bfd/elf32-avr.c

   1 /* AVR-specific support for 32-bit ELF
   2    Copyright 1999, 2000, 2001, 2002, 2003, 2004, 2006
   3    Free Software Foundation, Inc.
   4    Contributed by Denis Chertykov <denisc@overta.ru>
   5
   6    This file is part of BFD, the Binary File Descriptor library.
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 2 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 51 Franklin Street - Fifth Floor,
  21    Boston, MA 02110-1301, USA.  */
  22
  23 #include "bfd.h"
  24 #include "sysdep.h"
  25 #include "libbfd.h"
  26 #include "elf-bfd.h"
  27 #include "elf/avr.h"
  28
  29 static reloc_howto_type elf_avr_howto_table[] =
  30 {
  31   HOWTO (R_AVR_NONE,            /* type */
  32          0,                     /* rightshift */
  33          2,                     /* size (0 = byte, 1 = short, 2 = long) */
  34          32,                    /* bitsize */
  35          FALSE,                 /* pc_relative */
  36          0,                     /* bitpos */
  37          complain_overflow_bitfield, /* complain_on_overflow */
  38          bfd_elf_generic_reloc, /* special_function */
  39          "R_AVR_NONE",          /* name */
  40          FALSE,                 /* partial_inplace */
  41          0,                     /* src_mask */
  42          0,                     /* dst_mask */
  43          FALSE),                /* pcrel_offset */
  44
  45   HOWTO (R_AVR_32,              /* type */
  46          0,                     /* rightshift */
  47          2,                     /* size (0 = byte, 1 = short, 2 = long) */
  48          32,                    /* bitsize */
  49          FALSE,                 /* pc_relative */
  50          0,                     /* bitpos */
  51          complain_overflow_bitfield, /* complain_on_overflow */
  52          bfd_elf_generic_reloc, /* special_function */
  53          "R_AVR_32",            /* name */
  54          FALSE,                 /* partial_inplace */
  55          0xffffffff,            /* src_mask */
  56          0xffffffff,            /* dst_mask */
  57          FALSE),                /* pcrel_offset */
  58
  59   /* A 7 bit PC relative relocation.  */
  60   HOWTO (R_AVR_7_PCREL,         /* type */
  61          1,                     /* rightshift */
  62          1,                     /* size (0 = byte, 1 = short, 2 = long) */
  63          7,                     /* bitsize */
  64          TRUE,                  /* pc_relative */
  65          3,                     /* bitpos */
  66          complain_overflow_bitfield, /* complain_on_overflow */
  67          bfd_elf_generic_reloc, /* special_function */
  68          "R_AVR_7_PCREL",       /* name */
  69          FALSE,                 /* partial_inplace */
  70          0xffff,                /* src_mask */
  71          0xffff,                /* dst_mask */
  72          TRUE),                 /* pcrel_offset */
  73
  74   /* A 13 bit PC relative relocation.  */
  75   HOWTO (R_AVR_13_PCREL,        /* type */
  76          1,                     /* rightshift */
  77          1,                     /* size (0 = byte, 1 = short, 2 = long) */
  78          13,                    /* bitsize */
  79          TRUE,                  /* pc_relative */
  80          0,                     /* bitpos */
  81          complain_overflow_bitfield, /* complain_on_overflow */
  82          bfd_elf_generic_reloc, /* special_function */
  83          "R_AVR_13_PCREL",      /* name */
  84          FALSE,                 /* partial_inplace */
  85          0xfff,                 /* src_mask */
  86          0xfff,                 /* dst_mask */
  87          TRUE),                 /* pcrel_offset */
  88
  89   /* A 16 bit absolute relocation.  */
  90   HOWTO (R_AVR_16,              /* type */
  91          0,                     /* rightshift */
  92          1,                     /* size (0 = byte, 1 = short, 2 = long) */
  93          16,                    /* bitsize */
  94          FALSE,                 /* pc_relative */
  95          0,                     /* bitpos */
  96          complain_overflow_dont, /* complain_on_overflow */
  97          bfd_elf_generic_reloc, /* special_function */
  98          "R_AVR_16",            /* name */
  99          FALSE,                 /* partial_inplace */
 100          0xffff,                /* src_mask */
 101          0xffff,                /* dst_mask */
 102          FALSE),                /* pcrel_offset */
 103
 104   /* A 16 bit absolute relocation for command address.  */
 105   HOWTO (R_AVR_16_PM,           /* type */
 106          1,                     /* rightshift */
 107          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 108          16,                    /* bitsize */
 109          FALSE,                 /* pc_relative */
 110          0,                     /* bitpos */
 111          complain_overflow_bitfield, /* complain_on_overflow */
 112          bfd_elf_generic_reloc, /* special_function */
 113          "R_AVR_16_PM",         /* name */
 114          FALSE,                 /* partial_inplace */
 115          0xffff,                /* src_mask */
 116          0xffff,                /* dst_mask */
 117          FALSE),                /* pcrel_offset */
 118   /* A low 8 bit absolute relocation of 16 bit address.
 119      For LDI command.  */
 120   HOWTO (R_AVR_LO8_LDI,         /* type */
 121          0,                     /* rightshift */
 122          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 123          8,                     /* bitsize */
 124          FALSE,                 /* pc_relative */
 125          0,                     /* bitpos */
 126          complain_overflow_dont, /* complain_on_overflow */
 127          bfd_elf_generic_reloc, /* special_function */
 128          "R_AVR_LO8_LDI",       /* name */
 129          FALSE,                 /* partial_inplace */
 130          0xffff,                /* src_mask */
 131          0xffff,                /* dst_mask */
 132          FALSE),                /* pcrel_offset */
 133   /* A high 8 bit absolute relocation of 16 bit address.
 134      For LDI command.  */
 135   HOWTO (R_AVR_HI8_LDI,         /* type */
 136          8,                     /* rightshift */
 137          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 138          8,                     /* bitsize */
 139          FALSE,                 /* pc_relative */
 140          0,                     /* bitpos */
 141          complain_overflow_dont, /* complain_on_overflow */
 142          bfd_elf_generic_reloc, /* special_function */
 143          "R_AVR_HI8_LDI",       /* name */
 144          FALSE,                 /* partial_inplace */
 145          0xffff,                /* src_mask */
 146          0xffff,                /* dst_mask */
 147          FALSE),                /* pcrel_offset */
 148   /* A high 6 bit absolute relocation of 22 bit address.
 149      For LDI command.  As well second most significant 8 bit value of
 150      a 32 bit link-time constant.  */
 151   HOWTO (R_AVR_HH8_LDI,         /* type */
 152          16,                    /* rightshift */
 153          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 154          8,                     /* bitsize */
 155          FALSE,                 /* pc_relative */
 156          0,                     /* bitpos */
 157          complain_overflow_dont, /* complain_on_overflow */
 158          bfd_elf_generic_reloc, /* special_function */
 159          "R_AVR_HH8_LDI",       /* name */
 160          FALSE,                 /* partial_inplace */
 161          0xffff,                /* src_mask */
 162          0xffff,                /* dst_mask */
 163          FALSE),                /* pcrel_offset */
 164   /* A negative low 8 bit absolute relocation of 16 bit address.
 165      For LDI command.  */
 166   HOWTO (R_AVR_LO8_LDI_NEG,     /* type */
 167          0,                     /* rightshift */
 168          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 169          8,                     /* bitsize */
 170          FALSE,                 /* pc_relative */
 171          0,                     /* bitpos */
 172          complain_overflow_dont, /* complain_on_overflow */
 173          bfd_elf_generic_reloc, /* special_function */
 174          "R_AVR_LO8_LDI_NEG",   /* name */
 175          FALSE,                 /* partial_inplace */
 176          0xffff,                /* src_mask */
 177          0xffff,                /* dst_mask */
 178          FALSE),                /* pcrel_offset */
 179   /* A negative high 8 bit absolute relocation of 16 bit address.
 180      For LDI command.  */
 181   HOWTO (R_AVR_HI8_LDI_NEG,     /* type */
 182          8,                     /* rightshift */
 183          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 184          8,                     /* bitsize */
 185          FALSE,                 /* pc_relative */
 186          0,                     /* bitpos */
 187          complain_overflow_dont, /* complain_on_overflow */
 188          bfd_elf_generic_reloc, /* special_function */
 189          "R_AVR_HI8_LDI_NEG",   /* name */
 190          FALSE,                 /* partial_inplace */
 191          0xffff,                /* src_mask */
 192          0xffff,                /* dst_mask */
 193          FALSE),                /* pcrel_offset */
 194   /* A negative high 6 bit absolute relocation of 22 bit address.
 195      For LDI command.  */
 196   HOWTO (R_AVR_HH8_LDI_NEG,     /* type */
 197          16,                    /* rightshift */
 198          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 199          8,                     /* bitsize */
 200          FALSE,                 /* pc_relative */
 201          0,                     /* bitpos */
 202          complain_overflow_dont, /* complain_on_overflow */
 203          bfd_elf_generic_reloc, /* special_function */
 204          "R_AVR_HH8_LDI_NEG",   /* name */
 205          FALSE,                 /* partial_inplace */
 206          0xffff,                /* src_mask */
 207          0xffff,                /* dst_mask */
 208          FALSE),                /* pcrel_offset */
 209   /* A low 8 bit absolute relocation of 24 bit program memory address.
 210      For LDI command.  */
 211   HOWTO (R_AVR_LO8_LDI_PM,      /* type */
 212          1,                     /* rightshift */
 213          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 214          8,                     /* bitsize */
 215          FALSE,                 /* pc_relative */
 216          0,                     /* bitpos */
 217          complain_overflow_dont, /* complain_on_overflow */
 218          bfd_elf_generic_reloc, /* special_function */
 219          "R_AVR_LO8_LDI_PM",    /* name */
 220          FALSE,                 /* partial_inplace */
 221          0xffff,                /* src_mask */
 222          0xffff,                /* dst_mask */
 223          FALSE),                /* pcrel_offset */
 224   /* A high 8 bit absolute relocation of 16 bit program memory address.
 225      For LDI command.  */
 226   HOWTO (R_AVR_HI8_LDI_PM,      /* type */
 227          9,                     /* rightshift */
 228          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 229          8,                     /* bitsize */
 230          FALSE,                 /* pc_relative */
 231          0,                     /* bitpos */
 232          complain_overflow_dont, /* complain_on_overflow */
 233          bfd_elf_generic_reloc, /* special_function */
 234          "R_AVR_HI8_LDI_PM",    /* name */
 235          FALSE,                 /* partial_inplace */
 236          0xffff,                /* src_mask */
 237          0xffff,                /* dst_mask */
 238          FALSE),                /* pcrel_offset */
 239   /* A high 8 bit absolute relocation of 24 bit program memory address.
 240      For LDI command.  */
 241   HOWTO (R_AVR_HH8_LDI_PM,      /* type */
 242          17,                    /* rightshift */
 243          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 244          8,                     /* bitsize */
 245          FALSE,                 /* pc_relative */
 246          0,                     /* bitpos */
 247          complain_overflow_dont, /* complain_on_overflow */
 248          bfd_elf_generic_reloc, /* special_function */
 249          "R_AVR_HH8_LDI_PM",    /* name */
 250          FALSE,                 /* partial_inplace */
 251          0xffff,                /* src_mask */
 252          0xffff,                /* dst_mask */
 253          FALSE),                /* pcrel_offset */
 254   /* A low 8 bit absolute relocation of a negative 24 bit
 255      program memory address.  For LDI command.  */
 256   HOWTO (R_AVR_LO8_LDI_PM_NEG,  /* type */
 257          1,                     /* rightshift */
 258          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 259          8,                     /* bitsize */
 260          FALSE,                 /* pc_relative */
 261          0,                     /* bitpos */
 262          complain_overflow_dont, /* complain_on_overflow */
 263          bfd_elf_generic_reloc, /* special_function */
 264          "R_AVR_LO8_LDI_PM_NEG", /* name */
 265          FALSE,                 /* partial_inplace */
 266          0xffff,                /* src_mask */
 267          0xffff,                /* dst_mask */
 268          FALSE),                /* pcrel_offset */
 269   /* A high 8 bit absolute relocation of a negative 16 bit
 270      program memory address.  For LDI command.  */
 271   HOWTO (R_AVR_HI8_LDI_PM_NEG,  /* type */
 272          9,                     /* rightshift */
 273          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 274          8,                     /* bitsize */
 275          FALSE,                 /* pc_relative */
 276          0,                     /* bitpos */
 277          complain_overflow_dont, /* complain_on_overflow */
 278          bfd_elf_generic_reloc, /* special_function */
 279          "R_AVR_HI8_LDI_PM_NEG", /* name */
 280          FALSE,                 /* partial_inplace */
 281          0xffff,                /* src_mask */
 282          0xffff,                /* dst_mask */
 283          FALSE),                /* pcrel_offset */
 284   /* A high 8 bit absolute relocation of a negative 24 bit
 285      program memory address.  For LDI command.  */
 286   HOWTO (R_AVR_HH8_LDI_PM_NEG,  /* type */
 287          17,                    /* rightshift */
 288          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 289          8,                     /* bitsize */
 290          FALSE,                 /* pc_relative */
 291          0,                     /* bitpos */
 292          complain_overflow_dont, /* complain_on_overflow */
 293          bfd_elf_generic_reloc, /* special_function */
 294          "R_AVR_HH8_LDI_PM_NEG", /* name */
 295          FALSE,                 /* partial_inplace */
 296          0xffff,                /* src_mask */
 297          0xffff,                /* dst_mask */
 298          FALSE),                /* pcrel_offset */
 299   /* Relocation for CALL command in ATmega.  */
 300   HOWTO (R_AVR_CALL,            /* type */
 301          1,                     /* rightshift */
 302          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 303          23,                    /* 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_CALL",          /* name */
 309          FALSE,                 /* partial_inplace */
 310          0xffffffff,            /* src_mask */
 311          0xffffffff,            /* dst_mask */
 312          FALSE),                        /* pcrel_offset */
 313   /* A 16 bit absolute relocation of 16 bit address.
 314      For LDI command.  */
 315   HOWTO (R_AVR_LDI,             /* type */
 316          0,                     /* rightshift */
 317          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 318          16,                    /* 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_LDI",           /* name */
 324          FALSE,                 /* partial_inplace */
 325          0xffff,                /* src_mask */
 326          0xffff,                /* dst_mask */
 327          FALSE),                /* pcrel_offset */
 328   /* A 6 bit absolute relocation of 6 bit offset.
 329      For ldd/sdd command.  */
 330   HOWTO (R_AVR_6,               /* type */
 331          0,                     /* rightshift */
 332          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 333          6,                     /* 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_6",             /* name */
 339          FALSE,                 /* partial_inplace */
 340          0xffff,                /* src_mask */
 341          0xffff,                /* dst_mask */
 342          FALSE),                /* pcrel_offset */
 343   /* A 6 bit absolute relocation of 6 bit offset.
 344      For sbiw/adiw command.  */
 345   HOWTO (R_AVR_6_ADIW,          /* type */
 346          0,                     /* rightshift */
 347          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 348          6,                     /* 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_6_ADIW",        /* name */
 354          FALSE,                 /* partial_inplace */
 355          0xffff,                /* src_mask */
 356          0xffff,                /* dst_mask */
 357          FALSE),                /* pcrel_offset */
 358   /* Most significant 8 bit value of a 32 bit link-time constant.  */
 359   HOWTO (R_AVR_MS8_LDI,         /* type */
 360          24,                    /* rightshift */
 361          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 362          8,                     /* bitsize */
 363          FALSE,                 /* pc_relative */
 364          0,                     /* bitpos */
 365          complain_overflow_dont, /* complain_on_overflow */
 366          bfd_elf_generic_reloc, /* special_function */
 367          "R_AVR_MS8_LDI",       /* name */
 368          FALSE,                 /* partial_inplace */
 369          0xffff,                /* src_mask */
 370          0xffff,                /* dst_mask */
 371          FALSE),                /* pcrel_offset */
 372   /* Negative most significant 8 bit value of a 32 bit link-time constant.  */
 373   HOWTO (R_AVR_MS8_LDI_NEG,     /* type */
 374          24,                    /* rightshift */
 375          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 376          8,                     /* bitsize */
 377          FALSE,                 /* pc_relative */
 378          0,                     /* bitpos */
 379          complain_overflow_dont, /* complain_on_overflow */
 380          bfd_elf_generic_reloc, /* special_function */
 381          "R_AVR_MS8_LDI_NEG",   /* name */
 382          FALSE,                 /* partial_inplace */
 383          0xffff,                /* src_mask */
 384          0xffff,                /* dst_mask */
 385          FALSE)                 /* pcrel_offset */
 386 };
 387
 388 /* Map BFD reloc types to AVR ELF reloc types.  */
 389
 390 struct avr_reloc_map
 391 {
 392   bfd_reloc_code_real_type bfd_reloc_val;
 393   unsigned int elf_reloc_val;
 394 };
 395
 396  static const struct avr_reloc_map avr_reloc_map[] =
 397 {
 398   { BFD_RELOC_NONE,                 R_AVR_NONE },
 399   { BFD_RELOC_32,                   R_AVR_32 },
 400   { BFD_RELOC_AVR_7_PCREL,          R_AVR_7_PCREL },
 401   { BFD_RELOC_AVR_13_PCREL,         R_AVR_13_PCREL },
 402   { BFD_RELOC_16,                   R_AVR_16 },
 403   { BFD_RELOC_AVR_16_PM,            R_AVR_16_PM },
 404   { BFD_RELOC_AVR_LO8_LDI,          R_AVR_LO8_LDI},
 405   { BFD_RELOC_AVR_HI8_LDI,          R_AVR_HI8_LDI },
 406   { BFD_RELOC_AVR_HH8_LDI,          R_AVR_HH8_LDI },
 407   { BFD_RELOC_AVR_MS8_LDI,          R_AVR_MS8_LDI },
 408   { BFD_RELOC_AVR_LO8_LDI_NEG,      R_AVR_LO8_LDI_NEG },
 409   { BFD_RELOC_AVR_HI8_LDI_NEG,      R_AVR_HI8_LDI_NEG },
 410   { BFD_RELOC_AVR_HH8_LDI_NEG,      R_AVR_HH8_LDI_NEG },
 411   { BFD_RELOC_AVR_MS8_LDI_NEG,      R_AVR_MS8_LDI_NEG },
 412   { BFD_RELOC_AVR_LO8_LDI_PM,       R_AVR_LO8_LDI_PM },
 413   { BFD_RELOC_AVR_HI8_LDI_PM,       R_AVR_HI8_LDI_PM },
 414   { BFD_RELOC_AVR_HH8_LDI_PM,       R_AVR_HH8_LDI_PM },
 415   { BFD_RELOC_AVR_LO8_LDI_PM_NEG,   R_AVR_LO8_LDI_PM_NEG },
 416   { BFD_RELOC_AVR_HI8_LDI_PM_NEG,   R_AVR_HI8_LDI_PM_NEG },
 417   { BFD_RELOC_AVR_HH8_LDI_PM_NEG,   R_AVR_HH8_LDI_PM_NEG },
 418   { BFD_RELOC_AVR_CALL,             R_AVR_CALL },
 419   { BFD_RELOC_AVR_LDI,              R_AVR_LDI  },
 420   { BFD_RELOC_AVR_6,                R_AVR_6    },
 421   { BFD_RELOC_AVR_6_ADIW,           R_AVR_6_ADIW }
 422 };
 423
 424 /* Meant to be filled one day with the wrap around address for the
 425    specific device.  I.e. should get the value 0x4000 for 16k devices,
 426    0x8000 for 32k devices and so on.
 427
 428    We initialize it here with a value of 0x1000000 resulting in
 429    that we will never suggest a wrap-around jump during relaxation.
 430    The logic of the source code later on assumes that in
 431    avr_pc_wrap_around one single bit is set.  */
 432
 433 unsigned int avr_pc_wrap_around = 0x10000000;
 434
 435 /* Calculates the effective distance of a pc relative jump/call.  */
 436 static int
 437 avr_relative_distance_considering_wrap_around (unsigned int distance)
 438 {
 439   unsigned int wrap_around_mask = avr_pc_wrap_around - 1;
 440   int dist_with_wrap_around = distance & wrap_around_mask;
 441
 442   if (dist_with_wrap_around > ((int) (avr_pc_wrap_around >> 1)))
 443     dist_with_wrap_around -= avr_pc_wrap_around;
 444
 445   return dist_with_wrap_around;
 446 }
 447
 448
 449 static reloc_howto_type *
 450 bfd_elf32_bfd_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
 451                                  bfd_reloc_code_real_type code)
 452 {
 453   unsigned int i;
 454
 455   for (i = 0;
 456        i < sizeof (avr_reloc_map) / sizeof (struct avr_reloc_map);
 457        i++)
 458     {
 459       if (avr_reloc_map[i].bfd_reloc_val == code)
 460         return &elf_avr_howto_table[avr_reloc_map[i].elf_reloc_val];
 461     }
 462
 463   return NULL;
 464 }
 465
 466 /* Set the howto pointer for an AVR ELF reloc.  */
 467
 468 static void
 469 avr_info_to_howto_rela (bfd *abfd ATTRIBUTE_UNUSED,
 470                         arelent *cache_ptr,
 471                         Elf_Internal_Rela *dst)
 472 {
 473   unsigned int r_type;
 474
 475   r_type = ELF32_R_TYPE (dst->r_info);
 476   BFD_ASSERT (r_type < (unsigned int) R_AVR_max);
 477   cache_ptr->howto = &elf_avr_howto_table[r_type];
 478 }
 479
 480 static asection *
 481 elf32_avr_gc_mark_hook (asection *sec,
 482                         struct bfd_link_info *info ATTRIBUTE_UNUSED,
 483                         Elf_Internal_Rela *rel,
 484                         struct elf_link_hash_entry *h,
 485                         Elf_Internal_Sym *sym)
 486 {
 487   if (h != NULL)
 488     {
 489       switch (ELF32_R_TYPE (rel->r_info))
 490         {
 491         default:
 492           switch (h->root.type)
 493             {
 494             case bfd_link_hash_defined:
 495             case bfd_link_hash_defweak:
 496               return h->root.u.def.section;
 497
 498             case bfd_link_hash_common:
 499               return h->root.u.c.p->section;
 500
 501             default:
 502               break;
 503             }
 504         }
 505     }
 506   else
 507     return bfd_section_from_elf_index (sec->owner, sym->st_shndx);
 508
 509   return NULL;
 510 }
 511
 512 static bfd_boolean
 513 elf32_avr_gc_sweep_hook (bfd *abfd ATTRIBUTE_UNUSED,
 514                          struct bfd_link_info *info ATTRIBUTE_UNUSED,
 515                          asection *sec ATTRIBUTE_UNUSED,
 516                          const Elf_Internal_Rela *relocs ATTRIBUTE_UNUSED)
 517 {
 518   /* We don't use got and plt entries for avr.  */
 519   return TRUE;
 520 }
 521
 522 /* Look through the relocs for a section during the first phase.
 523    Since we don't do .gots or .plts, we just need to consider the
 524    virtual table relocs for gc.  */
 525
 526 static bfd_boolean
 527 elf32_avr_check_relocs (bfd *abfd,
 528                         struct bfd_link_info *info,
 529                         asection *sec,
 530                         const Elf_Internal_Rela *relocs)
 531 {
 532   Elf_Internal_Shdr *symtab_hdr;
 533   struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;
 534   const Elf_Internal_Rela *rel;
 535   const Elf_Internal_Rela *rel_end;
 536
 537   if (info->relocatable)
 538     return TRUE;
 539
 540   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
 541   sym_hashes = elf_sym_hashes (abfd);
 542   sym_hashes_end = sym_hashes + symtab_hdr->sh_size / sizeof (Elf32_External_Sym);
 543   if (!elf_bad_symtab (abfd))
 544     sym_hashes_end -= symtab_hdr->sh_info;
 545
 546   rel_end = relocs + sec->reloc_count;
 547   for (rel = relocs; rel < rel_end; rel++)
 548     {
 549       struct elf_link_hash_entry *h;
 550       unsigned long r_symndx;
 551
 552       r_symndx = ELF32_R_SYM (rel->r_info);
 553       if (r_symndx < symtab_hdr->sh_info)
 554         h = NULL;
 555       else
 556         {
 557           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
 558           while (h->root.type == bfd_link_hash_indirect
 559                  || h->root.type == bfd_link_hash_warning)
 560             h = (struct elf_link_hash_entry *) h->root.u.i.link;
 561         }
 562     }
 563
 564   return TRUE;
 565 }
 566
 567 /* Perform a single relocation.  By default we use the standard BFD
 568    routines, but a few relocs, we have to do them ourselves.  */
 569
 570 static bfd_reloc_status_type
 571 avr_final_link_relocate (reloc_howto_type *  howto,
 572                          bfd *               input_bfd,
 573                          asection *          input_section,
 574                          bfd_byte *          contents,
 575                          Elf_Internal_Rela * rel,
 576                          bfd_vma             relocation)
 577 {
 578   bfd_reloc_status_type r = bfd_reloc_ok;
 579   bfd_vma               x;
 580   bfd_signed_vma        srel;
 581
 582   switch (howto->type)
 583     {
 584     case R_AVR_7_PCREL:
 585       contents += rel->r_offset;
 586       srel = (bfd_signed_vma) relocation;
 587       srel += rel->r_addend;
 588       srel -= rel->r_offset;
 589       srel -= 2;        /* Branch instructions add 2 to the PC...  */
 590       srel -= (input_section->output_section->vma +
 591                input_section->output_offset);
 592
 593       if (srel & 1)
 594         return bfd_reloc_outofrange;
 595       if (srel > ((1 << 7) - 1) || (srel < - (1 << 7)))
 596         return bfd_reloc_overflow;
 597       x = bfd_get_16 (input_bfd, contents);
 598       x = (x & 0xfc07) | (((srel >> 1) << 3) & 0x3f8);
 599       bfd_put_16 (input_bfd, x, contents);
 600       break;
 601
 602     case R_AVR_13_PCREL:
 603       contents   += rel->r_offset;
 604       srel = (bfd_signed_vma) relocation;
 605       srel += rel->r_addend;
 606       srel -= rel->r_offset;
 607       srel -= 2;        /* Branch instructions add 2 to the PC...  */
 608       srel -= (input_section->output_section->vma +
 609                input_section->output_offset);
 610
 611       if (srel & 1)
 612         return bfd_reloc_outofrange;
 613
 614       srel = avr_relative_distance_considering_wrap_around (srel);
 615
 616       /* AVR addresses commands as words.  */
 617       srel >>= 1;
 618
 619       /* Check for overflow.  */
 620       if (srel < -2048 || srel > 2047)
 621         {
 622           /* Relative distance is too large.  */
 623
 624           /* Always apply WRAPAROUND for avr2 and avr4.  */
 625           switch (bfd_get_mach (input_bfd))
 626             {
 627             case bfd_mach_avr2:
 628             case bfd_mach_avr4:
 629               break;
 630
 631             default:
 632               return bfd_reloc_overflow;
 633             }
 634         }
 635
 636       x = bfd_get_16 (input_bfd, contents);
 637       x = (x & 0xf000) | (srel & 0xfff);
 638       bfd_put_16 (input_bfd, x, contents);
 639       break;
 640
 641     case R_AVR_LO8_LDI:
 642       contents += rel->r_offset;
 643       srel = (bfd_signed_vma) relocation + rel->r_addend;
 644       x = bfd_get_16 (input_bfd, contents);
 645       x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
 646       bfd_put_16 (input_bfd, x, contents);
 647       break;
 648
 649     case R_AVR_LDI:
 650       contents += rel->r_offset;
 651       srel = (bfd_signed_vma) relocation + rel->r_addend;
 652       if (((srel > 0) && (srel & 0xffff) > 255)
 653           || ((srel < 0) && ((-srel) & 0xffff) > 128))
 654         /* Remove offset for data/eeprom section.  */
 655         return bfd_reloc_overflow;
 656
 657       x = bfd_get_16 (input_bfd, contents);
 658       x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
 659       bfd_put_16 (input_bfd, x, contents);
 660       break;
 661
 662     case R_AVR_6:
 663       contents += rel->r_offset;
 664       srel = (bfd_signed_vma) relocation + rel->r_addend;
 665       if (((srel & 0xffff) > 63) || (srel < 0))
 666         /* Remove offset for data/eeprom section.  */
 667         return bfd_reloc_overflow;
 668       x = bfd_get_16 (input_bfd, contents);
 669       x = (x & 0xd3f8) | ((srel & 7) | ((srel & (3 << 3)) << 7)
 670                        | ((srel & (1 << 5)) << 8));
 671       bfd_put_16 (input_bfd, x, contents);
 672       break;
 673
 674     case R_AVR_6_ADIW:
 675       contents += rel->r_offset;
 676       srel = (bfd_signed_vma) relocation + rel->r_addend;
 677       if (((srel & 0xffff) > 63) || (srel < 0))
 678         /* Remove offset for data/eeprom section.  */
 679         return bfd_reloc_overflow;
 680       x = bfd_get_16 (input_bfd, contents);
 681       x = (x & 0xff30) | (srel & 0xf) | ((srel & 0x30) << 2);
 682       bfd_put_16 (input_bfd, x, contents);
 683       break;
 684
 685     case R_AVR_HI8_LDI:
 686       contents += rel->r_offset;
 687       srel = (bfd_signed_vma) relocation + rel->r_addend;
 688       srel = (srel >> 8) & 0xff;
 689       x = bfd_get_16 (input_bfd, contents);
 690       x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
 691       bfd_put_16 (input_bfd, x, contents);
 692       break;
 693
 694     case R_AVR_HH8_LDI:
 695       contents += rel->r_offset;
 696       srel = (bfd_signed_vma) relocation + rel->r_addend;
 697       srel = (srel >> 16) & 0xff;
 698       x = bfd_get_16 (input_bfd, contents);
 699       x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
 700       bfd_put_16 (input_bfd, x, contents);
 701       break;
 702
 703     case R_AVR_MS8_LDI:
 704       contents += rel->r_offset;
 705       srel = (bfd_signed_vma) relocation + rel->r_addend;
 706       srel = (srel >> 24) & 0xff;
 707       x = bfd_get_16 (input_bfd, contents);
 708       x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
 709       bfd_put_16 (input_bfd, x, contents);
 710       break;
 711
 712     case R_AVR_LO8_LDI_NEG:
 713       contents += rel->r_offset;
 714       srel = (bfd_signed_vma) relocation + rel->r_addend;
 715       srel = -srel;
 716       x = bfd_get_16 (input_bfd, contents);
 717       x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
 718       bfd_put_16 (input_bfd, x, contents);
 719       break;
 720
 721     case R_AVR_HI8_LDI_NEG:
 722       contents += rel->r_offset;
 723       srel = (bfd_signed_vma) relocation + rel->r_addend;
 724       srel = -srel;
 725       srel = (srel >> 8) & 0xff;
 726       x = bfd_get_16 (input_bfd, contents);
 727       x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
 728       bfd_put_16 (input_bfd, x, contents);
 729       break;
 730
 731     case R_AVR_HH8_LDI_NEG:
 732       contents += rel->r_offset;
 733       srel = (bfd_signed_vma) relocation + rel->r_addend;
 734       srel = -srel;
 735       srel = (srel >> 16) & 0xff;
 736       x = bfd_get_16 (input_bfd, contents);
 737       x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
 738       bfd_put_16 (input_bfd, x, contents);
 739       break;
 740
 741     case R_AVR_MS8_LDI_NEG:
 742       contents += rel->r_offset;
 743       srel = (bfd_signed_vma) relocation + rel->r_addend;
 744       srel = -srel;
 745       srel = (srel >> 24) & 0xff;
 746       x = bfd_get_16 (input_bfd, contents);
 747       x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
 748       bfd_put_16 (input_bfd, x, contents);
 749       break;
 750
 751     case R_AVR_LO8_LDI_PM:
 752       contents += rel->r_offset;
 753       srel = (bfd_signed_vma) relocation + rel->r_addend;
 754       if (srel & 1)
 755         return bfd_reloc_outofrange;
 756       srel = srel >> 1;
 757       x = bfd_get_16 (input_bfd, contents);
 758       x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
 759       bfd_put_16 (input_bfd, x, contents);
 760       break;
 761
 762     case R_AVR_HI8_LDI_PM:
 763       contents += rel->r_offset;
 764       srel = (bfd_signed_vma) relocation + rel->r_addend;
 765       if (srel & 1)
 766         return bfd_reloc_outofrange;
 767       srel = srel >> 1;
 768       srel = (srel >> 8) & 0xff;
 769       x = bfd_get_16 (input_bfd, contents);
 770       x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
 771       bfd_put_16 (input_bfd, x, contents);
 772       break;
 773
 774     case R_AVR_HH8_LDI_PM:
 775       contents += rel->r_offset;
 776       srel = (bfd_signed_vma) relocation + rel->r_addend;
 777       if (srel & 1)
 778         return bfd_reloc_outofrange;
 779       srel = srel >> 1;
 780       srel = (srel >> 16) & 0xff;
 781       x = bfd_get_16 (input_bfd, contents);
 782       x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
 783       bfd_put_16 (input_bfd, x, contents);
 784       break;
 785
 786     case R_AVR_LO8_LDI_PM_NEG:
 787       contents += rel->r_offset;
 788       srel = (bfd_signed_vma) relocation + rel->r_addend;
 789       srel = -srel;
 790       if (srel & 1)
 791         return bfd_reloc_outofrange;
 792       srel = srel >> 1;
 793       x = bfd_get_16 (input_bfd, contents);
 794       x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
 795       bfd_put_16 (input_bfd, x, contents);
 796       break;
 797
 798     case R_AVR_HI8_LDI_PM_NEG:
 799       contents += rel->r_offset;
 800       srel = (bfd_signed_vma) relocation + rel->r_addend;
 801       srel = -srel;
 802       if (srel & 1)
 803         return bfd_reloc_outofrange;
 804       srel = srel >> 1;
 805       srel = (srel >> 8) & 0xff;
 806       x = bfd_get_16 (input_bfd, contents);
 807       x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
 808       bfd_put_16 (input_bfd, x, contents);
 809       break;
 810
 811     case R_AVR_HH8_LDI_PM_NEG:
 812       contents += rel->r_offset;
 813       srel = (bfd_signed_vma) relocation + rel->r_addend;
 814       srel = -srel;
 815       if (srel & 1)
 816         return bfd_reloc_outofrange;
 817       srel = srel >> 1;
 818       srel = (srel >> 16) & 0xff;
 819       x = bfd_get_16 (input_bfd, contents);
 820       x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
 821       bfd_put_16 (input_bfd, x, contents);
 822       break;
 823
 824     case R_AVR_CALL:
 825       contents += rel->r_offset;
 826       srel = (bfd_signed_vma) relocation + rel->r_addend;
 827       if (srel & 1)
 828         return bfd_reloc_outofrange;
 829       srel = srel >> 1;
 830       x = bfd_get_16 (input_bfd, contents);
 831       x |= ((srel & 0x10000) | ((srel << 3) & 0x1f00000)) >> 16;
 832       bfd_put_16 (input_bfd, x, contents);
 833       bfd_put_16 (input_bfd, (bfd_vma) srel & 0xffff, contents+2);
 834       break;
 835
 836     default:
 837       r = _bfd_final_link_relocate (howto, input_bfd, input_section,
 838                                     contents, rel->r_offset,
 839                                     relocation, rel->r_addend);
 840     }
 841
 842   return r;
 843 }
 844
 845 /* Relocate an AVR ELF section.  */
 846
 847 static bfd_boolean
 848 elf32_avr_relocate_section (bfd *output_bfd ATTRIBUTE_UNUSED,
 849                             struct bfd_link_info *info,
 850                             bfd *input_bfd,
 851                             asection *input_section,
 852                             bfd_byte *contents,
 853                             Elf_Internal_Rela *relocs,
 854                             Elf_Internal_Sym *local_syms,
 855                             asection **local_sections)
 856 {
 857   Elf_Internal_Shdr *           symtab_hdr;
 858   struct elf_link_hash_entry ** sym_hashes;
 859   Elf_Internal_Rela *           rel;
 860   Elf_Internal_Rela *           relend;
 861
 862   if (info->relocatable)
 863     return TRUE;
 864
 865   symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
 866   sym_hashes = elf_sym_hashes (input_bfd);
 867   relend     = relocs + input_section->reloc_count;
 868
 869   for (rel = relocs; rel < relend; rel ++)
 870     {
 871       reloc_howto_type *           howto;
 872       unsigned long                r_symndx;
 873       Elf_Internal_Sym *           sym;
 874       asection *                   sec;
 875       struct elf_link_hash_entry * h;
 876       bfd_vma                      relocation;
 877       bfd_reloc_status_type        r;
 878       const char *                 name;
 879       int                          r_type;
 880
 881       /* This is a final link.  */
 882       r_type = ELF32_R_TYPE (rel->r_info);
 883       r_symndx = ELF32_R_SYM (rel->r_info);
 884       howto  = elf_avr_howto_table + ELF32_R_TYPE (rel->r_info);
 885       h      = NULL;
 886       sym    = NULL;
 887       sec    = NULL;
 888
 889       if (r_symndx < symtab_hdr->sh_info)
 890         {
 891           sym = local_syms + r_symndx;
 892           sec = local_sections [r_symndx];
 893           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
 894
 895           name = bfd_elf_string_from_elf_section
 896             (input_bfd, symtab_hdr->sh_link, sym->st_name);
 897           name = (name == NULL) ? bfd_section_name (input_bfd, sec) : name;
 898         }
 899       else
 900         {
 901           bfd_boolean unresolved_reloc, warned;
 902
 903           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
 904                                    r_symndx, symtab_hdr, sym_hashes,
 905                                    h, sec, relocation,
 906                                    unresolved_reloc, warned);
 907
 908           name = h->root.root.string;
 909         }
 910
 911       r = avr_final_link_relocate (howto, input_bfd, input_section,
 912                                    contents, rel, relocation);
 913
 914       if (r != bfd_reloc_ok)
 915         {
 916           const char * msg = (const char *) NULL;
 917
 918           switch (r)
 919             {
 920             case bfd_reloc_overflow:
 921               r = info->callbacks->reloc_overflow
 922                 (info, (h ? &h->root : NULL),
 923                  name, howto->name, (bfd_vma) 0,
 924                  input_bfd, input_section, rel->r_offset);
 925               break;
 926
 927             case bfd_reloc_undefined:
 928               r = info->callbacks->undefined_symbol
 929                 (info, name, input_bfd, input_section, rel->r_offset, TRUE);
 930               break;
 931
 932             case bfd_reloc_outofrange:
 933               msg = _("internal error: out of range error");
 934               break;
 935
 936             case bfd_reloc_notsupported:
 937               msg = _("internal error: unsupported relocation error");
 938               break;
 939
 940             case bfd_reloc_dangerous:
 941               msg = _("internal error: dangerous relocation");
 942               break;
 943
 944             default:
 945               msg = _("internal error: unknown error");
 946               break;
 947             }
 948
 949           if (msg)
 950             r = info->callbacks->warning
 951               (info, msg, name, input_bfd, input_section, rel->r_offset);
 952
 953           if (! r)
 954             return FALSE;
 955         }
 956     }
 957
 958   return TRUE;
 959 }
 960
 961 /* The final processing done just before writing out a AVR ELF object
 962    file.  This gets the AVR architecture right based on the machine
 963    number.  */
 964
 965 static void
 966 bfd_elf_avr_final_write_processing (bfd *abfd,
 967                                     bfd_boolean linker ATTRIBUTE_UNUSED)
 968 {
 969   unsigned long val;
 970
 971   switch (bfd_get_mach (abfd))
 972     {
 973     default:
 974     case bfd_mach_avr2:
 975       val = E_AVR_MACH_AVR2;
 976       break;
 977
 978     case bfd_mach_avr1:
 979       val = E_AVR_MACH_AVR1;
 980       break;
 981
 982     case bfd_mach_avr3:
 983       val = E_AVR_MACH_AVR3;
 984       break;
 985
 986     case bfd_mach_avr4:
 987       val = E_AVR_MACH_AVR4;
 988       break;
 989
 990     case bfd_mach_avr5:
 991       val = E_AVR_MACH_AVR5;
 992       break;
 993     }
 994
 995   elf_elfheader (abfd)->e_machine = EM_AVR;
 996   elf_elfheader (abfd)->e_flags &= ~ EF_AVR_MACH;
 997   elf_elfheader (abfd)->e_flags |= val;
 998   elf_elfheader (abfd)->e_flags |= EF_AVR_LINKRELAX_PREPARED;
 999 }
1000
1001 /* Set the right machine number.  */
1002
1003 static bfd_boolean
1004 elf32_avr_object_p (bfd *abfd)
1005 {
1006   unsigned int e_set = bfd_mach_avr2;
1007
1008   if (elf_elfheader (abfd)->e_machine == EM_AVR
1009       || elf_elfheader (abfd)->e_machine == EM_AVR_OLD)
1010     {
1011       int e_mach = elf_elfheader (abfd)->e_flags & EF_AVR_MACH;
1012
1013       switch (e_mach)
1014         {
1015         default:
1016         case E_AVR_MACH_AVR2:
1017           e_set = bfd_mach_avr2;
1018           break;
1019
1020         case E_AVR_MACH_AVR1:
1021           e_set = bfd_mach_avr1;
1022           break;
1023
1024         case E_AVR_MACH_AVR3:
1025           e_set = bfd_mach_avr3;
1026           break;
1027
1028         case E_AVR_MACH_AVR4:
1029           e_set = bfd_mach_avr4;
1030           break;
1031
1032         case E_AVR_MACH_AVR5:
1033           e_set = bfd_mach_avr5;
1034           break;
1035         }
1036     }
1037   return bfd_default_set_arch_mach (abfd, bfd_arch_avr,
1038                                     e_set);
1039 }
1040
1041
1042 /* Enable debugging printout at stdout with a value of 1.  */
1043 #define DEBUG_RELAX 0
1044
1045 /* Delete some bytes from a section while changing the size of an instruction.
1046    The parameter "addr" denotes the section-relative offset pointing just
1047    behind the shrinked instruction. "addr+count" point at the first
1048    byte just behind the original unshrinked instruction.  */
1049
1050 static bfd_boolean
1051 elf32_avr_relax_delete_bytes (bfd *abfd,
1052                               asection *sec,
1053                               bfd_vma addr,
1054                               int count)
1055 {
1056   Elf_Internal_Shdr *symtab_hdr;
1057   unsigned int sec_shndx;
1058   bfd_byte *contents;
1059   Elf_Internal_Rela *irel, *irelend;
1060   Elf_Internal_Rela *irelalign;
1061   Elf_Internal_Sym *isym;
1062   Elf_Internal_Sym *isymbuf = NULL;
1063   Elf_Internal_Sym *isymend;
1064   bfd_vma toaddr;
1065   struct elf_link_hash_entry **sym_hashes;
1066   struct elf_link_hash_entry **end_hashes;
1067   unsigned int symcount;
1068
1069   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1070   sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
1071   contents = elf_section_data (sec)->this_hdr.contents;
1072
1073   /* The deletion must stop at the next ALIGN reloc for an aligment
1074      power larger than the number of bytes we are deleting.  */
1075
1076   irelalign = NULL;
1077   toaddr = sec->size;
1078
1079   irel = elf_section_data (sec)->relocs;
1080   irelend = irel + sec->reloc_count;
1081
1082   /* Actually delete the bytes.  */
1083   if (toaddr - addr - count > 0)
1084     memmove (contents + addr, contents + addr + count,
1085              (size_t) (toaddr - addr - count));
1086   sec->size -= count;
1087
1088   /* Adjust all the relocs.  */
1089   for (irel = elf_section_data (sec)->relocs; irel < irelend; irel++)
1090     {
1091       bfd_vma symval;
1092       bfd_vma old_reloc_address;
1093       bfd_vma shrinked_insn_address;
1094
1095       old_reloc_address = (sec->output_section->vma
1096                            + sec->output_offset + irel->r_offset);
1097       shrinked_insn_address = (sec->output_section->vma
1098                               + sec->output_offset + addr - count);
1099
1100       /* Get the new reloc address.  */
1101       if ((irel->r_offset > addr
1102            && irel->r_offset < toaddr))
1103         {
1104           if (DEBUG_RELAX)
1105             printf ("Relocation at address 0x%x needs to be moved.\n"
1106                     "Old section offset: 0x%x, New section offset: 0x%x \n",
1107                     (unsigned int) old_reloc_address,
1108                     (unsigned int) irel->r_offset,
1109                     (unsigned int) ((irel->r_offset) - count));
1110
1111           irel->r_offset -= count;
1112         }
1113
1114       /* The reloc's own addresses are now ok. However, we need to readjust
1115          the reloc's addend if two conditions are met:
1116          1.) the reloc is relative to a symbol in this section that
1117              is located in front of the shrinked instruction
1118          2.) symbol plus addend end up behind the shrinked instruction.
1119
1120          This should happen only for local symbols that are progmem related.  */
1121
1122       /* Read this BFD's local symbols if we haven't done so already.  */
1123       if (isymbuf == NULL && symtab_hdr->sh_info != 0)
1124         {
1125           isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
1126           if (isymbuf == NULL)
1127             isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
1128                                             symtab_hdr->sh_info, 0,
1129                                             NULL, NULL, NULL);
1130           if (isymbuf == NULL)
1131              return FALSE;
1132          }
1133
1134       /* Get the value of the symbol referred to by the reloc.  */
1135       if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
1136         {
1137           /* A local symbol.  */
1138           Elf_Internal_Sym *isym;
1139           asection *sym_sec;
1140
1141           isym = isymbuf + ELF32_R_SYM (irel->r_info);
1142           sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
1143           symval = isym->st_value;
1144           /* If the reloc is absolute, it will not have
1145              a symbol or section associated with it.  */
1146           if (sym_sec)
1147             {
1148                symval += sym_sec->output_section->vma
1149                          + sym_sec->output_offset;
1150
1151                if (DEBUG_RELAX)
1152                 printf ("Checking if the relocation's "
1153                         "addend needs corrections.\n"
1154                         "Address of anchor symbol: 0x%x \n"
1155                         "Address of relocation target: 0x%x \n"
1156                         "Address of relaxed insn: 0x%x \n",
1157                         (unsigned int) symval,
1158                         (unsigned int) (symval + irel->r_addend),
1159                         (unsigned int) shrinked_insn_address);
1160
1161                if (symval <= shrinked_insn_address
1162                    && (symval + irel->r_addend) > shrinked_insn_address)
1163                  {
1164                    irel->r_addend -= count;
1165
1166                    if (DEBUG_RELAX)
1167                      printf ("Anchor symbol and relocation target bracket "
1168                              "shrinked insn address.\n"
1169                              "Need for new addend : 0x%x\n",
1170                              (unsigned int) irel->r_addend);
1171                  }
1172             }
1173           /* else ... Reference symbol is absolute.  No adjustment needed.  */
1174         }
1175       /* else ... Reference symbol is extern. No need for adjusting the addend.  */
1176     }
1177
1178   /* Adjust the local symbols defined in this section.  */
1179   isym = (Elf_Internal_Sym *) symtab_hdr->contents;
1180   isymend = isym + symtab_hdr->sh_info;
1181   for (; isym < isymend; isym++)
1182     {
1183       if (isym->st_shndx == sec_shndx
1184           && isym->st_value > addr
1185           && isym->st_value < toaddr)
1186         isym->st_value -= count;
1187     }
1188
1189   /* Now adjust the global symbols defined in this section.  */
1190   symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
1191               - symtab_hdr->sh_info);
1192   sym_hashes = elf_sym_hashes (abfd);
1193   end_hashes = sym_hashes + symcount;
1194   for (; sym_hashes < end_hashes; sym_hashes++)
1195     {
1196       struct elf_link_hash_entry *sym_hash = *sym_hashes;
1197       if ((sym_hash->root.type == bfd_link_hash_defined
1198            || sym_hash->root.type == bfd_link_hash_defweak)
1199           && sym_hash->root.u.def.section == sec
1200           && sym_hash->root.u.def.value > addr
1201           && sym_hash->root.u.def.value < toaddr)
1202         {
1203           sym_hash->root.u.def.value -= count;
1204         }
1205     }
1206
1207   return TRUE;
1208 }
1209
1210 /* This function handles relaxing for the avr.
1211    Many important relaxing opportunities within functions are already
1212    realized by the compiler itself.
1213    Here we try to replace  call (4 bytes) ->  rcall (2 bytes)
1214    and jump -> rjmp (safes also 2 bytes).
1215    As well we now optimize seqences of
1216      - call/rcall function
1217      - ret
1218    to yield
1219      - jmp/rjmp function
1220      - ret
1221    . In case that within a sequence
1222      - jmp/rjmp label
1223      - ret
1224    the ret could no longer be reached it is optimized away. In order
1225    to check if the ret is no longer needed, it is checked that the ret's address
1226    is not the target of a branch or jump within the same section, it is checked
1227    that there is no skip instruction before the jmp/rjmp and that there
1228    is no local or global label place at the address of the ret.
1229
1230    We refrain from relaxing within sections ".vectors" and
1231    ".jumptables" in order to maintain the position of the instructions.
1232    There, however, we substitute jmp/call by a sequence rjmp,nop/rcall,nop
1233    if possible. (In future one could possibly use the space of the nop
1234    for the first instruction of the irq service function.
1235
1236    The .jumptables sections is meant to be used for a future tablejump variant
1237    for the devices with 3-byte program counter where the table itself
1238    contains 4-byte jump instructions whose relative offset must not
1239    be changed.  */
1240
1241 static  bfd_boolean
1242 elf32_avr_relax_section (bfd *abfd,
1243                          asection *sec,
1244                          struct bfd_link_info *link_info,
1245                          bfd_boolean *again)
1246 {
1247   Elf_Internal_Shdr *symtab_hdr;
1248   Elf_Internal_Rela *internal_relocs;
1249   Elf_Internal_Rela *irel, *irelend;
1250   bfd_byte *contents = NULL;
1251   Elf_Internal_Sym *isymbuf = NULL;
1252   static asection *last_input_section = NULL;
1253   static Elf_Internal_Rela *last_reloc = NULL;
1254
1255   /* Assume nothing changes.  */
1256   *again = FALSE;
1257
1258   /* We don't have to do anything for a relocatable link, if
1259      this section does not have relocs, or if this is not a
1260      code section.  */
1261   if (link_info->relocatable
1262       || (sec->flags & SEC_RELOC) == 0
1263       || sec->reloc_count == 0
1264       || (sec->flags & SEC_CODE) == 0)
1265     return TRUE;
1266
1267   /* Check if the object file to relax uses internal symbols so that we
1268      could fix up the relocations.  */
1269   if (!(elf_elfheader (abfd)->e_flags & EF_AVR_LINKRELAX_PREPARED))
1270     return TRUE;
1271
1272   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1273
1274   /* Get a copy of the native relocations.  */
1275   internal_relocs = (_bfd_elf_link_read_relocs
1276                      (abfd, sec, NULL, NULL, link_info->keep_memory));
1277   if (internal_relocs == NULL)
1278     goto error_return;
1279
1280   if (sec != last_input_section)
1281     last_reloc = NULL;
1282
1283   last_input_section = sec;
1284
1285   /* Walk through the relocs looking for relaxing opportunities.  */
1286   irelend = internal_relocs + sec->reloc_count;
1287   for (irel = internal_relocs; irel < irelend; irel++)
1288     {
1289       bfd_vma symval;
1290
1291       if (   ELF32_R_TYPE (irel->r_info) != R_AVR_13_PCREL
1292           && ELF32_R_TYPE (irel->r_info) != R_AVR_7_PCREL
1293           && ELF32_R_TYPE (irel->r_info) != R_AVR_CALL)
1294         continue;
1295
1296       /* Get the section contents if we haven't done so already.  */
1297       if (contents == NULL)
1298         {
1299           /* Get cached copy if it exists.  */
1300           if (elf_section_data (sec)->this_hdr.contents != NULL)
1301             contents = elf_section_data (sec)->this_hdr.contents;
1302           else
1303             {
1304               /* Go get them off disk.  */
1305               if (! bfd_malloc_and_get_section (abfd, sec, &contents))
1306                 goto error_return;
1307             }
1308         }
1309
1310      /* Read this BFD's local symbols if we haven't done so already.  */
1311       if (isymbuf == NULL && symtab_hdr->sh_info != 0)
1312         {
1313           isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
1314           if (isymbuf == NULL)
1315             isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
1316                                             symtab_hdr->sh_info, 0,
1317                                             NULL, NULL, NULL);
1318           if (isymbuf == NULL)
1319             goto error_return;
1320         }
1321
1322
1323       /* Get the value of the symbol referred to by the reloc.  */
1324       if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
1325         {
1326           /* A local symbol.  */
1327           Elf_Internal_Sym *isym;
1328           asection *sym_sec;
1329
1330           isym = isymbuf + ELF32_R_SYM (irel->r_info);
1331           sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
1332           symval = isym->st_value;
1333           /* If the reloc is absolute, it will not have
1334              a symbol or section associated with it.  */
1335           if (sym_sec)
1336             symval += sym_sec->output_section->vma
1337               + sym_sec->output_offset;
1338         }
1339       else
1340         {
1341           unsigned long indx;
1342           struct elf_link_hash_entry *h;
1343
1344           /* An external symbol.  */
1345           indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
1346           h = elf_sym_hashes (abfd)[indx];
1347           BFD_ASSERT (h != NULL);
1348           if (h->root.type != bfd_link_hash_defined
1349               && h->root.type != bfd_link_hash_defweak)
1350             /* This appears to be a reference to an undefined
1351                symbol.  Just ignore it--it will be caught by the
1352                regular reloc processing.  */
1353             continue;
1354
1355           symval = (h->root.u.def.value
1356                     + h->root.u.def.section->output_section->vma
1357                     + h->root.u.def.section->output_offset);
1358         }
1359
1360       /* For simplicity of coding, we are going to modify the section
1361          contents, the section relocs, and the BFD symbol table.  We
1362          must tell the rest of the code not to free up this
1363          information.  It would be possible to instead create a table
1364          of changes which have to be made, as is done in coff-mips.c;
1365          that would be more work, but would require less memory when
1366          the linker is run.  */
1367       switch (ELF32_R_TYPE (irel->r_info))
1368         {
1369          /* Try to turn a 22-bit absolute call/jump into an 13-bit
1370             pc-relative rcall/rjmp.  */
1371          case R_AVR_CALL:
1372           {
1373             bfd_vma value = symval + irel->r_addend;
1374             bfd_vma dot, gap;
1375             int distance_short_enough = 0;
1376
1377             /* Get the address of this instruction.  */
1378             dot = (sec->output_section->vma
1379                    + sec->output_offset + irel->r_offset);
1380
1381             /* Compute the distance from this insn to the branch target.  */
1382             gap = value - dot;
1383
1384             /* If the distance is within -4094..+4098 inclusive, then we can
1385                relax this jump/call.  +4098 because the call/jump target
1386                will be closer after the relaxation.  */
1387             if ((int) gap >= -4094 && (int) gap <= 4098)
1388               distance_short_enough = 1;
1389
1390             /* Here we handle the wrap-around case.  E.g. for a 16k device
1391                we could use a rjmp to jump from address 0x100 to 0x3d00!
1392                In order to make this work properly, we need to fill the
1393                vaiable avr_pc_wrap_around with the appropriate value.
1394                I.e. 0x4000 for a 16k device.  */
1395             {
1396                /* Shrinking the code size makes the gaps larger in the
1397                   case of wrap-arounds.  So we use a heuristical safety
1398                   margin to avoid that during relax the distance gets
1399                   again too large for the short jumps.  Let's assume
1400                   a typical code-size reduction due to relax for a
1401                   16k device of 600 bytes.  So let's use twice the
1402                   typical value as safety margin.  */
1403                int rgap;
1404                int safety_margin;
1405
1406                int assumed_shrink = 600;
1407                if (avr_pc_wrap_around > 0x4000)
1408                  assumed_shrink = 900;
1409
1410                safety_margin = 2 * assumed_shrink;
1411
1412                rgap = avr_relative_distance_considering_wrap_around (gap);
1413
1414                if (rgap >= (-4092 + safety_margin)
1415                    && rgap <= (4094 - safety_margin))
1416                  distance_short_enough = 1;
1417             }
1418
1419             if (distance_short_enough)
1420               {
1421                 unsigned char code_msb;
1422                 unsigned char code_lsb;
1423
1424                 if (DEBUG_RELAX)
1425                   printf ("shrinking jump/call instruction at address 0x%x"
1426                           " in section %s\n\n",
1427                           (int) dot, sec->name);
1428
1429                 /* Note that we've changed the relocs, section contents,
1430                    etc.  */
1431                 elf_section_data (sec)->relocs = internal_relocs;
1432                 elf_section_data (sec)->this_hdr.contents = contents;
1433                 symtab_hdr->contents = (unsigned char *) isymbuf;
1434
1435                 /* Get the instruction code for relaxing.  */
1436                 code_lsb = bfd_get_8 (abfd, contents + irel->r_offset);
1437                 code_msb = bfd_get_8 (abfd, contents + irel->r_offset + 1);
1438
1439                 /* Mask out the relocation bits.  */
1440                 code_msb &= 0x94;
1441                 code_lsb &= 0x0E;
1442                 if (code_msb == 0x94 && code_lsb == 0x0E)
1443                   {
1444                     /* we are changing call -> rcall .  */
1445                     bfd_put_8 (abfd, 0x00, contents + irel->r_offset);
1446                     bfd_put_8 (abfd, 0xD0, contents + irel->r_offset + 1);
1447                   }
1448                 else if (code_msb == 0x94 && code_lsb == 0x0C)
1449                   {
1450                     /* we are changeing jump -> rjmp.  */
1451                     bfd_put_8 (abfd, 0x00, contents + irel->r_offset);
1452                     bfd_put_8 (abfd, 0xC0, contents + irel->r_offset + 1);
1453                   }
1454                 else
1455                   abort ();
1456
1457                 /* Fix the relocation's type.  */
1458                 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1459                                              R_AVR_13_PCREL);
1460
1461                 /* Check for the vector section. There we don't want to
1462                    modify the ordering!  */
1463
1464                 if (!strcmp (sec->name,".vectors")
1465                     || !strcmp (sec->name,".jumptables"))
1466                   {
1467                     /* Let's insert a nop.  */
1468                     bfd_put_8 (abfd, 0x00, contents + irel->r_offset + 2);
1469                     bfd_put_8 (abfd, 0x00, contents + irel->r_offset + 3);
1470                   }
1471                 else
1472                   {
1473                     /* Delete two bytes of data.  */
1474                     if (!elf32_avr_relax_delete_bytes (abfd, sec,
1475                                                        irel->r_offset + 2, 2))
1476                       goto error_return;
1477
1478                     /* That will change things, so, we should relax again.
1479                        Note that this is not required, and it may be slow.  */
1480                     *again = TRUE;
1481                   }
1482               }
1483           }
1484
1485         default:
1486           {
1487             unsigned char code_msb;
1488             unsigned char code_lsb;
1489             bfd_vma dot;
1490
1491             code_msb = bfd_get_8 (abfd, contents + irel->r_offset + 1);
1492             code_lsb = bfd_get_8 (abfd, contents + irel->r_offset + 0);
1493
1494             /* Get the address of this instruction.  */
1495             dot = (sec->output_section->vma
1496                    + sec->output_offset + irel->r_offset);
1497
1498             /* Here we look for rcall/ret or call/ret sequences that could be
1499                safely replaced by rjmp/ret or jmp/ret */
1500             if (0xd0 == (code_msb & 0xf0))
1501               {
1502                 /* This insn is a rcall.  */
1503                 unsigned char next_insn_msb = 0;
1504                 unsigned char next_insn_lsb = 0;
1505
1506                 if (irel->r_offset + 3 < sec->size)
1507                   {
1508                     next_insn_msb =
1509                         bfd_get_8 (abfd, contents + irel->r_offset + 3);
1510                     next_insn_lsb =
1511                         bfd_get_8 (abfd, contents + irel->r_offset + 2);
1512                   }
1513
1514                 if ((0x95 == next_insn_msb) && (0x08 == next_insn_lsb))
1515                   {
1516                     /* The next insn is a ret. We now convert the rcall insn
1517                        into a rjmp instruction.  */
1518                     code_msb &= 0xef;
1519                     bfd_put_8 (abfd, code_msb, contents + irel->r_offset + 1);
1520                     if (DEBUG_RELAX)
1521                       printf ("converted rcall/ret sequence at address 0x%x"
1522                               " into rjmp/ret sequence. Section is %s\n\n",
1523                               (int) dot, sec->name);
1524                     *again = TRUE;
1525                     break;
1526                   }
1527               }
1528             else if ((0x94 == (code_msb & 0xfe))
1529                       && (0x0e == (code_lsb & 0x0e)))
1530               {
1531                 /* This insn is a call.  */
1532                 unsigned char next_insn_msb = 0;
1533                 unsigned char next_insn_lsb = 0;
1534
1535                 if (irel->r_offset + 5 < sec->size)
1536                   {
1537                     next_insn_msb =
1538                         bfd_get_8 (abfd, contents + irel->r_offset + 5);
1539                     next_insn_lsb =
1540                         bfd_get_8 (abfd, contents + irel->r_offset + 4);
1541                   }
1542
1543                 if ((0x95 == next_insn_msb) && (0x08 == next_insn_lsb))
1544                   {
1545                     /* The next insn is a ret. We now convert the call insn
1546                        into a jmp instruction.  */
1547
1548                     code_lsb &= 0xfd;
1549                     bfd_put_8 (abfd, code_lsb, contents + irel->r_offset);
1550                     if (DEBUG_RELAX)
1551                       printf ("converted call/ret sequence at address 0x%x"
1552                               " into jmp/ret sequence. Section is %s\n\n",
1553                               (int) dot, sec->name);
1554                     *again = TRUE;
1555                     break;
1556                   }
1557               }
1558             else if ((0xc0 == (code_msb & 0xf0))
1559                      || ((0x94 == (code_msb & 0xfe))
1560                          && (0x0c == (code_lsb & 0x0e))))
1561               {
1562                 /* This insn is a rjmp or a jmp.  */
1563                 unsigned char next_insn_msb = 0;
1564                 unsigned char next_insn_lsb = 0;
1565                 int insn_size;
1566
1567                 if (0xc0 == (code_msb & 0xf0))
1568                   insn_size = 2; /* rjmp insn */
1569                 else
1570                   insn_size = 4; /* jmp insn */
1571
1572                 if (irel->r_offset + insn_size + 1 < sec->size)
1573                   {
1574                     next_insn_msb =
1575                         bfd_get_8 (abfd, contents + irel->r_offset
1576                                          + insn_size + 1);
1577                     next_insn_lsb =
1578                         bfd_get_8 (abfd, contents + irel->r_offset
1579                                          + insn_size);
1580                   }
1581
1582                 if ((0x95 == next_insn_msb) && (0x08 == next_insn_lsb))
1583                   {
1584                     /* The next insn is a ret. We possibly could delete
1585                        this ret. First we need to check for preceeding
1586                        sbis/sbic/sbrs or cpse "skip" instructions.  */
1587
1588                     int there_is_preceeding_non_skip_insn = 1;
1589                     bfd_vma address_of_ret;
1590
1591                     address_of_ret = dot + insn_size;
1592
1593                     if (DEBUG_RELAX && (insn_size == 2))
1594                       printf ("found rjmp / ret sequence at address 0x%x\n",
1595                               (int) dot);
1596                     if (DEBUG_RELAX && (insn_size == 4))
1597                       printf ("found jmp / ret sequence at address 0x%x\n",
1598                               (int) dot);
1599
1600                     /* We have to make sure that there is a preceeding insn.  */
1601                     if (irel->r_offset >= 2)
1602                       {
1603                         unsigned char preceeding_msb;
1604                         unsigned char preceeding_lsb;
1605                         preceeding_msb =
1606                             bfd_get_8 (abfd, contents + irel->r_offset - 1);
1607                         preceeding_lsb =
1608                             bfd_get_8 (abfd, contents + irel->r_offset - 2);
1609
1610                         /* sbic.  */
1611                         if (0x99 == preceeding_msb)
1612                           there_is_preceeding_non_skip_insn = 0;
1613
1614                         /* sbis.  */
1615                         if (0x9b == preceeding_msb)
1616                           there_is_preceeding_non_skip_insn = 0;
1617
1618                         /* sbrc */
1619                         if ((0xfc == (preceeding_msb & 0xfe)
1620                             && (0x00 == (preceeding_lsb & 0x08))))
1621                           there_is_preceeding_non_skip_insn = 0;
1622
1623                         /* sbrs */
1624                         if ((0xfe == (preceeding_msb & 0xfe)
1625                             && (0x00 == (preceeding_lsb & 0x08))))
1626                           there_is_preceeding_non_skip_insn = 0;
1627
1628                         /* cpse */
1629                         if (0x10 == (preceeding_msb & 0xfc))
1630                           there_is_preceeding_non_skip_insn = 0;
1631
1632                         if (there_is_preceeding_non_skip_insn == 0)
1633                           if (DEBUG_RELAX)
1634                             printf ("preceeding skip insn prevents deletion of"
1635                                     " ret insn at addr 0x%x in section %s\n",
1636                                     (int) dot + 2, sec->name);
1637                       }
1638                     else
1639                       {
1640                         /* There is no previous instruction.  */
1641                         there_is_preceeding_non_skip_insn = 0;
1642                       }
1643
1644                     if (there_is_preceeding_non_skip_insn)
1645                       {
1646                         /* We now only have to make sure that there is no
1647                            local label defined at the address of the ret
1648                            instruction and that there is no local relocation
1649                            in this section pointing to the ret.  */
1650
1651                         int deleting_ret_is_safe = 1;
1652                         unsigned int section_offset_of_ret_insn =
1653                                           irel->r_offset + insn_size;
1654                         Elf_Internal_Sym *isym, *isymend;
1655                         unsigned int sec_shndx;
1656
1657                         sec_shndx =
1658                           _bfd_elf_section_from_bfd_section (abfd, sec);
1659
1660                         /* Check for local symbols.  */
1661                         isym = (Elf_Internal_Sym *) symtab_hdr->contents;
1662                         isymend = isym + symtab_hdr->sh_info;
1663                         for (; isym < isymend; isym++)
1664                          {
1665                            if (isym->st_value == section_offset_of_ret_insn
1666                                && isym->st_shndx == sec_shndx)
1667                              {
1668                                deleting_ret_is_safe = 0;
1669                                if (DEBUG_RELAX)
1670                                  printf ("local label prevents deletion of ret "
1671                                          "insn at address 0x%x\n",
1672                                          (int) dot + insn_size);
1673                              }
1674                          }
1675
1676                          /* Now check for global symbols.  */
1677                          {
1678                            int symcount;
1679                            struct elf_link_hash_entry **sym_hashes;
1680                            struct elf_link_hash_entry **end_hashes;
1681
1682                            symcount = (symtab_hdr->sh_size
1683                                        / sizeof (Elf32_External_Sym)
1684                                        - symtab_hdr->sh_info);
1685                            sym_hashes = elf_sym_hashes (abfd);
1686                            end_hashes = sym_hashes + symcount;
1687                            for (; sym_hashes < end_hashes; sym_hashes++)
1688                             {
1689                               struct elf_link_hash_entry *sym_hash =
1690                                                                  *sym_hashes;
1691                               if ((sym_hash->root.type == bfd_link_hash_defined
1692                                   || sym_hash->root.type ==
1693                                    bfd_link_hash_defweak)
1694                                   && sym_hash->root.u.def.section == sec
1695                                   && sym_hash->root.u.def.value == section_offset_of_ret_insn)
1696                                 {
1697                                   deleting_ret_is_safe = 0;
1698                                   if (DEBUG_RELAX)
1699                                     printf ("global label prevents deletion of "
1700                                             "ret insn at address 0x%x\n",
1701                                             (int) dot + insn_size);
1702                                 }
1703                             }
1704                          }
1705                          /* Now we check for relocations pointing to ret.  */
1706                          {
1707                            Elf_Internal_Rela *irel;
1708                            Elf_Internal_Rela *relend;
1709                            Elf_Internal_Shdr *symtab_hdr;
1710
1711                            symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1712                            relend = elf_section_data (sec)->relocs
1713                                     + sec->reloc_count;
1714
1715                            for (irel = elf_section_data (sec)->relocs;
1716                                 irel < relend; irel++)
1717                              {
1718                                bfd_vma reloc_target = 0;
1719                                bfd_vma symval;
1720                                Elf_Internal_Sym *isymbuf = NULL;
1721
1722                                /* Read this BFD's local symbols if we haven't
1723                                   done so already.  */
1724                                if (isymbuf == NULL && symtab_hdr->sh_info != 0)
1725                                  {
1726                                    isymbuf = (Elf_Internal_Sym *)
1727                                              symtab_hdr->contents;
1728                                    if (isymbuf == NULL)
1729                                      isymbuf = bfd_elf_get_elf_syms
1730                                        (abfd,
1731                                         symtab_hdr,
1732                                         symtab_hdr->sh_info, 0,
1733                                         NULL, NULL, NULL);
1734                                    if (isymbuf == NULL)
1735                                      break;
1736                                   }
1737
1738                                /* Get the value of the symbol referred to
1739                                   by the reloc.  */
1740                                if (ELF32_R_SYM (irel->r_info)
1741                                    < symtab_hdr->sh_info)
1742                                  {
1743                                    /* A local symbol.  */
1744                                    Elf_Internal_Sym *isym;
1745                                    asection *sym_sec;
1746
1747                                    isym = isymbuf
1748                                           + ELF32_R_SYM (irel->r_info);
1749                                    sym_sec = bfd_section_from_elf_index
1750                                      (abfd, isym->st_shndx);
1751                                    symval = isym->st_value;
1752
1753                                    /* If the reloc is absolute, it will not
1754                                       have a symbol or section associated
1755                                       with it.  */
1756
1757                                    if (sym_sec)
1758                                      {
1759                                        symval +=
1760                                            sym_sec->output_section->vma
1761                                            + sym_sec->output_offset;
1762                                        reloc_target = symval + irel->r_addend;
1763                                      }
1764                                    else
1765                                      {
1766                                        reloc_target = symval + irel->r_addend;
1767                                        /* Reference symbol is absolute.  */
1768                                      }
1769                                  }
1770                                /* else ... reference symbol is extern.  */
1771
1772                                if (address_of_ret == reloc_target)
1773                                  {
1774                                    deleting_ret_is_safe = 0;
1775                                    if (DEBUG_RELAX)
1776                                      printf ("ret from "
1777                                              "rjmp/jmp ret sequence at address"
1778                                              " 0x%x could not be deleted. ret"
1779                                              " is target of a relocation.\n",
1780                                              (int) address_of_ret);
1781                                  }
1782                              }
1783                          }
1784
1785                          if (deleting_ret_is_safe)
1786                            {
1787                              if (DEBUG_RELAX)
1788                                printf ("unreachable ret instruction "
1789                                        "at address 0x%x deleted.\n",
1790                                        (int) dot + insn_size);
1791
1792                              /* Delete two bytes of data.  */
1793                              if (!elf32_avr_relax_delete_bytes (abfd, sec,
1794                                         irel->r_offset + insn_size, 2))
1795                                goto error_return;
1796
1797                              /* That will change things, so, we should relax
1798                                 again. Note that this is not required, and it
1799                                 may be slow.  */
1800                              *again = TRUE;
1801                              break;
1802                            }
1803                       }
1804
1805                   }
1806               }
1807             break;
1808           }
1809         }
1810     }
1811
1812   if (contents != NULL
1813       && elf_section_data (sec)->this_hdr.contents != contents)
1814     {
1815       if (! link_info->keep_memory)
1816         free (contents);
1817       else
1818         {
1819           /* Cache the section contents for elf_link_input_bfd.  */
1820           elf_section_data (sec)->this_hdr.contents = contents;
1821         }
1822     }
1823
1824   if (internal_relocs != NULL
1825       && elf_section_data (sec)->relocs != internal_relocs)
1826     free (internal_relocs);
1827
1828   return TRUE;
1829
1830  error_return:
1831   if (isymbuf != NULL
1832       && symtab_hdr->contents != (unsigned char *) isymbuf)
1833     free (isymbuf);
1834   if (contents != NULL
1835       && elf_section_data (sec)->this_hdr.contents != contents)
1836     free (contents);
1837   if (internal_relocs != NULL
1838       && elf_section_data (sec)->relocs != internal_relocs)
1839     free (internal_relocs);
1840
1841   return FALSE;
1842 }
1843
1844 /* This is a version of bfd_generic_get_relocated_section_contents
1845    which uses elf32_avr_relocate_section.
1846
1847    For avr it's essentially a cut and paste taken from the H8300 port.
1848    The author of the relaxation support patch for avr had absolutely no
1849    clue what is happening here but found out that this part of the code
1850    seems to be important.  */
1851
1852 static bfd_byte *
1853 elf32_avr_get_relocated_section_contents (bfd *output_bfd,
1854                                           struct bfd_link_info *link_info,
1855                                           struct bfd_link_order *link_order,
1856                                           bfd_byte *data,
1857                                           bfd_boolean relocatable,
1858                                           asymbol **symbols)
1859 {
1860   Elf_Internal_Shdr *symtab_hdr;
1861   asection *input_section = link_order->u.indirect.section;
1862   bfd *input_bfd = input_section->owner;
1863   asection **sections = NULL;
1864   Elf_Internal_Rela *internal_relocs = NULL;
1865   Elf_Internal_Sym *isymbuf = NULL;
1866
1867   /* We only need to handle the case of relaxing, or of having a
1868      particular set of section contents, specially.  */
1869   if (relocatable
1870       || elf_section_data (input_section)->this_hdr.contents == NULL)
1871     return bfd_generic_get_relocated_section_contents (output_bfd, link_info,
1872                                                        link_order, data,
1873                                                        relocatable,
1874                                                        symbols);
1875   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1876
1877   memcpy (data, elf_section_data (input_section)->this_hdr.contents,
1878           (size_t) input_section->size);
1879
1880   if ((input_section->flags & SEC_RELOC) != 0
1881       && input_section->reloc_count > 0)
1882     {
1883       asection **secpp;
1884       Elf_Internal_Sym *isym, *isymend;
1885       bfd_size_type amt;
1886
1887       internal_relocs = (_bfd_elf_link_read_relocs
1888                          (input_bfd, input_section, NULL, NULL, FALSE));
1889       if (internal_relocs == NULL)
1890         goto error_return;
1891
1892       if (symtab_hdr->sh_info != 0)
1893         {
1894           isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
1895           if (isymbuf == NULL)
1896             isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr,
1897                                             symtab_hdr->sh_info, 0,
1898                                             NULL, NULL, NULL);
1899           if (isymbuf == NULL)
1900             goto error_return;
1901         }
1902
1903       amt = symtab_hdr->sh_info;
1904       amt *= sizeof (asection *);
1905       sections = bfd_malloc (amt);
1906       if (sections == NULL && amt != 0)
1907         goto error_return;
1908
1909       isymend = isymbuf + symtab_hdr->sh_info;
1910       for (isym = isymbuf, secpp = sections; isym < isymend; ++isym, ++secpp)
1911         {
1912           asection *isec;
1913
1914           if (isym->st_shndx == SHN_UNDEF)
1915             isec = bfd_und_section_ptr;
1916           else if (isym->st_shndx == SHN_ABS)
1917             isec = bfd_abs_section_ptr;
1918           else if (isym->st_shndx == SHN_COMMON)
1919             isec = bfd_com_section_ptr;
1920           else
1921             isec = bfd_section_from_elf_index (input_bfd, isym->st_shndx);
1922
1923           *secpp = isec;
1924         }
1925
1926       if (! elf32_avr_relocate_section (output_bfd, link_info, input_bfd,
1927                                         input_section, data, internal_relocs,
1928                                         isymbuf, sections))
1929         goto error_return;
1930
1931       if (sections != NULL)
1932         free (sections);
1933       if (isymbuf != NULL
1934           && symtab_hdr->contents != (unsigned char *) isymbuf)
1935         free (isymbuf);
1936       if (elf_section_data (input_section)->relocs != internal_relocs)
1937         free (internal_relocs);
1938     }
1939
1940   return data;
1941
1942  error_return:
1943   if (sections != NULL)
1944     free (sections);
1945   if (isymbuf != NULL
1946       && symtab_hdr->contents != (unsigned char *) isymbuf)
1947     free (isymbuf);
1948   if (internal_relocs != NULL
1949       && elf_section_data (input_section)->relocs != internal_relocs)
1950     free (internal_relocs);
1951   return NULL;
1952 }
1953
1954
1955 #define ELF_ARCH                bfd_arch_avr
1956 #define ELF_MACHINE_CODE        EM_AVR
1957 #define ELF_MACHINE_ALT1        EM_AVR_OLD
1958 #define ELF_MAXPAGESIZE         1
1959
1960 #define TARGET_LITTLE_SYM       bfd_elf32_avr_vec
1961 #define TARGET_LITTLE_NAME      "elf32-avr"
1962
1963 #define elf_info_to_howto                    avr_info_to_howto_rela
1964 #define elf_info_to_howto_rel                NULL
1965 #define elf_backend_relocate_section         elf32_avr_relocate_section
1966 #define elf_backend_gc_mark_hook             elf32_avr_gc_mark_hook
1967 #define elf_backend_gc_sweep_hook            elf32_avr_gc_sweep_hook
1968 #define elf_backend_check_relocs             elf32_avr_check_relocs
1969 #define elf_backend_can_gc_sections          1
1970 #define elf_backend_rela_normal              1
1971 #define elf_backend_final_write_processing \
1972                                         bfd_elf_avr_final_write_processing
1973 #define elf_backend_object_p            elf32_avr_object_p
1974
1975 #define bfd_elf32_bfd_relax_section elf32_avr_relax_section
1976 #define bfd_elf32_bfd_get_relocated_section_contents \
1977                                         elf32_avr_get_relocated_section_contents
1978
1979 #include "elf32-target.h"