sysdeps/tile/dl-machine.h

   1 /* Copyright (C) 2011-2017 Free Software Foundation, Inc.
   2    This file is part of the GNU C Library.
   3    Contributed by Chris Metcalf <cmetcalf@tilera.com>, 2011.
   4    Based on work contributed by by Carl Pederson & Martin Schwidefsky.
   5
   6    The GNU C Library is free software; you can redistribute it and/or
   7    modify it under the terms of the GNU Lesser General Public
   8    License as published by the Free Software Foundation; either
   9    version 2.1 of the License, or (at your option) any later version.
  10
  11    The GNU C Library is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14    Lesser General Public License for more details.
  15
  16    You should have received a copy of the GNU Lesser General Public
  17    License along with the GNU C Library.  If not, see
  18    <http://www.gnu.org/licenses/>.  */
  19
  20 #ifndef dl_machine_h
  21 #define dl_machine_h
  22
  23 #ifdef __tilegx__
  24 #define ELF_MACHINE_NAME "tilegx"
  25 #else
  26 #define ELF_MACHINE_NAME "tilepro"
  27 #endif
  28
  29 #include <sys/param.h>
  30 #include <string.h>
  31 #include <link.h>
  32 #include <bits/wordsize.h>
  33 #include <arch/icache.h>
  34 #include <arch/opcode.h>
  35
  36 /* Return nonzero iff ELF header is compatible with the running host.  */
  37 static inline int
  38 elf_machine_matches_host (const ElfW(Ehdr) *ehdr)
  39 {
  40 #if defined __tilegx__
  41   if (ehdr->e_machine != EM_TILEGX)
  42     return 0;
  43 # if __WORDSIZE == 32
  44   return (ehdr->e_ident[EI_CLASS] == ELFCLASS32);
  45 # else
  46   return (ehdr->e_ident[EI_CLASS] == ELFCLASS64);
  47 # endif
  48 #elif defined __tilepro__
  49   return ehdr->e_machine == EM_TILEPRO;
  50 #else
  51 # error "Unknown tile architecture."
  52 #endif
  53 }
  54
  55
  56 /* Return the link-time address of _DYNAMIC.  Conveniently, this is the
  57    first element of the GOT.  This must be inlined in a function which
  58    uses global data.  */
  59
  60 static inline ElfW(Addr)
  61 elf_machine_dynamic (void)
  62 {
  63   ElfW(Addr) *got;
  64
  65 #ifdef __tilegx__
  66   ElfW(Addr) tmp;
  67   asm( "        { lnk %0; moveli %1, hw2_last(_GLOBAL_OFFSET_TABLE_ - 1f) }\n"
  68        "1:      shl16insli %1, %1, hw1(_GLOBAL_OFFSET_TABLE_ - 1b)\n"
  69        "        shl16insli %1, %1, hw0(_GLOBAL_OFFSET_TABLE_ - 1b)\n"
  70        "        add %0, %0, %1"
  71        : "=r" (got), "=r" (tmp));
  72 #else
  73   asm( "        lnk %0\n"
  74        "1:      addli %0, %0, lo16(_GLOBAL_OFFSET_TABLE_ - 1b)\n"
  75        "        auli %0, %0, ha16(_GLOBAL_OFFSET_TABLE_ - 1b)"
  76        : "=r" (got));
  77 #endif
  78
  79   return *got;
  80 }
  81
  82
  83 /* Return the run-time load address of the shared object.  */
  84 static inline ElfW(Addr)
  85 elf_machine_load_address (void)
  86 {
  87   ElfW(Addr) *got;
  88   ElfW(Addr) dynamic;
  89
  90 #ifdef __tilegx__
  91   ElfW(Addr) tmp;
  92   asm( "        lnk %2\n"
  93        "1:      {\n"
  94        "         moveli %0, hw2_last(_GLOBAL_OFFSET_TABLE_ - 1b)\n"
  95        "         moveli %1, hw2_last(_DYNAMIC - 1b)\n"
  96        "        }\n"
  97        "        {\n"
  98        "         shl16insli %0, %0, hw1(_GLOBAL_OFFSET_TABLE_ - 1b)\n"
  99        "         shl16insli %1, %1, hw1(_DYNAMIC - 1b)\n"
 100        "        }\n"
 101        "        {\n"
 102        "         shl16insli %0, %0, hw0(_GLOBAL_OFFSET_TABLE_ - 1b)\n"
 103        "         shl16insli %1, %1, hw0(_DYNAMIC - 1b)\n"
 104        "        }\n"
 105        "        {\n"
 106        "         add %0, %0, %2\n"
 107        "         add %1, %1, %2\n"
 108        "        }"
 109        : "=r" (got), "=r" (dynamic), "=r" (tmp));
 110 #else
 111   asm( "        lnk %0\n"
 112        "1:      {\n"
 113        "         addli %0, %0, lo16(_GLOBAL_OFFSET_TABLE_ - 1b)\n"
 114        "         addli %1, %0, lo16(_DYNAMIC - 1b)\n"
 115        "        }\n"
 116        "        {\n"
 117        "         auli %0, %0, ha16(_GLOBAL_OFFSET_TABLE_ - 1b)\n"
 118        "         auli %1, %1, ha16(_DYNAMIC - 1b)\n"
 119        "        }\n"
 120        : "=r" (got), "=r" (dynamic));
 121 #endif
 122
 123   return dynamic - *got;
 124 }
 125
 126 /* Flush some range of the instruction cache.  If invoked prior to
 127    actually setting dl_pagesize, we conservatively use 4KB, which
 128    is the smallest page size we could plausibly be running with.  */
 129 static inline void
 130 _dl_flush_icache (const void *addr, unsigned long size)
 131 {
 132   invalidate_icache (addr, size, GLRO(dl_pagesize) ? : 4096);
 133 }
 134
 135 /* Set up the loaded object described by L so its unrelocated PLT
 136    entries will jump to the on-demand fixup code in dl-runtime.c.  */
 137
 138 static inline int __attribute__ ((unused))
 139 elf_machine_runtime_setup (struct link_map *l, int lazy, int profile)
 140 {
 141   ElfW(Addr) *gotplt;
 142   extern void _dl_runtime_resolve (ElfW(Word));
 143   extern void _dl_runtime_profile (ElfW(Word));
 144
 145   if (l->l_info[DT_JMPREL] && lazy)
 146     {
 147       gotplt = (ElfW(Addr) *) D_PTR (l, l_info[DT_PLTGOT]);
 148
 149       /* The GOT entries for functions in the PLT have not yet been filled
 150          in.  Their initial contents will arrange when called to put in
 151          registers an offset into the .rel.plt section, and gotplt[0], then
 152          jump to gotplt[1].  */
 153
 154       /* Identify this shared object.  */
 155       gotplt[0] = (ElfW(Addr)) l;
 156
 157       /* The gotplt[1] entry contains the address of a function which gets
 158          called to get the address of a so far unresolved function and jump
 159          to it.  The profiling extension of the dynamic linker allows to
 160          intercept the calls to collect information.  In this case we don't
 161          store the address in the GOTPLT so that all future calls also end
 162          in this function.  */
 163       if (__builtin_expect (profile, 0))
 164         {
 165           gotplt[1] = (ElfW(Addr)) &_dl_runtime_profile;
 166
 167           if (GLRO(dl_profile) != NULL
 168               && _dl_name_match_p (GLRO(dl_profile), l))
 169             /* This is the object we are looking for.  Say that we really
 170                want profiling and the timers are started.  */
 171             GL(dl_profile_map) = l;
 172         }
 173       else
 174         /* This function will get called to fix up the GOTPLT entry
 175            indicated by the offset on the stack, and then jump to the
 176            resolved address.  */
 177         gotplt[1] = (ElfW(Addr)) &_dl_runtime_resolve;
 178     }
 179
 180   return lazy;
 181 }
 182
 183 #if __WORDSIZE == 32
 184 /* Mask identifying addresses reserved for the user program,
 185    where the dynamic linker should not map anything.  */
 186 #define ELF_MACHINE_USER_ADDRESS_MASK   0xf8000000UL
 187 #endif
 188
 189 /* Initial entry point code for the dynamic linker.
 190    The C function `_dl_start' is the real entry point;
 191    its return value is the user program's entry point.  */
 192
 193 #define RTLD_START asm (".globl _dl_start");
 194
 195 #ifndef RTLD_START_SPECIAL_INIT
 196 #define RTLD_START_SPECIAL_INIT /* nothing */
 197 #endif
 198
 199 /* Wrap a generic Tilera relocation type. */
 200 #ifdef __tilegx__
 201 #define R_TILE(x) R_TILEGX_##x
 202 #define __R_TILE_TLS(x,c) R_TILEGX_TLS_##x##c
 203 #define _R_TILE_TLS(x,c) __R_TILE_TLS(x,c)
 204 #define R_TILE_TLS(x) _R_TILE_TLS(x,__ELF_NATIVE_CLASS)
 205 #else
 206 #define R_TILE(x) R_TILEPRO_##x
 207 #define R_TILE_TLS(x) R_TILEPRO_TLS_##x##32
 208 #endif
 209
 210 /* ELF_RTYPE_CLASS_PLT iff TYPE describes relocation of a PLT entry or
 211    TLS variable, so undefined references should not be allowed to
 212    define the value.
 213    ELF_RTYPE_CLASS_COPY iff TYPE should not be allowed to resolve to one
 214    of the main executable's symbols, as for a COPY reloc.  */
 215 #define elf_machine_type_class(type) \
 216   ((((type) == R_TILE(JMP_SLOT) || (type) == R_TILE_TLS(DTPMOD)               \
 217      || (type) == R_TILE_TLS(DTPOFF) || (type) == R_TILE_TLS(TPOFF))          \
 218     * ELF_RTYPE_CLASS_PLT)                                                    \
 219    | (((type) == R_TILE(COPY)) * ELF_RTYPE_CLASS_COPY))
 220
 221 /* A reloc type used for ld.so cmdline arg lookups to reject PLT entries.  */
 222 #define ELF_MACHINE_JMP_SLOT R_TILE(JMP_SLOT)
 223
 224 /* TILE never uses Elf32_Rel relocations.  */
 225 #define ELF_MACHINE_NO_REL 1
 226 #define ELF_MACHINE_NO_RELA 0
 227
 228 /* We define an initialization functions.  This is called very early in
 229    _dl_sysdep_start.  */
 230 #define DL_PLATFORM_INIT dl_platform_init ()
 231
 232 static inline void __attribute__ ((unused))
 233 dl_platform_init (void)
 234 {
 235   if (GLRO(dl_platform) != NULL && *GLRO(dl_platform) == '\0')
 236     /* Avoid an empty string which would disturb us.  */
 237     GLRO(dl_platform) = NULL;
 238 }
 239
 240 static inline ElfW(Addr)
 241 elf_machine_fixup_plt (struct link_map *map, lookup_t t,
 242                        const ElfW(Sym) *refsym, const ElfW(Sym) *sym,
 243                        const ElfW(Rela) *reloc,
 244                        ElfW(Addr) *reloc_addr, ElfW(Addr) value)
 245 {
 246   return *reloc_addr = value;
 247 }
 248
 249 /* Return the final value of a plt relocation.  */
 250 static inline ElfW(Addr)
 251 elf_machine_plt_value (struct link_map *map, const ElfW(Rela) *reloc,
 252                        ElfW(Addr) value)
 253 {
 254   return value;
 255 }
 256
 257 /* Support notifying the simulator about new objects. */
 258 void internal_function _dl_after_load (struct link_map *l);
 259 #define DL_AFTER_LOAD _dl_after_load
 260
 261 /* Names of the architecture-specific auditing callback functions.  */
 262 #define ARCH_LA_PLTENTER tile_gnu_pltenter
 263 #define ARCH_LA_PLTEXIT tile_gnu_pltexit
 264
 265 #endif /* !dl_machine_h */
 266
 267
 268 #ifdef RESOLVE_MAP
 269
 270 struct reloc_howto
 271 {
 272   /* Right shift operand by this number of bits. */
 273   unsigned char right_shift;
 274
 275 #ifdef __tilegx__
 276   /* If nonzero, this is updating a code bundle. */
 277   unsigned char is_bundle_update;
 278 #else
 279   /* If nonzero, add 0x8000 to the value. */
 280   unsigned char add_0x8000;
 281 #endif
 282
 283   /* If nonzero, subtract the containing address from the address. */
 284   unsigned char is_pcrel;
 285
 286   /* Size in bytes, or 0 if this table entry should be ignored. */
 287   unsigned char byte_size;
 288 };
 289
 290 /* Relocation information. Cannot contain create_* function pointers
 291    because then the table would not be position-independent. */
 292 static const struct reloc_howto howto[] =
 293 {
 294 #ifdef __tilegx__
 295
 296 # if __WORDSIZE == 32
 297   /* The GX -m32 loader only handles 32-bit types, so it will be confused
 298      by shifts larger than that.  We convert them to just sign-extend;
 299      they usually indicate a program bug or missed optimization, but we
 300      have to handle them correctly anyway.  */
 301 #  define S32 31
 302 #  define S48 31
 303 # else
 304 #  define S32 32
 305 #  define S48 48
 306 # endif
 307
 308   /* R_TILEGX_NONE */                    {   0, 0, 0, 0 },
 309   /* R_TILEGX_64 */                      {   0, 0, 0, 8 },
 310   /* R_TILEGX_32 */                      {   0, 0, 0, 4 },
 311   /* R_TILEGX_16 */                      {   0, 0, 0, 2 },
 312   /* R_TILEGX_8 */                       {   0, 0, 0, 1 },
 313   /* R_TILEGX_64_PCREL */                {   0, 0, 1, 8 },
 314   /* R_TILEGX_32_PCREL */                {   0, 0, 1, 4 },
 315   /* R_TILEGX_16_PCREL */                {   0, 0, 1, 2 },
 316   /* R_TILEGX_8_PCREL */                 {   0, 0, 1, 1 },
 317   /* R_TILEGX_HW0 */                     {   0, 0, 0, 0 },
 318   /* R_TILEGX_HW1 */                     {  16, 0, 0, 0 },
 319   /* R_TILEGX_HW2 */                     { S32, 0, 0, 0 },
 320   /* R_TILEGX_HW3 */                     { S48, 0, 0, 0 },
 321   /* R_TILEGX_HW0_LAST */                {   0, 0, 0, 0 },
 322   /* R_TILEGX_HW1_LAST */                {  16, 0, 0, 0 },
 323   /* R_TILEGX_HW2_LAST */                { S32, 0, 0, 0 },
 324   /* R_TILEGX_COPY */                    {   0, 0, 0, 0 },
 325   /* R_TILEGX_GLOB_DAT */                {   0, 0, 0, 8 },
 326   /* R_TILEGX_JMP_SLOT */                {   0, 0, 0, 0 },
 327   /* R_TILEGX_RELATIVE */                {   0, 0, 0, 0 },
 328   /* R_TILEGX_BROFF_X1 */                {   3, 1, 1, 8 },
 329   /* R_TILEGX_JUMPOFF_X1 */              {   3, 1, 1, 8 },
 330   /* R_TILEGX_JUMPOFF_X1_PLT */          {   3, 1, 1, 8 },
 331   /* R_TILEGX_IMM8_X0 */                 {   0, 1, 0, 8 },
 332   /* R_TILEGX_IMM8_Y0 */                 {   0, 1, 0, 8 },
 333   /* R_TILEGX_IMM8_X1 */                 {   0, 1, 0, 8 },
 334   /* R_TILEGX_IMM8_Y1 */                 {   0, 1, 0, 8 },
 335   /* R_TILEGX_DEST_IMM8_X1 */            {   0, 1, 0, 8 },
 336   /* R_TILEGX_MT_IMM14_X1 */             {   0, 1, 0, 8 },
 337   /* R_TILEGX_MF_IMM14_X1 */             {   0, 1, 0, 8 },
 338   /* R_TILEGX_MMSTART_X0 */              {   0, 1, 0, 8 },
 339   /* R_TILEGX_MMEND_X0 */                {   0, 1, 0, 8 },
 340   /* R_TILEGX_SHAMT_X0 */                {   0, 1, 0, 8 },
 341   /* R_TILEGX_SHAMT_X1 */                {   0, 1, 0, 8 },
 342   /* R_TILEGX_SHAMT_Y0 */                {   0, 1, 0, 8 },
 343   /* R_TILEGX_SHAMT_Y1 */                {   0, 1, 0, 8 },
 344   /* R_TILEGX_IMM16_X0_HW0 */            {   0, 1, 0, 8 },
 345   /* R_TILEGX_IMM16_X1_HW0 */            {   0, 1, 0, 8 },
 346   /* R_TILEGX_IMM16_X0_HW1 */            {  16, 1, 0, 8 },
 347   /* R_TILEGX_IMM16_X1_HW1 */            {  16, 1, 0, 8 },
 348   /* R_TILEGX_IMM16_X0_HW2 */            { S32, 1, 0, 8 },
 349   /* R_TILEGX_IMM16_X1_HW2 */            { S32, 1, 0, 8 },
 350   /* R_TILEGX_IMM16_X0_HW3 */            { S48, 1, 0, 8 },
 351   /* R_TILEGX_IMM16_X1_HW3 */            { S48, 1, 0, 8 },
 352   /* R_TILEGX_IMM16_X0_HW0_LAST */       {   0, 1, 0, 8 },
 353   /* R_TILEGX_IMM16_X1_HW0_LAST */       {   0, 1, 0, 8 },
 354   /* R_TILEGX_IMM16_X0_HW1_LAST */       {  16, 1, 0, 8 },
 355   /* R_TILEGX_IMM16_X1_HW1_LAST */       {  16, 1, 0, 8 },
 356   /* R_TILEGX_IMM16_X0_HW2_LAST */       { S32, 1, 0, 8 },
 357   /* R_TILEGX_IMM16_X1_HW2_LAST */       { S32, 1, 0, 8 },
 358   /* R_TILEGX_IMM16_X0_HW0_PCREL */      {   0, 1, 1, 8 },
 359   /* R_TILEGX_IMM16_X1_HW0_PCREL */      {   0, 1, 1, 8 },
 360   /* R_TILEGX_IMM16_X0_HW1_PCREL */      {  16, 1, 1, 8 },
 361   /* R_TILEGX_IMM16_X1_HW1_PCREL */      {  16, 1, 1, 8 },
 362   /* R_TILEGX_IMM16_X0_HW2_PCREL */      { S32, 1, 1, 8 },
 363   /* R_TILEGX_IMM16_X1_HW2_PCREL */      { S32, 1, 1, 8 },
 364   /* R_TILEGX_IMM16_X0_HW3_PCREL */      { S48, 1, 1, 8 },
 365   /* R_TILEGX_IMM16_X1_HW3_PCREL */      { S48, 1, 1, 8 },
 366   /* R_TILEGX_IMM16_X0_HW0_LAST_PCREL */ {   0, 1, 1, 8 },
 367   /* R_TILEGX_IMM16_X1_HW0_LAST_PCREL */ {   0, 1, 1, 8 },
 368   /* R_TILEGX_IMM16_X0_HW1_LAST_PCREL */ {  16, 1, 1, 8 },
 369   /* R_TILEGX_IMM16_X1_HW1_LAST_PCREL */ {  16, 1, 1, 8 },
 370   /* R_TILEGX_IMM16_X0_HW2_LAST_PCREL */ { S32, 1, 1, 8 },
 371   /* R_TILEGX_IMM16_X1_HW2_LAST_PCREL */ { S32, 1, 1, 8 },
 372   /* R_TILEGX_IMM16_X0_HW0_GOT */        {   0, 1, 0, 0 },
 373   /* R_TILEGX_IMM16_X1_HW0_GOT */        {   0, 1, 0, 0 },
 374   /* R_TILEGX_IMM16_X0_HW1_GOT */        {  16, 1, 0, 0 },
 375   /* R_TILEGX_IMM16_X1_HW1_GOT */        {  16, 1, 0, 0 },
 376   /* R_TILEGX_IMM16_X0_HW2_GOT */        { S32, 1, 0, 0 },
 377   /* R_TILEGX_IMM16_X1_HW2_GOT */        { S32, 1, 0, 0 },
 378   /* R_TILEGX_IMM16_X0_HW3_GOT */        { S48, 1, 0, 0 },
 379   /* R_TILEGX_IMM16_X1_HW3_GOT */        { S48, 1, 0, 0 },
 380   /* R_TILEGX_IMM16_X0_HW0_LAST_GOT */   {   0, 1, 0, 0 },
 381   /* R_TILEGX_IMM16_X1_HW0_LAST_GOT */   {   0, 1, 0, 0 },
 382   /* R_TILEGX_IMM16_X0_HW1_LAST_GOT */   {  16, 1, 0, 0 },
 383   /* R_TILEGX_IMM16_X1_HW1_LAST_GOT */   {  16, 1, 0, 0 },
 384   /* R_TILEGX_IMM16_X0_HW2_LAST_GOT */   { S32, 1, 0, 0 },
 385   /* R_TILEGX_IMM16_X1_HW2_LAST_GOT */   { S32, 1, 0, 0 },
 386   /* R_TILEGX_IMM16_X0_HW0_TLS_GD */     {   0, 1, 0, 8 },
 387   /* R_TILEGX_IMM16_X1_HW0_TLS_GD */     {   0, 1, 0, 8 },
 388   /* R_TILEGX_IMM16_X0_HW1_TLS_GD */     {  16, 1, 0, 8 },
 389   /* R_TILEGX_IMM16_X1_HW1_TLS_GD */     {  16, 1, 0, 8 },
 390   /* R_TILEGX_IMM16_X0_HW2_TLS_GD */     { S32, 1, 0, 8 },
 391   /* R_TILEGX_IMM16_X1_HW2_TLS_GD */     { S32, 1, 0, 8 },
 392   /* R_TILEGX_IMM16_X0_HW3_TLS_GD */     { S48, 1, 0, 8 },
 393   /* R_TILEGX_IMM16_X1_HW3_TLS_GD */     { S48, 1, 0, 8 },
 394   /* R_TILEGX_IMM16_X0_HW0_LAST_TLS_GD */{   0, 1, 0, 8 },
 395   /* R_TILEGX_IMM16_X1_HW0_LAST_TLS_GD */{   0, 1, 0, 8 },
 396   /* R_TILEGX_IMM16_X0_HW1_LAST_TLS_GD */{  16, 1, 0, 8 },
 397   /* R_TILEGX_IMM16_X1_HW1_LAST_TLS_GD */{  16, 1, 0, 8 },
 398   /* R_TILEGX_IMM16_X0_HW2_LAST_TLS_GD */{ S32, 1, 0, 8 },
 399   /* R_TILEGX_IMM16_X1_HW2_LAST_TLS_GD */{ S32, 1, 0, 8 },
 400   /* R_TILEGX_IMM16_X0_HW0_TLS_IE */     {   0, 1, 0, 8 },
 401   /* R_TILEGX_IMM16_X1_HW0_TLS_IE */     {   0, 1, 0, 8 },
 402   /* R_TILEGX_IMM16_X0_HW1_TLS_IE */     {  16, 1, 0, 8 },
 403   /* R_TILEGX_IMM16_X1_HW1_TLS_IE */     {  16, 1, 0, 8 },
 404   /* R_TILEGX_IMM16_X0_HW2_TLS_IE */     { S32, 1, 0, 8 },
 405   /* R_TILEGX_IMM16_X1_HW2_TLS_IE */     { S32, 1, 0, 8 },
 406   /* R_TILEGX_IMM16_X0_HW3_TLS_IE */     { S48, 1, 0, 8 },
 407   /* R_TILEGX_IMM16_X1_HW3_TLS_IE */     { S48, 1, 0, 8 },
 408   /* R_TILEGX_IMM16_X0_HW0_LAST_TLS_IE */{   0, 1, 0, 8 },
 409   /* R_TILEGX_IMM16_X1_HW0_LAST_TLS_IE */{   0, 1, 0, 8 },
 410   /* R_TILEGX_IMM16_X0_HW1_LAST_TLS_IE */{  16, 1, 0, 8 },
 411   /* R_TILEGX_IMM16_X1_HW1_LAST_TLS_IE */{  16, 1, 0, 8 },
 412   /* R_TILEGX_IMM16_X0_HW2_LAST_TLS_IE */{ S32, 1, 0, 8 },
 413   /* R_TILEGX_IMM16_X1_HW2_LAST_TLS_IE */{ S32, 1, 0, 8 },
 414   /* R_TILEGX_TLS_DTPMOD64 */            {   0, 0, 0, 0 },
 415   /* R_TILEGX_TLS_DTPOFF64 */            {   0, 0, 0, 0 },
 416   /* R_TILEGX_TLS_TPOFF64 */             {   0, 0, 0, 0 },
 417   /* R_TILEGX_TLS_DTPMOD32 */            {   0, 0, 0, 0 },
 418   /* R_TILEGX_TLS_DTPOFF32 */            {   0, 0, 0, 0 },
 419   /* R_TILEGX_TLS_TPOFF32 */             {   0, 0, 0, 0 }
 420 #else
 421   /* R_TILEPRO_NONE */                   { 0,  0, 0, 0 },
 422   /* R_TILEPRO_32 */                     { 0,  0, 0, 4 },
 423   /* R_TILEPRO_16 */                     { 0,  0, 0, 2 },
 424   /* R_TILEPRO_8 */                      { 0,  0, 0, 1 },
 425   /* R_TILEPRO_32_PCREL */               { 0,  0, 1, 4 },
 426   /* R_TILEPRO_16_PCREL */               { 0,  0, 1, 2 },
 427   /* R_TILEPRO_8_PCREL */                { 0,  0, 1, 1 },
 428   /* R_TILEPRO_LO16 */                   { 0,  0, 0, 2 },
 429   /* R_TILEPRO_HI16 */                   { 16, 0, 0, 2 },
 430   /* R_TILEPRO_HA16 */                   { 16, 1, 0, 2 },
 431   /* R_TILEPRO_COPY */                   { 0,  0, 0, 0 },
 432   /* R_TILEPRO_GLOB_DAT */               { 0,  0, 0, 4 },
 433   /* R_TILEPRO_JMP_SLOT */               { 0,  0, 0, 0 },
 434   /* R_TILEPRO_RELATIVE */               { 0,  0, 0, 0 },
 435   /* R_TILEPRO_BROFF_X1 */               { 3,  0, 1, 8 },
 436   /* R_TILEPRO_JOFFLONG_X1 */            { 3,  0, 1, 8 },
 437   /* R_TILEPRO_JOFFLONG_X1_PLT */        { 3,  0, 1, 8 },
 438   /* R_TILEPRO_IMM8_X0 */                { 0,  0, 0, 8 },
 439   /* R_TILEPRO_IMM8_Y0 */                { 0,  0, 0, 8 },
 440   /* R_TILEPRO_IMM8_X1 */                { 0,  0, 0, 8 },
 441   /* R_TILEPRO_IMM8_Y1 */                { 0,  0, 0, 8 },
 442   /* R_TILEPRO_MT_IMM15_X1 */            { 0,  0, 0, 8 },
 443   /* R_TILEPRO_MF_IMM15_X1 */            { 0,  0, 0, 8 },
 444   /* R_TILEPRO_IMM16_X0 */               { 0,  0, 0, 8 },
 445   /* R_TILEPRO_IMM16_X1 */               { 0,  0, 0, 8 },
 446   /* R_TILEPRO_IMM16_X0_LO */            { 0,  0, 0, 8 },
 447   /* R_TILEPRO_IMM16_X1_LO */            { 0,  0, 0, 8 },
 448   /* R_TILEPRO_IMM16_X0_HI */            { 16, 0, 0, 8 },
 449   /* R_TILEPRO_IMM16_X1_HI */            { 16, 0, 0, 8 },
 450   /* R_TILEPRO_IMM16_X0_HA */            { 16, 1, 0, 8 },
 451   /* R_TILEPRO_IMM16_X1_HA */            { 16, 1, 0, 8 },
 452   /* R_TILEPRO_IMM16_X0_PCREL */         { 0,  0, 1, 8 },
 453   /* R_TILEPRO_IMM16_X1_PCREL */         { 0,  0, 1, 8 },
 454   /* R_TILEPRO_IMM16_X0_LO_PCREL */      { 0,  0, 1, 8 },
 455   /* R_TILEPRO_IMM16_X1_LO_PCREL */      { 0,  0, 1, 8 },
 456   /* R_TILEPRO_IMM16_X0_HI_PCREL */      { 16, 0, 1, 8 },
 457   /* R_TILEPRO_IMM16_X1_HI_PCREL */      { 16, 0, 1, 8 },
 458   /* R_TILEPRO_IMM16_X0_HA_PCREL */      { 16, 1, 1, 8 },
 459   /* R_TILEPRO_IMM16_X1_HA_PCREL */      { 16, 1, 1, 8 },
 460   /* R_TILEPRO_IMM16_X0_GOT */           { 0,  0, 0, 0 },
 461   /* R_TILEPRO_IMM16_X1_GOT */           { 0,  0, 0, 0 },
 462   /* R_TILEPRO_IMM16_X0_GOT_LO */        { 0,  0, 0, 0 },
 463   /* R_TILEPRO_IMM16_X1_GOT_LO */        { 0,  0, 0, 0 },
 464   /* R_TILEPRO_IMM16_X0_GOT_HI */        { 0,  0, 0, 0 },
 465   /* R_TILEPRO_IMM16_X1_GOT_HI */        { 0,  0, 0, 0 },
 466   /* R_TILEPRO_IMM16_X0_GOT_HA */        { 0,  0, 0, 0 },
 467   /* R_TILEPRO_IMM16_X1_GOT_HA */        { 0,  0, 0, 0 },
 468   /* R_TILEPRO_MMSTART_X0 */             { 0,  0, 0, 8 },
 469   /* R_TILEPRO_MMEND_X0 */               { 0,  0, 0, 8 },
 470   /* R_TILEPRO_MMSTART_X1 */             { 0,  0, 0, 8 },
 471   /* R_TILEPRO_MMEND_X1 */               { 0,  0, 0, 8 },
 472   /* R_TILEPRO_SHAMT_X0 */               { 0,  0, 0, 8 },
 473   /* R_TILEPRO_SHAMT_X1 */               { 0,  0, 0, 8 },
 474   /* R_TILEPRO_SHAMT_Y0 */               { 0,  0, 0, 8 },
 475   /* R_TILEPRO_SHAMT_Y1 */               { 0,  0, 0, 8 },
 476   /* R_TILEPRO_SN_BROFF */               { 0,  0, 0, 0 },
 477   /* R_TILEPRO_SN_IMM8 */                { 0,  0, 0, 0 },
 478   /* R_TILEPRO_SN_UIMM8 */               { 0,  0, 0, 0 },
 479   /* R_TILEPRO_SN_BYTE0 */               { 0,  0, 0, 0 },
 480   /* R_TILEPRO_SN_BYTE1 */               { 0,  0, 0, 0 },
 481   /* R_TILEPRO_SN_BYTE2 */               { 0,  0, 0, 0 },
 482   /* R_TILEPRO_SN_BYTE3 */               { 0,  0, 0, 0 },
 483   /* R_TILEPRO_SN_SPCREL0 */             { 0,  0, 0, 0 },
 484   /* R_TILEPRO_SN_SPCREL1 */             { 0,  0, 0, 0 },
 485   /* R_TILEPRO_SN_SPCREL2 */             { 0,  0, 0, 0 },
 486   /* R_TILEPRO_SN_SPCREL3 */             { 0,  0, 0, 0 },
 487   /* R_TILEPRO_IMM16_X0_TLS_GD */        { 0,  0, 0, 8 },
 488   /* R_TILEPRO_IMM16_X1_TLS_GD */        { 0,  0, 0, 8 },
 489   /* R_TILEPRO_IMM16_X0_TLS_GD_LO */     { 0,  0, 0, 8 },
 490   /* R_TILEPRO_IMM16_X1_TLS_GD_LO */     { 0,  0, 0, 8 },
 491   /* R_TILEPRO_IMM16_X0_TLS_GD_HI */     { 16, 0, 0, 8 },
 492   /* R_TILEPRO_IMM16_X1_TLS_GD_HI */     { 16, 0, 0, 8 },
 493   /* R_TILEPRO_IMM16_X0_TLS_GD_HA */     { 16, 1, 0, 8 },
 494   /* R_TILEPRO_IMM16_X1_TLS_GD_HA */     { 16, 1, 0, 8 },
 495   /* R_TILEPRO_IMM16_X0_TLS_IE */        { 0,  0, 0, 8 },
 496   /* R_TILEPRO_IMM16_X1_TLS_IE */        { 0,  0, 0, 8 },
 497   /* R_TILEPRO_IMM16_X0_TLS_IE_LO */     { 0,  0, 0, 8 },
 498   /* R_TILEPRO_IMM16_X1_TLS_IE_LO */     { 0,  0, 0, 8 },
 499   /* R_TILEPRO_IMM16_X0_TLS_IE_HI */     { 16, 0, 0, 8 },
 500   /* R_TILEPRO_IMM16_X1_TLS_IE_HI */     { 16, 0, 0, 8 },
 501   /* R_TILEPRO_IMM16_X0_TLS_IE_HA */     { 16, 1, 0, 8 },
 502   /* R_TILEPRO_IMM16_X1_TLS_IE_HA */     { 16, 1, 0, 8 },
 503   /* R_TILEPRO_TLS_DTPMOD32 */           { 0,  0, 0, 0 },
 504   /* R_TILEPRO_TLS_DTPOFF32 */           { 0,  0, 0, 0 },
 505   /* R_TILEPRO_TLS_TPOFF32 */            { 0,  0, 0, 0 },
 506 #endif
 507 };
 508
 509 #if __ELF_NATIVE_CLASS == 32
 510 #define ELFW_R_TYPE     ELF32_R_TYPE
 511 #define ELFW_ST_TYPE    ELF32_ST_TYPE
 512 #else
 513 #define ELFW_R_TYPE     ELF64_R_TYPE
 514 #define ELFW_ST_TYPE    ELF64_ST_TYPE
 515 #endif
 516
 517 /* Perform the relocation specified by RELOC and SYM (which is fully resolved).
 518    MAP is the object containing the reloc.  */
 519
 520 auto inline void __attribute__ ((always_inline))
 521 elf_machine_rela (struct link_map *map, const ElfW(Rela) *reloc,
 522                   const ElfW(Sym) *sym, const struct r_found_version *version,
 523                   void *const reloc_addr_arg, int skip_ifunc)
 524 {
 525   ElfW(Addr) *const reloc_addr = reloc_addr_arg;
 526   const unsigned int r_type = ELFW_R_TYPE (reloc->r_info);
 527
 528 #if !defined RTLD_BOOTSTRAP || !defined HAVE_Z_COMBRELOC
 529   if (__builtin_expect (r_type == R_TILE(RELATIVE), 0))
 530     {
 531 # if !defined RTLD_BOOTSTRAP && !defined HAVE_Z_COMBRELOC
 532       /* This is defined in rtld.c, but nowhere in the static libc.a;
 533          make the reference weak so static programs can still link.
 534          This declaration cannot be done when compiling rtld.c
 535          (i.e. #ifdef RTLD_BOOTSTRAP) because rtld.c contains the
 536          common defn for _dl_rtld_map, which is incompatible with a
 537          weak decl in the same file.  */
 538 #  ifndef SHARED
 539       weak_extern (GL(dl_rtld_map));
 540 #  endif
 541       if (map != &GL(dl_rtld_map)) /* Already done in rtld itself.  */
 542 # endif
 543         *reloc_addr = map->l_addr + reloc->r_addend;
 544       return;
 545     }
 546 #endif
 547
 548   if (__builtin_expect (r_type == R_TILE(NONE), 0))
 549     return;
 550
 551 #if !defined RTLD_BOOTSTRAP && !defined RESOLVE_CONFLICT_FIND_MAP
 552   const ElfW(Sym) *const refsym = sym;
 553 #endif
 554   struct link_map *sym_map = RESOLVE_MAP (&sym, version, r_type);
 555   ElfW(Addr) value;
 556
 557   if (sym == NULL)
 558     value = 0;
 559   else if (ELFW_ST_TYPE (sym->st_info) == STT_SECTION)
 560     value = map->l_addr;  /* like a RELATIVE reloc */
 561   else
 562     value = sym_map->l_addr + sym->st_value;
 563
 564   if (sym != NULL
 565       && __builtin_expect (ELFW(ST_TYPE) (sym->st_info) == STT_GNU_IFUNC, 0)
 566       && __builtin_expect (sym->st_shndx != SHN_UNDEF, 1)
 567       && __builtin_expect (!skip_ifunc, 1))
 568     value = ((Elf64_Addr (*) (void)) value) ();
 569
 570   switch (r_type)
 571     {
 572     case R_TILE(JMP_SLOT):
 573       elf_machine_fixup_plt (map, 0, 0, 0, reloc, reloc_addr,
 574                              value + reloc->r_addend);
 575       return;
 576
 577 #ifndef RESOLVE_CONFLICT_FIND_MAP
 578     case R_TILE_TLS(DTPMOD):
 579 # ifdef RTLD_BOOTSTRAP
 580       /* During startup the dynamic linker is always the module
 581          with index 1.
 582          XXX If this relocation is necessary move before RESOLVE
 583          call.  */
 584       *reloc_addr = 1;
 585 # else
 586       /* Get the information from the link map returned by the
 587          resolv function.  */
 588       if (sym_map != NULL)
 589         *reloc_addr = sym_map->l_tls_modid;
 590 # endif
 591       return;
 592     case R_TILE_TLS(DTPOFF):
 593 # ifndef RTLD_BOOTSTRAP
 594       /* During relocation all TLS symbols are defined and used.
 595          Therefore the offset is already correct.  */
 596       if (sym != NULL)
 597         *reloc_addr = sym->st_value + reloc->r_addend;
 598 # endif
 599       return;
 600     case R_TILE_TLS(TPOFF):
 601 # ifdef RTLD_BOOTSTRAP
 602       *reloc_addr = sym->st_value + reloc->r_addend + map->l_tls_offset;
 603 # else
 604       if (sym != NULL)
 605         {
 606           CHECK_STATIC_TLS (map, sym_map);
 607           *reloc_addr = (sym->st_value + reloc->r_addend
 608                          + sym_map->l_tls_offset);
 609         }
 610 #endif
 611       return;
 612 #endif /* use TLS */
 613
 614 #if !defined RTLD_BOOTSTRAP && !defined RESOLVE_CONFLICT_FIND_MAP
 615       /* Not needed in dl-conflict.c.  */
 616     case R_TILE(COPY):
 617       if (sym == NULL)
 618         /* This can happen in trace mode if an object could not be found.  */
 619         return;
 620       if (__builtin_expect (sym->st_size > refsym->st_size, 0)
 621           || (__builtin_expect (sym->st_size < refsym->st_size, 0)
 622               && __builtin_expect (GLRO(dl_verbose), 0)))
 623         {
 624           const char *strtab;
 625
 626           strtab = (const char *) D_PTR (map,l_info[DT_STRTAB]);
 627           _dl_error_printf ("%s: Symbol `%s' has different size in shared"
 628                             " object, consider re-linking\n",
 629                             RTLD_PROGNAME, strtab + refsym->st_name);
 630         }
 631       memcpy (reloc_addr_arg, (void *) value,
 632               MIN (sym->st_size, refsym->st_size));
 633       return;
 634 #endif
 635     }
 636
 637   /* All remaining relocations must be in the lookup table. */
 638   const struct reloc_howto *h = &howto[r_type];
 639   if ((unsigned int) r_type >= sizeof howto / sizeof howto[0] ||
 640       h->byte_size == 0)
 641     {
 642 #if !defined RTLD_BOOTSTRAP || defined _NDEBUG
 643       /* We add these checks in the version to relocate ld.so only
 644          if we are still debugging.  */
 645       _dl_reloc_bad_type (map, r_type, 0);
 646 #endif
 647       return;
 648     }
 649
 650   value += reloc->r_addend;
 651
 652   /* The lookup table entry knows how to perform this reloc. */
 653   if (h->is_pcrel)
 654     value -= (ElfW(Addr)) reloc_addr;
 655
 656 #ifndef __tilegx__
 657   if (h->add_0x8000)
 658     value += 0x8000;
 659 #endif
 660
 661   value = ((long) value) >> h->right_shift;
 662
 663   switch (h->byte_size)
 664     {
 665     case 1:
 666       *(char *) reloc_addr = value;
 667       return;
 668     case 2:
 669       *(short *) reloc_addr = value;
 670       return;
 671     case 4:
 672       *(int *) reloc_addr = value;
 673       return;
 674 #ifdef __tilegx__
 675     case 8:
 676       if (!h->is_bundle_update)
 677         {
 678           *(ElfW(Addr) *) reloc_addr = value;
 679           return;
 680         }
 681 #endif
 682     }
 683
 684   /* We are updating a bundle, so use the function pointer that
 685      swizzles the operand bits into the right location. */
 686
 687   tile_bundle_bits *p = (tile_bundle_bits *) reloc_addr;
 688   tile_bundle_bits bits = *p;
 689
 690 #define MUNGE_SIGNED(func, length) do {                             \
 691     bits = ((bits & ~create_##func (-1)) | create_##func (value));  \
 692     ElfW(Addr) result = get_##func (bits);                          \
 693     int signbits = __WORDSIZE - length;                             \
 694     result = (long) (result << signbits) >> signbits;               \
 695     if (result != value)                                            \
 696       _dl_signal_error (0, map->l_name, NULL,                       \
 697                         "relocation value too large for " #func);   \
 698   } while (0)
 699
 700 #define MUNGE(func) MUNGE_SIGNED(func, __WORDSIZE)
 701
 702 #define MUNGE_NOCHECK(func)                                     \
 703   bits = ((bits & ~create_##func (-1)) | create_##func (value))
 704
 705   switch (r_type)
 706     {
 707 #ifdef __tilegx__
 708     case R_TILEGX_BROFF_X1:
 709       MUNGE_SIGNED (BrOff_X1, 17);
 710       break;
 711     case R_TILEGX_JUMPOFF_X1:
 712     case R_TILEGX_JUMPOFF_X1_PLT:
 713       MUNGE_SIGNED (JumpOff_X1, 27);
 714       break;
 715     case R_TILEGX_IMM8_X0:
 716       MUNGE_SIGNED (Imm8_X0, 8);
 717       break;
 718     case R_TILEGX_IMM8_Y0:
 719       MUNGE_SIGNED (Imm8_Y0, 8);
 720       break;
 721     case R_TILEGX_IMM8_X1:
 722       MUNGE_SIGNED (Imm8_X1, 8);
 723       break;
 724     case R_TILEGX_IMM8_Y1:
 725       MUNGE_SIGNED (Imm8_Y1, 8);
 726       break;
 727     case R_TILEGX_MT_IMM14_X1:
 728       MUNGE (MT_Imm14_X1);
 729       break;
 730     case R_TILEGX_MF_IMM14_X1:
 731       MUNGE (MF_Imm14_X1);
 732       break;
 733     case R_TILEGX_IMM16_X0_HW0:
 734     case R_TILEGX_IMM16_X0_HW1:
 735     case R_TILEGX_IMM16_X0_HW2:
 736     case R_TILEGX_IMM16_X0_HW3:
 737     case R_TILEGX_IMM16_X0_HW0_PCREL:
 738     case R_TILEGX_IMM16_X0_HW1_PCREL:
 739     case R_TILEGX_IMM16_X0_HW2_PCREL:
 740     case R_TILEGX_IMM16_X0_HW3_PCREL:
 741     case R_TILEGX_IMM16_X0_HW0_TLS_GD:
 742     case R_TILEGX_IMM16_X0_HW0_TLS_IE:
 743       MUNGE_NOCHECK (Imm16_X0);
 744       break;
 745     case R_TILEGX_IMM16_X0_HW0_LAST:
 746     case R_TILEGX_IMM16_X0_HW1_LAST:
 747     case R_TILEGX_IMM16_X0_HW2_LAST:
 748     case R_TILEGX_IMM16_X0_HW0_LAST_PCREL:
 749     case R_TILEGX_IMM16_X0_HW1_LAST_PCREL:
 750     case R_TILEGX_IMM16_X0_HW2_LAST_PCREL:
 751     case R_TILEGX_IMM16_X0_HW0_LAST_TLS_GD:
 752     case R_TILEGX_IMM16_X0_HW1_LAST_TLS_GD:
 753     case R_TILEGX_IMM16_X0_HW0_LAST_TLS_IE:
 754     case R_TILEGX_IMM16_X0_HW1_LAST_TLS_IE:
 755       MUNGE_SIGNED (Imm16_X0, 16);
 756       break;
 757     case R_TILEGX_IMM16_X1_HW0:
 758     case R_TILEGX_IMM16_X1_HW1:
 759     case R_TILEGX_IMM16_X1_HW2:
 760     case R_TILEGX_IMM16_X1_HW3:
 761     case R_TILEGX_IMM16_X1_HW0_PCREL:
 762     case R_TILEGX_IMM16_X1_HW1_PCREL:
 763     case R_TILEGX_IMM16_X1_HW2_PCREL:
 764     case R_TILEGX_IMM16_X1_HW3_PCREL:
 765     case R_TILEGX_IMM16_X1_HW0_TLS_GD:
 766     case R_TILEGX_IMM16_X1_HW0_TLS_IE:
 767       MUNGE_NOCHECK (Imm16_X1);
 768       break;
 769     case R_TILEGX_IMM16_X1_HW0_LAST:
 770     case R_TILEGX_IMM16_X1_HW1_LAST:
 771     case R_TILEGX_IMM16_X1_HW2_LAST:
 772     case R_TILEGX_IMM16_X1_HW0_LAST_PCREL:
 773     case R_TILEGX_IMM16_X1_HW1_LAST_PCREL:
 774     case R_TILEGX_IMM16_X1_HW2_LAST_PCREL:
 775     case R_TILEGX_IMM16_X1_HW0_LAST_TLS_GD:
 776     case R_TILEGX_IMM16_X1_HW1_LAST_TLS_GD:
 777     case R_TILEGX_IMM16_X1_HW0_LAST_TLS_IE:
 778     case R_TILEGX_IMM16_X1_HW1_LAST_TLS_IE:
 779       MUNGE_SIGNED (Imm16_X1, 16);
 780       break;
 781     case R_TILEGX_MMSTART_X0:
 782       MUNGE (BFStart_X0);
 783       break;
 784     case R_TILEGX_MMEND_X0:
 785       MUNGE (BFEnd_X0);
 786       break;
 787     case R_TILEGX_SHAMT_X0:
 788       MUNGE (ShAmt_X0);
 789       break;
 790     case R_TILEGX_SHAMT_X1:
 791       MUNGE (ShAmt_X1);
 792       break;
 793     case R_TILEGX_SHAMT_Y0:
 794       MUNGE (ShAmt_Y0);
 795       break;
 796     case R_TILEGX_SHAMT_Y1:
 797       MUNGE (ShAmt_Y1);
 798       break;
 799 #else
 800     case R_TILEPRO_BROFF_X1:
 801       MUNGE_SIGNED (BrOff_X1, 17);
 802       break;
 803     case R_TILEPRO_JOFFLONG_X1:
 804     case R_TILEPRO_JOFFLONG_X1_PLT:
 805       MUNGE_NOCHECK (JOffLong_X1);   /* holds full 32-bit value */
 806       break;
 807     case R_TILEPRO_IMM8_X0:
 808       MUNGE_SIGNED (Imm8_X0, 8);
 809       break;
 810     case R_TILEPRO_IMM8_Y0:
 811       MUNGE_SIGNED (Imm8_Y0, 8);
 812       break;
 813     case R_TILEPRO_IMM8_X1:
 814       MUNGE_SIGNED (Imm8_X1, 8);
 815       break;
 816     case R_TILEPRO_IMM8_Y1:
 817       MUNGE_SIGNED (Imm8_Y1, 8);
 818       break;
 819     case R_TILEPRO_MT_IMM15_X1:
 820       MUNGE (MT_Imm15_X1);
 821       break;
 822     case R_TILEPRO_MF_IMM15_X1:
 823       MUNGE (MF_Imm15_X1);
 824       break;
 825     case R_TILEPRO_IMM16_X0_LO:
 826     case R_TILEPRO_IMM16_X0_HI:
 827     case R_TILEPRO_IMM16_X0_HA:
 828     case R_TILEPRO_IMM16_X0_LO_PCREL:
 829     case R_TILEPRO_IMM16_X0_HI_PCREL:
 830     case R_TILEPRO_IMM16_X0_HA_PCREL:
 831     case R_TILEPRO_IMM16_X0_TLS_GD_LO:
 832     case R_TILEPRO_IMM16_X0_TLS_GD_HI:
 833     case R_TILEPRO_IMM16_X0_TLS_GD_HA:
 834     case R_TILEPRO_IMM16_X0_TLS_IE_LO:
 835     case R_TILEPRO_IMM16_X0_TLS_IE_HI:
 836     case R_TILEPRO_IMM16_X0_TLS_IE_HA:
 837       MUNGE_NOCHECK (Imm16_X0);
 838       break;
 839     case R_TILEPRO_IMM16_X0:
 840     case R_TILEPRO_IMM16_X0_PCREL:
 841     case R_TILEPRO_IMM16_X0_TLS_GD:
 842     case R_TILEPRO_IMM16_X0_TLS_IE:
 843       MUNGE_SIGNED (Imm16_X0, 16);
 844       break;
 845     case R_TILEPRO_IMM16_X1_LO:
 846     case R_TILEPRO_IMM16_X1_HI:
 847     case R_TILEPRO_IMM16_X1_HA:
 848     case R_TILEPRO_IMM16_X1_LO_PCREL:
 849     case R_TILEPRO_IMM16_X1_HI_PCREL:
 850     case R_TILEPRO_IMM16_X1_HA_PCREL:
 851     case R_TILEPRO_IMM16_X1_TLS_GD_LO:
 852     case R_TILEPRO_IMM16_X1_TLS_GD_HI:
 853     case R_TILEPRO_IMM16_X1_TLS_GD_HA:
 854     case R_TILEPRO_IMM16_X1_TLS_IE_LO:
 855     case R_TILEPRO_IMM16_X1_TLS_IE_HI:
 856     case R_TILEPRO_IMM16_X1_TLS_IE_HA:
 857       MUNGE_NOCHECK (Imm16_X1);
 858       break;
 859     case R_TILEPRO_IMM16_X1:
 860     case R_TILEPRO_IMM16_X1_PCREL:
 861     case R_TILEPRO_IMM16_X1_TLS_GD:
 862     case R_TILEPRO_IMM16_X1_TLS_IE:
 863       MUNGE_SIGNED (Imm16_X1, 16);
 864       break;
 865     case R_TILEPRO_MMSTART_X0:
 866       MUNGE (MMStart_X0);
 867       break;
 868     case R_TILEPRO_MMEND_X0:
 869       MUNGE (MMEnd_X0);
 870       break;
 871     case R_TILEPRO_MMSTART_X1:
 872       MUNGE (MMStart_X1);
 873       break;
 874     case R_TILEPRO_MMEND_X1:
 875       MUNGE (MMEnd_X1);
 876       break;
 877     case R_TILEPRO_SHAMT_X0:
 878       MUNGE (ShAmt_X0);
 879       break;
 880     case R_TILEPRO_SHAMT_X1:
 881       MUNGE (ShAmt_X1);
 882       break;
 883     case R_TILEPRO_SHAMT_Y0:
 884       MUNGE (ShAmt_Y0);
 885       break;
 886     case R_TILEPRO_SHAMT_Y1:
 887       MUNGE (ShAmt_Y1);
 888       break;
 889 #endif
 890     }
 891 #undef MUNGE
 892   *p = bits;
 893   _dl_flush_icache (p, sizeof (*p));
 894 }
 895
 896 auto inline void __attribute__ ((always_inline))
 897 elf_machine_rela_relative (ElfW(Addr) l_addr, const ElfW(Rela) *reloc,
 898                            void *const reloc_addr_arg)
 899 {
 900   ElfW(Addr) *const reloc_addr = reloc_addr_arg;
 901   *reloc_addr = l_addr + reloc->r_addend;
 902 }
 903
 904 auto inline void __attribute__ ((always_inline))
 905 elf_machine_lazy_rel (struct link_map *map,
 906                       ElfW(Addr) l_addr, const ElfW(Rela) *reloc,
 907                       int skip_ifunc)
 908 {
 909   const unsigned int r_type = ELF32_R_TYPE (reloc->r_info);
 910
 911   /* Check for unexpected PLT reloc type.  */
 912   if (__builtin_expect (r_type == R_TILE(JMP_SLOT), 1))
 913     {
 914       *(ElfW(Addr) *) (l_addr + reloc->r_offset) += l_addr;
 915     }
 916   else
 917     _dl_reloc_bad_type (map, r_type, 1);
 918 }
 919
 920 #endif /* RESOLVE_MAP */