bfd/elfxx-ia64.c

   1 /* IA-64 support for 64-bit ELF
   2    Copyright (C) 1998-2019 Free Software Foundation, Inc.
   3    Contributed by David Mosberger-Tang <davidm@hpl.hp.com>
   4
   5    This file is part of BFD, the Binary File Descriptor library.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
  20    MA 02110-1301, USA.  */
  21
  22 #include "sysdep.h"
  23 #include "bfd.h"
  24 #include "libbfd.h"
  25 #include "elf-bfd.h"
  26 #include "opcode/ia64.h"
  27 #include "elf/ia64.h"
  28 #include "objalloc.h"
  29 #include "hashtab.h"
  30 #include "elfxx-ia64.h"
  31
  32 /* THE RULES for all the stuff the linker creates --
  33
  34   GOT           Entries created in response to LTOFF or LTOFF_FPTR
  35                 relocations.  Dynamic relocs created for dynamic
  36                 symbols in an application; REL relocs for locals
  37                 in a shared library.
  38
  39   FPTR          The canonical function descriptor.  Created for local
  40                 symbols in applications.  Descriptors for dynamic symbols
  41                 and local symbols in shared libraries are created by
  42                 ld.so.  Thus there are no dynamic relocs against these
  43                 objects.  The FPTR relocs for such _are_ passed through
  44                 to the dynamic relocation tables.
  45
  46   FULL_PLT      Created for a PCREL21B relocation against a dynamic symbol.
  47                 Requires the creation of a PLTOFF entry.  This does not
  48                 require any dynamic relocations.
  49
  50   PLTOFF        Created by PLTOFF relocations.  For local symbols, this
  51                 is an alternate function descriptor, and in shared libraries
  52                 requires two REL relocations.  Note that this cannot be
  53                 transformed into an FPTR relocation, since it must be in
  54                 range of the GP.  For dynamic symbols, this is a function
  55                 descriptor for a MIN_PLT entry, and requires one IPLT reloc.
  56
  57   MIN_PLT       Created by PLTOFF entries against dynamic symbols.  This
  58                 does not require dynamic relocations.  */
  59
  60 /* ia64-specific relocation.  */
  61
  62 #define NELEMS(a)       ((int) (sizeof (a) / sizeof ((a)[0])))
  63
  64 /* Perform a relocation.  Not much to do here as all the hard work is
  65    done in elfNN_ia64_final_link_relocate.  */
  66 static bfd_reloc_status_type
  67 ia64_elf_reloc (bfd *abfd ATTRIBUTE_UNUSED, arelent *reloc,
  68                 asymbol *sym ATTRIBUTE_UNUSED,
  69                 PTR data ATTRIBUTE_UNUSED, asection *input_section,
  70                 bfd *output_bfd, char **error_message)
  71 {
  72   if (output_bfd)
  73     {
  74       reloc->address += input_section->output_offset;
  75       return bfd_reloc_ok;
  76     }
  77
  78   if (input_section->flags & SEC_DEBUGGING)
  79     return bfd_reloc_continue;
  80
  81   *error_message = "Unsupported call to ia64_elf_reloc";
  82   return bfd_reloc_notsupported;
  83 }
  84
  85 #define IA64_HOWTO(TYPE, NAME, SIZE, PCREL, IN)                 \
  86   HOWTO (TYPE, 0, SIZE, 0, PCREL, 0, complain_overflow_signed,  \
  87          ia64_elf_reloc, NAME, FALSE, 0, -1, IN)
  88
  89 /* This table has to be sorted according to increasing number of the
  90    TYPE field.  */
  91 static reloc_howto_type ia64_howto_table[] =
  92   {
  93     IA64_HOWTO (R_IA64_NONE,        "NONE",        3, FALSE, TRUE),
  94
  95     IA64_HOWTO (R_IA64_IMM14,       "IMM14",       0, FALSE, TRUE),
  96     IA64_HOWTO (R_IA64_IMM22,       "IMM22",       0, FALSE, TRUE),
  97     IA64_HOWTO (R_IA64_IMM64,       "IMM64",       0, FALSE, TRUE),
  98     IA64_HOWTO (R_IA64_DIR32MSB,    "DIR32MSB",    2, FALSE, TRUE),
  99     IA64_HOWTO (R_IA64_DIR32LSB,    "DIR32LSB",    2, FALSE, TRUE),
 100     IA64_HOWTO (R_IA64_DIR64MSB,    "DIR64MSB",    4, FALSE, TRUE),
 101     IA64_HOWTO (R_IA64_DIR64LSB,    "DIR64LSB",    4, FALSE, TRUE),
 102
 103     IA64_HOWTO (R_IA64_GPREL22,     "GPREL22",     0, FALSE, TRUE),
 104     IA64_HOWTO (R_IA64_GPREL64I,    "GPREL64I",    0, FALSE, TRUE),
 105     IA64_HOWTO (R_IA64_GPREL32MSB,  "GPREL32MSB",  2, FALSE, TRUE),
 106     IA64_HOWTO (R_IA64_GPREL32LSB,  "GPREL32LSB",  2, FALSE, TRUE),
 107     IA64_HOWTO (R_IA64_GPREL64MSB,  "GPREL64MSB",  4, FALSE, TRUE),
 108     IA64_HOWTO (R_IA64_GPREL64LSB,  "GPREL64LSB",  4, FALSE, TRUE),
 109
 110     IA64_HOWTO (R_IA64_LTOFF22,     "LTOFF22",     0, FALSE, TRUE),
 111     IA64_HOWTO (R_IA64_LTOFF64I,    "LTOFF64I",    0, FALSE, TRUE),
 112
 113     IA64_HOWTO (R_IA64_PLTOFF22,    "PLTOFF22",    0, FALSE, TRUE),
 114     IA64_HOWTO (R_IA64_PLTOFF64I,   "PLTOFF64I",   0, FALSE, TRUE),
 115     IA64_HOWTO (R_IA64_PLTOFF64MSB, "PLTOFF64MSB", 4, FALSE, TRUE),
 116     IA64_HOWTO (R_IA64_PLTOFF64LSB, "PLTOFF64LSB", 4, FALSE, TRUE),
 117
 118     IA64_HOWTO (R_IA64_FPTR64I,     "FPTR64I",     0, FALSE, TRUE),
 119     IA64_HOWTO (R_IA64_FPTR32MSB,   "FPTR32MSB",   2, FALSE, TRUE),
 120     IA64_HOWTO (R_IA64_FPTR32LSB,   "FPTR32LSB",   2, FALSE, TRUE),
 121     IA64_HOWTO (R_IA64_FPTR64MSB,   "FPTR64MSB",   4, FALSE, TRUE),
 122     IA64_HOWTO (R_IA64_FPTR64LSB,   "FPTR64LSB",   4, FALSE, TRUE),
 123
 124     IA64_HOWTO (R_IA64_PCREL60B,    "PCREL60B",    0, TRUE, TRUE),
 125     IA64_HOWTO (R_IA64_PCREL21B,    "PCREL21B",    0, TRUE, TRUE),
 126     IA64_HOWTO (R_IA64_PCREL21M,    "PCREL21M",    0, TRUE, TRUE),
 127     IA64_HOWTO (R_IA64_PCREL21F,    "PCREL21F",    0, TRUE, TRUE),
 128     IA64_HOWTO (R_IA64_PCREL32MSB,  "PCREL32MSB",  2, TRUE, TRUE),
 129     IA64_HOWTO (R_IA64_PCREL32LSB,  "PCREL32LSB",  2, TRUE, TRUE),
 130     IA64_HOWTO (R_IA64_PCREL64MSB,  "PCREL64MSB",  4, TRUE, TRUE),
 131     IA64_HOWTO (R_IA64_PCREL64LSB,  "PCREL64LSB",  4, TRUE, TRUE),
 132
 133     IA64_HOWTO (R_IA64_LTOFF_FPTR22, "LTOFF_FPTR22", 0, FALSE, TRUE),
 134     IA64_HOWTO (R_IA64_LTOFF_FPTR64I, "LTOFF_FPTR64I", 0, FALSE, TRUE),
 135     IA64_HOWTO (R_IA64_LTOFF_FPTR32MSB, "LTOFF_FPTR32MSB", 2, FALSE, TRUE),
 136     IA64_HOWTO (R_IA64_LTOFF_FPTR32LSB, "LTOFF_FPTR32LSB", 2, FALSE, TRUE),
 137     IA64_HOWTO (R_IA64_LTOFF_FPTR64MSB, "LTOFF_FPTR64MSB", 4, FALSE, TRUE),
 138     IA64_HOWTO (R_IA64_LTOFF_FPTR64LSB, "LTOFF_FPTR64LSB", 4, FALSE, TRUE),
 139
 140     IA64_HOWTO (R_IA64_SEGREL32MSB, "SEGREL32MSB", 2, FALSE, TRUE),
 141     IA64_HOWTO (R_IA64_SEGREL32LSB, "SEGREL32LSB", 2, FALSE, TRUE),
 142     IA64_HOWTO (R_IA64_SEGREL64MSB, "SEGREL64MSB", 4, FALSE, TRUE),
 143     IA64_HOWTO (R_IA64_SEGREL64LSB, "SEGREL64LSB", 4, FALSE, TRUE),
 144
 145     IA64_HOWTO (R_IA64_SECREL32MSB, "SECREL32MSB", 2, FALSE, TRUE),
 146     IA64_HOWTO (R_IA64_SECREL32LSB, "SECREL32LSB", 2, FALSE, TRUE),
 147     IA64_HOWTO (R_IA64_SECREL64MSB, "SECREL64MSB", 4, FALSE, TRUE),
 148     IA64_HOWTO (R_IA64_SECREL64LSB, "SECREL64LSB", 4, FALSE, TRUE),
 149
 150     IA64_HOWTO (R_IA64_REL32MSB,    "REL32MSB",    2, FALSE, TRUE),
 151     IA64_HOWTO (R_IA64_REL32LSB,    "REL32LSB",    2, FALSE, TRUE),
 152     IA64_HOWTO (R_IA64_REL64MSB,    "REL64MSB",    4, FALSE, TRUE),
 153     IA64_HOWTO (R_IA64_REL64LSB,    "REL64LSB",    4, FALSE, TRUE),
 154
 155     IA64_HOWTO (R_IA64_LTV32MSB,    "LTV32MSB",    2, FALSE, TRUE),
 156     IA64_HOWTO (R_IA64_LTV32LSB,    "LTV32LSB",    2, FALSE, TRUE),
 157     IA64_HOWTO (R_IA64_LTV64MSB,    "LTV64MSB",    4, FALSE, TRUE),
 158     IA64_HOWTO (R_IA64_LTV64LSB,    "LTV64LSB",    4, FALSE, TRUE),
 159
 160     IA64_HOWTO (R_IA64_PCREL21BI,   "PCREL21BI",   0, TRUE, TRUE),
 161     IA64_HOWTO (R_IA64_PCREL22,     "PCREL22",     0, TRUE, TRUE),
 162     IA64_HOWTO (R_IA64_PCREL64I,    "PCREL64I",    0, TRUE, TRUE),
 163
 164     IA64_HOWTO (R_IA64_IPLTMSB,     "IPLTMSB",     4, FALSE, TRUE),
 165     IA64_HOWTO (R_IA64_IPLTLSB,     "IPLTLSB",     4, FALSE, TRUE),
 166     IA64_HOWTO (R_IA64_COPY,        "COPY",        4, FALSE, TRUE),
 167     IA64_HOWTO (R_IA64_LTOFF22X,    "LTOFF22X",    0, FALSE, TRUE),
 168     IA64_HOWTO (R_IA64_LDXMOV,      "LDXMOV",      0, FALSE, TRUE),
 169
 170     IA64_HOWTO (R_IA64_TPREL14,     "TPREL14",     0, FALSE, FALSE),
 171     IA64_HOWTO (R_IA64_TPREL22,     "TPREL22",     0, FALSE, FALSE),
 172     IA64_HOWTO (R_IA64_TPREL64I,    "TPREL64I",    0, FALSE, FALSE),
 173     IA64_HOWTO (R_IA64_TPREL64MSB,  "TPREL64MSB",  4, FALSE, FALSE),
 174     IA64_HOWTO (R_IA64_TPREL64LSB,  "TPREL64LSB",  4, FALSE, FALSE),
 175     IA64_HOWTO (R_IA64_LTOFF_TPREL22, "LTOFF_TPREL22",  0, FALSE, FALSE),
 176
 177     IA64_HOWTO (R_IA64_DTPMOD64MSB, "DTPMOD64MSB",  4, FALSE, FALSE),
 178     IA64_HOWTO (R_IA64_DTPMOD64LSB, "DTPMOD64LSB",  4, FALSE, FALSE),
 179     IA64_HOWTO (R_IA64_LTOFF_DTPMOD22, "LTOFF_DTPMOD22", 0, FALSE, FALSE),
 180
 181     IA64_HOWTO (R_IA64_DTPREL14,    "DTPREL14",    0, FALSE, FALSE),
 182     IA64_HOWTO (R_IA64_DTPREL22,    "DTPREL22",    0, FALSE, FALSE),
 183     IA64_HOWTO (R_IA64_DTPREL64I,   "DTPREL64I",   0, FALSE, FALSE),
 184     IA64_HOWTO (R_IA64_DTPREL32MSB, "DTPREL32MSB", 2, FALSE, FALSE),
 185     IA64_HOWTO (R_IA64_DTPREL32LSB, "DTPREL32LSB", 2, FALSE, FALSE),
 186     IA64_HOWTO (R_IA64_DTPREL64MSB, "DTPREL64MSB", 4, FALSE, FALSE),
 187     IA64_HOWTO (R_IA64_DTPREL64LSB, "DTPREL64LSB", 4, FALSE, FALSE),
 188     IA64_HOWTO (R_IA64_LTOFF_DTPREL22, "LTOFF_DTPREL22", 0, FALSE, FALSE),
 189   };
 190
 191 static unsigned char elf_code_to_howto_index[R_IA64_MAX_RELOC_CODE + 1];
 192
 193 /* Given a BFD reloc type, return the matching HOWTO structure.  */
 194
 195 reloc_howto_type *
 196 ia64_elf_lookup_howto (unsigned int rtype)
 197 {
 198   static bfd_boolean inited = FALSE;
 199   int i;
 200
 201   if (!inited)
 202     {
 203       inited = TRUE;
 204
 205       memset (elf_code_to_howto_index, 0xff, sizeof (elf_code_to_howto_index));
 206       for (i = 0; i < NELEMS (ia64_howto_table); ++i)
 207         elf_code_to_howto_index[ia64_howto_table[i].type] = i;
 208     }
 209
 210   if (rtype > R_IA64_MAX_RELOC_CODE)
 211     return NULL;
 212   i = elf_code_to_howto_index[rtype];
 213   if (i >= NELEMS (ia64_howto_table))
 214     return NULL;
 215   return ia64_howto_table + i;
 216 }
 217
 218 reloc_howto_type *
 219 ia64_elf_reloc_type_lookup (bfd *abfd,
 220                             bfd_reloc_code_real_type bfd_code)
 221 {
 222   unsigned int rtype;
 223
 224   switch (bfd_code)
 225     {
 226     case BFD_RELOC_NONE:                rtype = R_IA64_NONE; break;
 227
 228     case BFD_RELOC_IA64_IMM14:          rtype = R_IA64_IMM14; break;
 229     case BFD_RELOC_IA64_IMM22:          rtype = R_IA64_IMM22; break;
 230     case BFD_RELOC_IA64_IMM64:          rtype = R_IA64_IMM64; break;
 231
 232     case BFD_RELOC_IA64_DIR32MSB:       rtype = R_IA64_DIR32MSB; break;
 233     case BFD_RELOC_IA64_DIR32LSB:       rtype = R_IA64_DIR32LSB; break;
 234     case BFD_RELOC_IA64_DIR64MSB:       rtype = R_IA64_DIR64MSB; break;
 235     case BFD_RELOC_IA64_DIR64LSB:       rtype = R_IA64_DIR64LSB; break;
 236
 237     case BFD_RELOC_IA64_GPREL22:        rtype = R_IA64_GPREL22; break;
 238     case BFD_RELOC_IA64_GPREL64I:       rtype = R_IA64_GPREL64I; break;
 239     case BFD_RELOC_IA64_GPREL32MSB:     rtype = R_IA64_GPREL32MSB; break;
 240     case BFD_RELOC_IA64_GPREL32LSB:     rtype = R_IA64_GPREL32LSB; break;
 241     case BFD_RELOC_IA64_GPREL64MSB:     rtype = R_IA64_GPREL64MSB; break;
 242     case BFD_RELOC_IA64_GPREL64LSB:     rtype = R_IA64_GPREL64LSB; break;
 243
 244     case BFD_RELOC_IA64_LTOFF22:        rtype = R_IA64_LTOFF22; break;
 245     case BFD_RELOC_IA64_LTOFF64I:       rtype = R_IA64_LTOFF64I; break;
 246
 247     case BFD_RELOC_IA64_PLTOFF22:       rtype = R_IA64_PLTOFF22; break;
 248     case BFD_RELOC_IA64_PLTOFF64I:      rtype = R_IA64_PLTOFF64I; break;
 249     case BFD_RELOC_IA64_PLTOFF64MSB:    rtype = R_IA64_PLTOFF64MSB; break;
 250     case BFD_RELOC_IA64_PLTOFF64LSB:    rtype = R_IA64_PLTOFF64LSB; break;
 251     case BFD_RELOC_IA64_FPTR64I:        rtype = R_IA64_FPTR64I; break;
 252     case BFD_RELOC_IA64_FPTR32MSB:      rtype = R_IA64_FPTR32MSB; break;
 253     case BFD_RELOC_IA64_FPTR32LSB:      rtype = R_IA64_FPTR32LSB; break;
 254     case BFD_RELOC_IA64_FPTR64MSB:      rtype = R_IA64_FPTR64MSB; break;
 255     case BFD_RELOC_IA64_FPTR64LSB:      rtype = R_IA64_FPTR64LSB; break;
 256
 257     case BFD_RELOC_IA64_PCREL21B:       rtype = R_IA64_PCREL21B; break;
 258     case BFD_RELOC_IA64_PCREL21BI:      rtype = R_IA64_PCREL21BI; break;
 259     case BFD_RELOC_IA64_PCREL21M:       rtype = R_IA64_PCREL21M; break;
 260     case BFD_RELOC_IA64_PCREL21F:       rtype = R_IA64_PCREL21F; break;
 261     case BFD_RELOC_IA64_PCREL22:        rtype = R_IA64_PCREL22; break;
 262     case BFD_RELOC_IA64_PCREL60B:       rtype = R_IA64_PCREL60B; break;
 263     case BFD_RELOC_IA64_PCREL64I:       rtype = R_IA64_PCREL64I; break;
 264     case BFD_RELOC_IA64_PCREL32MSB:     rtype = R_IA64_PCREL32MSB; break;
 265     case BFD_RELOC_IA64_PCREL32LSB:     rtype = R_IA64_PCREL32LSB; break;
 266     case BFD_RELOC_IA64_PCREL64MSB:     rtype = R_IA64_PCREL64MSB; break;
 267     case BFD_RELOC_IA64_PCREL64LSB:     rtype = R_IA64_PCREL64LSB; break;
 268
 269     case BFD_RELOC_IA64_LTOFF_FPTR22:   rtype = R_IA64_LTOFF_FPTR22; break;
 270     case BFD_RELOC_IA64_LTOFF_FPTR64I:  rtype = R_IA64_LTOFF_FPTR64I; break;
 271     case BFD_RELOC_IA64_LTOFF_FPTR32MSB: rtype = R_IA64_LTOFF_FPTR32MSB; break;
 272     case BFD_RELOC_IA64_LTOFF_FPTR32LSB: rtype = R_IA64_LTOFF_FPTR32LSB; break;
 273     case BFD_RELOC_IA64_LTOFF_FPTR64MSB: rtype = R_IA64_LTOFF_FPTR64MSB; break;
 274     case BFD_RELOC_IA64_LTOFF_FPTR64LSB: rtype = R_IA64_LTOFF_FPTR64LSB; break;
 275
 276     case BFD_RELOC_IA64_SEGREL32MSB:    rtype = R_IA64_SEGREL32MSB; break;
 277     case BFD_RELOC_IA64_SEGREL32LSB:    rtype = R_IA64_SEGREL32LSB; break;
 278     case BFD_RELOC_IA64_SEGREL64MSB:    rtype = R_IA64_SEGREL64MSB; break;
 279     case BFD_RELOC_IA64_SEGREL64LSB:    rtype = R_IA64_SEGREL64LSB; break;
 280
 281     case BFD_RELOC_IA64_SECREL32MSB:    rtype = R_IA64_SECREL32MSB; break;
 282     case BFD_RELOC_IA64_SECREL32LSB:    rtype = R_IA64_SECREL32LSB; break;
 283     case BFD_RELOC_IA64_SECREL64MSB:    rtype = R_IA64_SECREL64MSB; break;
 284     case BFD_RELOC_IA64_SECREL64LSB:    rtype = R_IA64_SECREL64LSB; break;
 285
 286     case BFD_RELOC_IA64_REL32MSB:       rtype = R_IA64_REL32MSB; break;
 287     case BFD_RELOC_IA64_REL32LSB:       rtype = R_IA64_REL32LSB; break;
 288     case BFD_RELOC_IA64_REL64MSB:       rtype = R_IA64_REL64MSB; break;
 289     case BFD_RELOC_IA64_REL64LSB:       rtype = R_IA64_REL64LSB; break;
 290
 291     case BFD_RELOC_IA64_LTV32MSB:       rtype = R_IA64_LTV32MSB; break;
 292     case BFD_RELOC_IA64_LTV32LSB:       rtype = R_IA64_LTV32LSB; break;
 293     case BFD_RELOC_IA64_LTV64MSB:       rtype = R_IA64_LTV64MSB; break;
 294     case BFD_RELOC_IA64_LTV64LSB:       rtype = R_IA64_LTV64LSB; break;
 295
 296     case BFD_RELOC_IA64_IPLTMSB:        rtype = R_IA64_IPLTMSB; break;
 297     case BFD_RELOC_IA64_IPLTLSB:        rtype = R_IA64_IPLTLSB; break;
 298     case BFD_RELOC_IA64_COPY:           rtype = R_IA64_COPY; break;
 299     case BFD_RELOC_IA64_LTOFF22X:       rtype = R_IA64_LTOFF22X; break;
 300     case BFD_RELOC_IA64_LDXMOV:         rtype = R_IA64_LDXMOV; break;
 301
 302     case BFD_RELOC_IA64_TPREL14:        rtype = R_IA64_TPREL14; break;
 303     case BFD_RELOC_IA64_TPREL22:        rtype = R_IA64_TPREL22; break;
 304     case BFD_RELOC_IA64_TPREL64I:       rtype = R_IA64_TPREL64I; break;
 305     case BFD_RELOC_IA64_TPREL64MSB:     rtype = R_IA64_TPREL64MSB; break;
 306     case BFD_RELOC_IA64_TPREL64LSB:     rtype = R_IA64_TPREL64LSB; break;
 307     case BFD_RELOC_IA64_LTOFF_TPREL22:  rtype = R_IA64_LTOFF_TPREL22; break;
 308
 309     case BFD_RELOC_IA64_DTPMOD64MSB:    rtype = R_IA64_DTPMOD64MSB; break;
 310     case BFD_RELOC_IA64_DTPMOD64LSB:    rtype = R_IA64_DTPMOD64LSB; break;
 311     case BFD_RELOC_IA64_LTOFF_DTPMOD22: rtype = R_IA64_LTOFF_DTPMOD22; break;
 312
 313     case BFD_RELOC_IA64_DTPREL14:       rtype = R_IA64_DTPREL14; break;
 314     case BFD_RELOC_IA64_DTPREL22:       rtype = R_IA64_DTPREL22; break;
 315     case BFD_RELOC_IA64_DTPREL64I:      rtype = R_IA64_DTPREL64I; break;
 316     case BFD_RELOC_IA64_DTPREL32MSB:    rtype = R_IA64_DTPREL32MSB; break;
 317     case BFD_RELOC_IA64_DTPREL32LSB:    rtype = R_IA64_DTPREL32LSB; break;
 318     case BFD_RELOC_IA64_DTPREL64MSB:    rtype = R_IA64_DTPREL64MSB; break;
 319     case BFD_RELOC_IA64_DTPREL64LSB:    rtype = R_IA64_DTPREL64LSB; break;
 320     case BFD_RELOC_IA64_LTOFF_DTPREL22: rtype = R_IA64_LTOFF_DTPREL22; break;
 321
 322     default:
 323       /* xgettext:c-format */
 324       _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
 325                           abfd, (int) bfd_code);
 326       bfd_set_error (bfd_error_bad_value);
 327       return NULL;
 328     }
 329   return ia64_elf_lookup_howto (rtype);
 330 }
 331
 332 reloc_howto_type *
 333 ia64_elf_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
 334                             const char *r_name)
 335 {
 336   unsigned int i;
 337
 338   for (i = 0;
 339        i < sizeof (ia64_howto_table) / sizeof (ia64_howto_table[0]);
 340        i++)
 341     if (ia64_howto_table[i].name != NULL
 342         && strcasecmp (ia64_howto_table[i].name, r_name) == 0)
 343       return &ia64_howto_table[i];
 344
 345   return NULL;
 346 }
 347
 348 #define BTYPE_SHIFT     6
 349 #define Y_SHIFT         26
 350 #define X6_SHIFT        27
 351 #define X4_SHIFT        27
 352 #define X3_SHIFT        33
 353 #define X2_SHIFT        31
 354 #define X_SHIFT         33
 355 #define OPCODE_SHIFT    37
 356
 357 #define OPCODE_BITS     (0xfLL << OPCODE_SHIFT)
 358 #define X6_BITS         (0x3fLL << X6_SHIFT)
 359 #define X4_BITS         (0xfLL << X4_SHIFT)
 360 #define X3_BITS         (0x7LL << X3_SHIFT)
 361 #define X2_BITS         (0x3LL << X2_SHIFT)
 362 #define X_BITS          (0x1LL << X_SHIFT)
 363 #define Y_BITS          (0x1LL << Y_SHIFT)
 364 #define BTYPE_BITS      (0x7LL << BTYPE_SHIFT)
 365 #define PREDICATE_BITS  (0x3fLL)
 366
 367 #define IS_NOP_B(i) \
 368   (((i) & (OPCODE_BITS | X6_BITS)) == (2LL << OPCODE_SHIFT))
 369 #define IS_NOP_F(i) \
 370   (((i) & (OPCODE_BITS | X_BITS | X6_BITS | Y_BITS)) \
 371    == (0x1LL << X6_SHIFT))
 372 #define IS_NOP_I(i) \
 373   (((i) & (OPCODE_BITS | X3_BITS | X6_BITS | Y_BITS)) \
 374    == (0x1LL << X6_SHIFT))
 375 #define IS_NOP_M(i) \
 376   (((i) & (OPCODE_BITS | X3_BITS | X2_BITS | X4_BITS | Y_BITS)) \
 377    == (0x1LL << X4_SHIFT))
 378 #define IS_BR_COND(i) \
 379   (((i) & (OPCODE_BITS | BTYPE_BITS)) == (0x4LL << OPCODE_SHIFT))
 380 #define IS_BR_CALL(i) \
 381   (((i) & OPCODE_BITS) == (0x5LL << OPCODE_SHIFT))
 382
 383 bfd_boolean
 384 ia64_elf_relax_br (bfd_byte *contents, bfd_vma off)
 385 {
 386   unsigned int template_val, mlx;
 387   bfd_vma t0, t1, s0, s1, s2, br_code;
 388   long br_slot;
 389   bfd_byte *hit_addr;
 390
 391   hit_addr = (bfd_byte *) (contents + off);
 392   br_slot = (intptr_t) hit_addr & 0x3;
 393   hit_addr -= br_slot;
 394   t0 = bfd_getl64 (hit_addr + 0);
 395   t1 = bfd_getl64 (hit_addr + 8);
 396
 397   /* Check if we can turn br into brl.  A label is always at the start
 398      of the bundle.  Even if there are predicates on NOPs, we still
 399      perform this optimization.  */
 400   template_val = t0 & 0x1e;
 401   s0 = (t0 >> 5) & 0x1ffffffffffLL;
 402   s1 = ((t0 >> 46) | (t1 << 18)) & 0x1ffffffffffLL;
 403   s2 = (t1 >> 23) & 0x1ffffffffffLL;
 404   switch (br_slot)
 405     {
 406     case 0:
 407       /* Check if slot 1 and slot 2 are NOPs. Possible template is
 408          BBB.  We only need to check nop.b.  */
 409       if (!(IS_NOP_B (s1) && IS_NOP_B (s2)))
 410         return FALSE;
 411       br_code = s0;
 412       break;
 413     case 1:
 414       /* Check if slot 2 is NOP. Possible templates are MBB and BBB.
 415          For BBB, slot 0 also has to be nop.b.  */
 416       if (!((template_val == 0x12                               /* MBB */
 417              && IS_NOP_B (s2))
 418             || (template_val == 0x16                    /* BBB */
 419                 && IS_NOP_B (s0)
 420                 && IS_NOP_B (s2))))
 421         return FALSE;
 422       br_code = s1;
 423       break;
 424     case 2:
 425       /* Check if slot 1 is NOP. Possible templates are MIB, MBB, BBB,
 426          MMB and MFB. For BBB, slot 0 also has to be nop.b.  */
 427       if (!((template_val == 0x10                               /* MIB */
 428              && IS_NOP_I (s1))
 429             || (template_val == 0x12                    /* MBB */
 430                 && IS_NOP_B (s1))
 431             || (template_val == 0x16                    /* BBB */
 432                 && IS_NOP_B (s0)
 433                 && IS_NOP_B (s1))
 434             || (template_val == 0x18                    /* MMB */
 435                 && IS_NOP_M (s1))
 436             || (template_val == 0x1c                    /* MFB */
 437                 && IS_NOP_F (s1))))
 438         return FALSE;
 439       br_code = s2;
 440       break;
 441     default:
 442       /* It should never happen.  */
 443       abort ();
 444     }
 445
 446   /* We can turn br.cond/br.call into brl.cond/brl.call.  */
 447   if (!(IS_BR_COND (br_code) || IS_BR_CALL (br_code)))
 448     return FALSE;
 449
 450   /* Turn br into brl by setting bit 40.  */
 451   br_code |= 0x1LL << 40;
 452
 453   /* Turn the old bundle into a MLX bundle with the same stop-bit
 454      variety.  */
 455   if (t0 & 0x1)
 456     mlx = 0x5;
 457   else
 458     mlx = 0x4;
 459
 460   if (template_val == 0x16)
 461     {
 462       /* For BBB, we need to put nop.m in slot 0.  We keep the original
 463          predicate only if slot 0 isn't br.  */
 464       if (br_slot == 0)
 465         t0 = 0LL;
 466       else
 467         t0 &= PREDICATE_BITS << 5;
 468       t0 |= 0x1LL << (X4_SHIFT + 5);
 469     }
 470   else
 471     {
 472       /* Keep the original instruction in slot 0.  */
 473       t0 &= 0x1ffffffffffLL << 5;
 474     }
 475
 476   t0 |= mlx;
 477
 478   /* Put brl in slot 1.  */
 479   t1 = br_code << 23;
 480
 481   bfd_putl64 (t0, hit_addr);
 482   bfd_putl64 (t1, hit_addr + 8);
 483   return TRUE;
 484 }
 485
 486 void
 487 ia64_elf_relax_brl (bfd_byte *contents, bfd_vma off)
 488 {
 489   int template_val;
 490   bfd_byte *hit_addr;
 491   bfd_vma t0, t1, i0, i1, i2;
 492
 493   hit_addr = (bfd_byte *) (contents + off);
 494   hit_addr -= (intptr_t) hit_addr & 0x3;
 495   t0 = bfd_getl64 (hit_addr);
 496   t1 = bfd_getl64 (hit_addr + 8);
 497
 498   /* Keep the instruction in slot 0. */
 499   i0 = (t0 >> 5) & 0x1ffffffffffLL;
 500   /* Use nop.b for slot 1. */
 501   i1 = 0x4000000000LL;
 502   /* For slot 2, turn brl into br by masking out bit 40.  */
 503   i2 = (t1 >> 23) & 0x0ffffffffffLL;
 504
 505   /* Turn a MLX bundle into a MBB bundle with the same stop-bit
 506      variety.  */
 507   if (t0 & 0x1)
 508     template_val = 0x13;
 509   else
 510     template_val = 0x12;
 511   t0 = (i1 << 46) | (i0 << 5) | template_val;
 512   t1 = (i2 << 23) | (i1 >> 18);
 513
 514   bfd_putl64 (t0, hit_addr);
 515   bfd_putl64 (t1, hit_addr + 8);
 516 }
 517
 518 void
 519 ia64_elf_relax_ldxmov (bfd_byte *contents, bfd_vma off)
 520 {
 521   int shift, r1, r3;
 522   bfd_vma dword, insn;
 523
 524   switch ((int)off & 0x3)
 525     {
 526     case 0: shift =  5; break;
 527     case 1: shift = 14; off += 3; break;
 528     case 2: shift = 23; off += 6; break;
 529     default:
 530       abort ();
 531     }
 532
 533   dword = bfd_getl64 (contents + off);
 534   insn = (dword >> shift) & 0x1ffffffffffLL;
 535
 536   r1 = (insn >> 6) & 127;
 537   r3 = (insn >> 20) & 127;
 538   if (r1 == r3)
 539     insn = 0x8000000;                              /* nop */
 540   else
 541     insn = (insn & 0x7f01fff) | 0x10800000000LL;   /* (qp) mov r1 = r3 */
 542
 543   dword &= ~(0x1ffffffffffLL << shift);
 544   dword |= (insn << shift);
 545   bfd_putl64 (dword, contents + off);
 546 }
 547 \f
 548 bfd_reloc_status_type
 549 ia64_elf_install_value (bfd_byte *hit_addr, bfd_vma v, unsigned int r_type)
 550 {
 551   const struct ia64_operand *op;
 552   int bigendian = 0, shift = 0;
 553   bfd_vma t0, t1, dword;
 554   ia64_insn insn;
 555   enum ia64_opnd opnd;
 556   const char *err;
 557   size_t size = 8;
 558 #ifdef BFD_HOST_U_64_BIT
 559   BFD_HOST_U_64_BIT val = (BFD_HOST_U_64_BIT) v;
 560 #else
 561   bfd_vma val = v;
 562 #endif
 563
 564   opnd = IA64_OPND_NIL;
 565   switch (r_type)
 566     {
 567     case R_IA64_NONE:
 568     case R_IA64_LDXMOV:
 569       return bfd_reloc_ok;
 570
 571       /* Instruction relocations.  */
 572
 573     case R_IA64_IMM14:
 574     case R_IA64_TPREL14:
 575     case R_IA64_DTPREL14:
 576       opnd = IA64_OPND_IMM14;
 577       break;
 578
 579     case R_IA64_PCREL21F:       opnd = IA64_OPND_TGT25; break;
 580     case R_IA64_PCREL21M:       opnd = IA64_OPND_TGT25b; break;
 581     case R_IA64_PCREL60B:       opnd = IA64_OPND_TGT64; break;
 582     case R_IA64_PCREL21B:
 583     case R_IA64_PCREL21BI:
 584       opnd = IA64_OPND_TGT25c;
 585       break;
 586
 587     case R_IA64_IMM22:
 588     case R_IA64_GPREL22:
 589     case R_IA64_LTOFF22:
 590     case R_IA64_LTOFF22X:
 591     case R_IA64_PLTOFF22:
 592     case R_IA64_PCREL22:
 593     case R_IA64_LTOFF_FPTR22:
 594     case R_IA64_TPREL22:
 595     case R_IA64_DTPREL22:
 596     case R_IA64_LTOFF_TPREL22:
 597     case R_IA64_LTOFF_DTPMOD22:
 598     case R_IA64_LTOFF_DTPREL22:
 599       opnd = IA64_OPND_IMM22;
 600       break;
 601
 602     case R_IA64_IMM64:
 603     case R_IA64_GPREL64I:
 604     case R_IA64_LTOFF64I:
 605     case R_IA64_PLTOFF64I:
 606     case R_IA64_PCREL64I:
 607     case R_IA64_FPTR64I:
 608     case R_IA64_LTOFF_FPTR64I:
 609     case R_IA64_TPREL64I:
 610     case R_IA64_DTPREL64I:
 611       opnd = IA64_OPND_IMMU64;
 612       break;
 613
 614       /* Data relocations.  */
 615
 616     case R_IA64_DIR32MSB:
 617     case R_IA64_GPREL32MSB:
 618     case R_IA64_FPTR32MSB:
 619     case R_IA64_PCREL32MSB:
 620     case R_IA64_LTOFF_FPTR32MSB:
 621     case R_IA64_SEGREL32MSB:
 622     case R_IA64_SECREL32MSB:
 623     case R_IA64_LTV32MSB:
 624     case R_IA64_DTPREL32MSB:
 625       size = 4; bigendian = 1;
 626       break;
 627
 628     case R_IA64_DIR32LSB:
 629     case R_IA64_GPREL32LSB:
 630     case R_IA64_FPTR32LSB:
 631     case R_IA64_PCREL32LSB:
 632     case R_IA64_LTOFF_FPTR32LSB:
 633     case R_IA64_SEGREL32LSB:
 634     case R_IA64_SECREL32LSB:
 635     case R_IA64_LTV32LSB:
 636     case R_IA64_DTPREL32LSB:
 637       size = 4; bigendian = 0;
 638       break;
 639
 640     case R_IA64_DIR64MSB:
 641     case R_IA64_GPREL64MSB:
 642     case R_IA64_PLTOFF64MSB:
 643     case R_IA64_FPTR64MSB:
 644     case R_IA64_PCREL64MSB:
 645     case R_IA64_LTOFF_FPTR64MSB:
 646     case R_IA64_SEGREL64MSB:
 647     case R_IA64_SECREL64MSB:
 648     case R_IA64_LTV64MSB:
 649     case R_IA64_TPREL64MSB:
 650     case R_IA64_DTPMOD64MSB:
 651     case R_IA64_DTPREL64MSB:
 652       size = 8; bigendian = 1;
 653       break;
 654
 655     case R_IA64_DIR64LSB:
 656     case R_IA64_GPREL64LSB:
 657     case R_IA64_PLTOFF64LSB:
 658     case R_IA64_FPTR64LSB:
 659     case R_IA64_PCREL64LSB:
 660     case R_IA64_LTOFF_FPTR64LSB:
 661     case R_IA64_SEGREL64LSB:
 662     case R_IA64_SECREL64LSB:
 663     case R_IA64_LTV64LSB:
 664     case R_IA64_TPREL64LSB:
 665     case R_IA64_DTPMOD64LSB:
 666     case R_IA64_DTPREL64LSB:
 667       size = 8; bigendian = 0;
 668       break;
 669
 670       /* Unsupported / Dynamic relocations.  */
 671     default:
 672       return bfd_reloc_notsupported;
 673     }
 674
 675   switch (opnd)
 676     {
 677     case IA64_OPND_IMMU64:
 678       hit_addr -= (intptr_t) hit_addr & 0x3;
 679       t0 = bfd_getl64 (hit_addr);
 680       t1 = bfd_getl64 (hit_addr + 8);
 681
 682       /* tmpl/s: bits  0.. 5 in t0
 683          slot 0: bits  5..45 in t0
 684          slot 1: bits 46..63 in t0, bits 0..22 in t1
 685          slot 2: bits 23..63 in t1 */
 686
 687       /* First, clear the bits that form the 64 bit constant.  */
 688       t0 &= ~(0x3ffffLL << 46);
 689       t1 &= ~(0x7fffffLL
 690               | ((  (0x07fLL << 13) | (0x1ffLL << 27)
 691                     | (0x01fLL << 22) | (0x001LL << 21)
 692                     | (0x001LL << 36)) << 23));
 693
 694       t0 |= ((val >> 22) & 0x03ffffLL) << 46;           /* 18 lsbs of imm41 */
 695       t1 |= ((val >> 40) & 0x7fffffLL) <<  0;           /* 23 msbs of imm41 */
 696       t1 |= (  (((val >>  0) & 0x07f) << 13)            /* imm7b */
 697                | (((val >>  7) & 0x1ff) << 27)          /* imm9d */
 698                | (((val >> 16) & 0x01f) << 22)          /* imm5c */
 699                | (((val >> 21) & 0x001) << 21)          /* ic */
 700                | (((val >> 63) & 0x001) << 36)) << 23;  /* i */
 701
 702       bfd_putl64 (t0, hit_addr);
 703       bfd_putl64 (t1, hit_addr + 8);
 704       break;
 705
 706     case IA64_OPND_TGT64:
 707       hit_addr -= (intptr_t) hit_addr & 0x3;
 708       t0 = bfd_getl64 (hit_addr);
 709       t1 = bfd_getl64 (hit_addr + 8);
 710
 711       /* tmpl/s: bits  0.. 5 in t0
 712          slot 0: bits  5..45 in t0
 713          slot 1: bits 46..63 in t0, bits 0..22 in t1
 714          slot 2: bits 23..63 in t1 */
 715
 716       /* First, clear the bits that form the 64 bit constant.  */
 717       t0 &= ~(0x3ffffLL << 46);
 718       t1 &= ~(0x7fffffLL
 719               | ((1LL << 36 | 0xfffffLL << 13) << 23));
 720
 721       val >>= 4;
 722       t0 |= ((val >> 20) & 0xffffLL) << 2 << 46;        /* 16 lsbs of imm39 */
 723       t1 |= ((val >> 36) & 0x7fffffLL) << 0;            /* 23 msbs of imm39 */
 724       t1 |= ((((val >> 0) & 0xfffffLL) << 13)           /* imm20b */
 725               | (((val >> 59) & 0x1LL) << 36)) << 23;   /* i */
 726
 727       bfd_putl64 (t0, hit_addr);
 728       bfd_putl64 (t1, hit_addr + 8);
 729       break;
 730
 731     default:
 732       switch ((intptr_t) hit_addr & 0x3)
 733         {
 734         case 0: shift =  5; break;
 735         case 1: shift = 14; hit_addr += 3; break;
 736         case 2: shift = 23; hit_addr += 6; break;
 737         case 3: return bfd_reloc_notsupported; /* shouldn't happen...  */
 738         }
 739       dword = bfd_getl64 (hit_addr);
 740       insn = (dword >> shift) & 0x1ffffffffffLL;
 741
 742       op = elf64_ia64_operands + opnd;
 743       err = (*op->insert) (op, val, &insn);
 744       if (err)
 745         return bfd_reloc_overflow;
 746
 747       dword &= ~(0x1ffffffffffLL << shift);
 748       dword |= (insn << shift);
 749       bfd_putl64 (dword, hit_addr);
 750       break;
 751
 752     case IA64_OPND_NIL:
 753       /* A data relocation.  */
 754       if (bigendian)
 755         if (size == 4)
 756           bfd_putb32 (val, hit_addr);
 757         else
 758           bfd_putb64 (val, hit_addr);
 759       else
 760         if (size == 4)
 761           bfd_putl32 (val, hit_addr);
 762         else
 763           bfd_putl64 (val, hit_addr);
 764       break;
 765     }
 766
 767   return bfd_reloc_ok;
 768 }