glibc-sparc64-dl-machine.patch

   1 --- glibc-2.3.6/sysdeps/sparc/sparc64/dl-machine.h.orig 2005-12-27 01:19:34.023832576 +0100
   2 +++ glibc-2.3.6/sysdeps/sparc/sparc64/dl-machine.h      2005-12-27 01:19:26.440985344 +0100
   3 @@ -18,6 +18,9 @@
   4     Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
   5     02111-1307 USA.  */
   6
   7 +#ifndef dl_machine_h
   8 +#define dl_machine_h
   9 +
  10  #define ELF_MACHINE_NAME "sparc64"
  11
  12  #include <string.h>
  13 @@ -233,232 +236,6 @@
  14    return value;
  15  }
  16
  17 -#ifdef RESOLVE
  18 -
  19 -/* Perform the relocation specified by RELOC and SYM (which is fully resolved).
  20 -   MAP is the object containing the reloc.  */
  21 -
  22 -auto inline void
  23 -__attribute__ ((always_inline))
  24 -elf_machine_rela (struct link_map *map, const Elf64_Rela *reloc,
  25 -                 const Elf64_Sym *sym, const struct r_found_version *version,
  26 -                 void *const reloc_addr_arg)
  27 -{
  28 -  Elf64_Addr *const reloc_addr = reloc_addr_arg;
  29 -  const unsigned long int r_type = ELF64_R_TYPE_ID (reloc->r_info);
  30 -
  31 -#if !defined RTLD_BOOTSTRAP || !defined HAVE_Z_COMBRELOC
  32 -  if (__builtin_expect (r_type == R_SPARC_RELATIVE, 0))
  33 -    *reloc_addr = map->l_addr + reloc->r_addend;
  34 -# ifndef RTLD_BOOTSTRAP
  35 -  else if (r_type == R_SPARC_NONE) /* Who is Wilbur? */
  36 -    return;
  37 -# endif
  38 -  else
  39 -#endif
  40 -    {
  41 -#if !defined RTLD_BOOTSTRAP && !defined RESOLVE_CONFLICT_FIND_MAP
  42 -      const Elf64_Sym *const refsym = sym;
  43 -#endif
  44 -      Elf64_Addr value;
  45 -#ifndef RESOLVE_CONFLICT_FIND_MAP
  46 -      if (sym->st_shndx != SHN_UNDEF &&
  47 -         ELF64_ST_BIND (sym->st_info) == STB_LOCAL)
  48 -       value = map->l_addr;
  49 -      else
  50 -       {
  51 -         value = RESOLVE (&sym, version, r_type);
  52 -         if (sym)
  53 -           value += sym->st_value;
  54 -       }
  55 -#else
  56 -      value = 0;
  57 -#endif
  58 -      value += reloc->r_addend;        /* Assume copy relocs have zero addend.  */
  59 -
  60 -      switch (r_type)
  61 -       {
  62 -#if !defined RTLD_BOOTSTRAP && !defined RESOLVE_CONFLICT_FIND_MAP
  63 -       case R_SPARC_COPY:
  64 -         if (sym == NULL)
  65 -           /* This can happen in trace mode if an object could not be
  66 -              found.  */
  67 -           break;
  68 -         if (sym->st_size > refsym->st_size
  69 -             || (GLRO(dl_verbose) && sym->st_size < refsym->st_size))
  70 -           {
  71 -             const char *strtab;
  72 -
  73 -             strtab = (const void *) D_PTR (map, l_info[DT_STRTAB]);
  74 -             _dl_error_printf ("\
  75 -%s: Symbol `%s' has different size in shared object, consider re-linking\n",
  76 -                               rtld_progname ?: "<program name unknown>",
  77 -                               strtab + refsym->st_name);
  78 -           }
  79 -         memcpy (reloc_addr_arg, (void *) value,
  80 -                 MIN (sym->st_size, refsym->st_size));
  81 -         break;
  82 -#endif
  83 -       case R_SPARC_64:
  84 -       case R_SPARC_GLOB_DAT:
  85 -         *reloc_addr = value;
  86 -         break;
  87 -#ifndef RTLD_BOOTSTRAP
  88 -       case R_SPARC_8:
  89 -         *(char *) reloc_addr = value;
  90 -         break;
  91 -       case R_SPARC_16:
  92 -         *(short *) reloc_addr = value;
  93 -         break;
  94 -       case R_SPARC_32:
  95 -         *(unsigned int *) reloc_addr = value;
  96 -         break;
  97 -       case R_SPARC_DISP8:
  98 -         *(char *) reloc_addr = (value - (Elf64_Addr) reloc_addr);
  99 -         break;
 100 -       case R_SPARC_DISP16:
 101 -         *(short *) reloc_addr = (value - (Elf64_Addr) reloc_addr);
 102 -         break;
 103 -       case R_SPARC_DISP32:
 104 -         *(unsigned int *) reloc_addr = (value - (Elf64_Addr) reloc_addr);
 105 -         break;
 106 -       case R_SPARC_WDISP30:
 107 -         *(unsigned int *) reloc_addr =
 108 -           ((*(unsigned int *)reloc_addr & 0xc0000000) |
 109 -            ((value - (Elf64_Addr) reloc_addr) >> 2));
 110 -         break;
 111 -
 112 -       /* MEDLOW code model relocs */
 113 -       case R_SPARC_LO10:
 114 -         *(unsigned int *) reloc_addr =
 115 -           ((*(unsigned int *)reloc_addr & ~0x3ff) |
 116 -            (value & 0x3ff));
 117 -         break;
 118 -       case R_SPARC_HI22:
 119 -         *(unsigned int *) reloc_addr =
 120 -           ((*(unsigned int *)reloc_addr & 0xffc00000) |
 121 -            (value >> 10));
 122 -         break;
 123 -       case R_SPARC_OLO10:
 124 -         *(unsigned int *) reloc_addr =
 125 -           ((*(unsigned int *)reloc_addr & ~0x1fff) |
 126 -            (((value & 0x3ff) + ELF64_R_TYPE_DATA (reloc->r_info)) & 0x1fff));
 127 -         break;
 128 -
 129 -       /* MEDMID code model relocs */
 130 -       case R_SPARC_H44:
 131 -         *(unsigned int *) reloc_addr =
 132 -           ((*(unsigned int *)reloc_addr & 0xffc00000) |
 133 -            (value >> 22));
 134 -         break;
 135 -       case R_SPARC_M44:
 136 -         *(unsigned int *) reloc_addr =
 137 -           ((*(unsigned int *)reloc_addr & ~0x3ff) |
 138 -            ((value >> 12) & 0x3ff));
 139 -         break;
 140 -       case R_SPARC_L44:
 141 -         *(unsigned int *) reloc_addr =
 142 -           ((*(unsigned int *)reloc_addr & ~0xfff) |
 143 -            (value & 0xfff));
 144 -         break;
 145 -
 146 -       /* MEDANY code model relocs */
 147 -       case R_SPARC_HH22:
 148 -         *(unsigned int *) reloc_addr =
 149 -           ((*(unsigned int *)reloc_addr & 0xffc00000) |
 150 -            (value >> 42));
 151 -         break;
 152 -       case R_SPARC_HM10:
 153 -         *(unsigned int *) reloc_addr =
 154 -           ((*(unsigned int *)reloc_addr & ~0x3ff) |
 155 -            ((value >> 32) & 0x3ff));
 156 -         break;
 157 -       case R_SPARC_LM22:
 158 -         *(unsigned int *) reloc_addr =
 159 -           ((*(unsigned int *)reloc_addr & 0xffc00000) |
 160 -            ((value >> 10) & 0x003fffff));
 161 -         break;
 162 -#endif
 163 -       case R_SPARC_JMP_SLOT:
 164 -#ifdef RESOLVE_CONFLICT_FIND_MAP
 165 -         /* R_SPARC_JMP_SLOT conflicts against .plt[32768+]
 166 -            relocs should be turned into R_SPARC_64 relocs
 167 -            in .gnu.conflict section.
 168 -            r_addend non-zero does not mean it is a .plt[32768+]
 169 -            reloc, instead it is the actual address of the function
 170 -            to call.  */
 171 -         sparc64_fixup_plt (NULL, reloc, reloc_addr, value, 0, 0);
 172 -#else
 173 -         sparc64_fixup_plt (map, reloc, reloc_addr, value,
 174 -                            reloc->r_addend, 0);
 175 -#endif
 176 -         break;
 177 -#ifndef RTLD_BOOTSTRAP
 178 -       case R_SPARC_UA16:
 179 -         ((unsigned char *) reloc_addr_arg) [0] = value >> 8;
 180 -         ((unsigned char *) reloc_addr_arg) [1] = value;
 181 -         break;
 182 -       case R_SPARC_UA32:
 183 -         ((unsigned char *) reloc_addr_arg) [0] = value >> 24;
 184 -         ((unsigned char *) reloc_addr_arg) [1] = value >> 16;
 185 -         ((unsigned char *) reloc_addr_arg) [2] = value >> 8;
 186 -         ((unsigned char *) reloc_addr_arg) [3] = value;
 187 -         break;
 188 -       case R_SPARC_UA64:
 189 -         if (! ((long) reloc_addr_arg & 3))
 190 -           {
 191 -             /* Common in .eh_frame */
 192 -             ((unsigned int *) reloc_addr_arg) [0] = value >> 32;
 193 -             ((unsigned int *) reloc_addr_arg) [1] = value;
 194 -             break;
 195 -           }
 196 -         ((unsigned char *) reloc_addr_arg) [0] = value >> 56;
 197 -         ((unsigned char *) reloc_addr_arg) [1] = value >> 48;
 198 -         ((unsigned char *) reloc_addr_arg) [2] = value >> 40;
 199 -         ((unsigned char *) reloc_addr_arg) [3] = value >> 32;
 200 -         ((unsigned char *) reloc_addr_arg) [4] = value >> 24;
 201 -         ((unsigned char *) reloc_addr_arg) [5] = value >> 16;
 202 -         ((unsigned char *) reloc_addr_arg) [6] = value >> 8;
 203 -         ((unsigned char *) reloc_addr_arg) [7] = value;
 204 -         break;
 205 -#endif
 206 -#if !defined RTLD_BOOTSTRAP || defined _NDEBUG
 207 -       default:
 208 -         _dl_reloc_bad_type (map, r_type, 0);
 209 -         break;
 210 -#endif
 211 -       }
 212 -    }
 213 -}
 214 -
 215 -auto inline void
 216 -__attribute__ ((always_inline))
 217 -elf_machine_rela_relative (Elf64_Addr l_addr, const Elf64_Rela *reloc,
 218 -                          void *const reloc_addr_arg)
 219 -{
 220 -  Elf64_Addr *const reloc_addr = reloc_addr_arg;
 221 -  *reloc_addr = l_addr + reloc->r_addend;
 222 -}
 223 -
 224 -auto inline void
 225 -__attribute__ ((always_inline))
 226 -elf_machine_lazy_rel (struct link_map *map,
 227 -                     Elf64_Addr l_addr, const Elf64_Rela *reloc)
 228 -{
 229 -  switch (ELF64_R_TYPE (reloc->r_info))
 230 -    {
 231 -    case R_SPARC_NONE:
 232 -      break;
 233 -    case R_SPARC_JMP_SLOT:
 234 -      break;
 235 -    default:
 236 -      _dl_reloc_bad_type (map, ELFW(R_TYPE) (reloc->r_info), 1);
 237 -      break;
 238 -    }
 239 -}
 240 -
 241 -#endif /* RESOLVE */
 242 -
 243  /* ELF_RTYPE_CLASS_PLT iff TYPE describes relocation of a PLT entry, so
 244     PLT entries should not be allowed to define the value.
 245     ELF_RTYPE_CLASS_NOCOPY iff TYPE should not be allowed to resolve to one
 246 @@ -766,3 +543,231 @@
 247  "       add    %sp, 6*8, %sp\n"                                        \
 248  "      .size   _dl_start_user, . - _dl_start_user\n"                   \
 249  "      .previous\n");
 250 +
 251 +#endif /* dl_machine_h */
 252 +
 253 +#ifdef RESOLVE
 254 +
 255 +/* Perform the relocation specified by RELOC and SYM (which is fully resolved).
 256 +   MAP is the object containing the reloc.  */
 257 +
 258 +auto inline void
 259 +__attribute__ ((always_inline))
 260 +elf_machine_rela (struct link_map *map, const Elf64_Rela *reloc,
 261 +                 const Elf64_Sym *sym, const struct r_found_version *version,
 262 +                 void *const reloc_addr_arg)
 263 +{
 264 +  Elf64_Addr *const reloc_addr = reloc_addr_arg;
 265 +  const unsigned long int r_type = ELF64_R_TYPE_ID (reloc->r_info);
 266 +
 267 +#if !defined RTLD_BOOTSTRAP || !defined HAVE_Z_COMBRELOC
 268 +  if (__builtin_expect (r_type == R_SPARC_RELATIVE, 0))
 269 +    *reloc_addr = map->l_addr + reloc->r_addend;
 270 +# ifndef RTLD_BOOTSTRAP
 271 +  else if (r_type == R_SPARC_NONE) /* Who is Wilbur? */
 272 +    return;
 273 +# endif
 274 +  else
 275 +#endif
 276 +    {
 277 +#if !defined RTLD_BOOTSTRAP && !defined RESOLVE_CONFLICT_FIND_MAP
 278 +      const Elf64_Sym *const refsym = sym;
 279 +#endif
 280 +      Elf64_Addr value;
 281 +#ifndef RESOLVE_CONFLICT_FIND_MAP
 282 +      if (sym->st_shndx != SHN_UNDEF &&
 283 +         ELF64_ST_BIND (sym->st_info) == STB_LOCAL)
 284 +       value = map->l_addr;
 285 +      else
 286 +       {
 287 +         value = RESOLVE (&sym, version, r_type);
 288 +         if (sym)
 289 +           value += sym->st_value;
 290 +       }
 291 +#else
 292 +      value = 0;
 293 +#endif
 294 +      value += reloc->r_addend;        /* Assume copy relocs have zero addend.  */
 295 +
 296 +      switch (r_type)
 297 +       {
 298 +#if !defined RTLD_BOOTSTRAP && !defined RESOLVE_CONFLICT_FIND_MAP
 299 +       case R_SPARC_COPY:
 300 +         if (sym == NULL)
 301 +           /* This can happen in trace mode if an object could not be
 302 +              found.  */
 303 +           break;
 304 +         if (sym->st_size > refsym->st_size
 305 +             || (GLRO(dl_verbose) && sym->st_size < refsym->st_size))
 306 +           {
 307 +             const char *strtab;
 308 +
 309 +             strtab = (const void *) D_PTR (map, l_info[DT_STRTAB]);
 310 +             _dl_error_printf ("\
 311 +%s: Symbol `%s' has different size in shared object, consider re-linking\n",
 312 +                               rtld_progname ?: "<program name unknown>",
 313 +                               strtab + refsym->st_name);
 314 +           }
 315 +         memcpy (reloc_addr_arg, (void *) value,
 316 +                 MIN (sym->st_size, refsym->st_size));
 317 +         break;
 318 +#endif
 319 +       case R_SPARC_64:
 320 +       case R_SPARC_GLOB_DAT:
 321 +         *reloc_addr = value;
 322 +         break;
 323 +#ifndef RTLD_BOOTSTRAP
 324 +       case R_SPARC_8:
 325 +         *(char *) reloc_addr = value;
 326 +         break;
 327 +       case R_SPARC_16:
 328 +         *(short *) reloc_addr = value;
 329 +         break;
 330 +       case R_SPARC_32:
 331 +         *(unsigned int *) reloc_addr = value;
 332 +         break;
 333 +       case R_SPARC_DISP8:
 334 +         *(char *) reloc_addr = (value - (Elf64_Addr) reloc_addr);
 335 +         break;
 336 +       case R_SPARC_DISP16:
 337 +         *(short *) reloc_addr = (value - (Elf64_Addr) reloc_addr);
 338 +         break;
 339 +       case R_SPARC_DISP32:
 340 +         *(unsigned int *) reloc_addr = (value - (Elf64_Addr) reloc_addr);
 341 +         break;
 342 +       case R_SPARC_WDISP30:
 343 +         *(unsigned int *) reloc_addr =
 344 +           ((*(unsigned int *)reloc_addr & 0xc0000000) |
 345 +            ((value - (Elf64_Addr) reloc_addr) >> 2));
 346 +         break;
 347 +
 348 +       /* MEDLOW code model relocs */
 349 +       case R_SPARC_LO10:
 350 +         *(unsigned int *) reloc_addr =
 351 +           ((*(unsigned int *)reloc_addr & ~0x3ff) |
 352 +            (value & 0x3ff));
 353 +         break;
 354 +       case R_SPARC_HI22:
 355 +         *(unsigned int *) reloc_addr =
 356 +           ((*(unsigned int *)reloc_addr & 0xffc00000) |
 357 +            (value >> 10));
 358 +         break;
 359 +       case R_SPARC_OLO10:
 360 +         *(unsigned int *) reloc_addr =
 361 +           ((*(unsigned int *)reloc_addr & ~0x1fff) |
 362 +            (((value & 0x3ff) + ELF64_R_TYPE_DATA (reloc->r_info)) & 0x1fff));
 363 +         break;
 364 +
 365 +       /* MEDMID code model relocs */
 366 +       case R_SPARC_H44:
 367 +         *(unsigned int *) reloc_addr =
 368 +           ((*(unsigned int *)reloc_addr & 0xffc00000) |
 369 +            (value >> 22));
 370 +         break;
 371 +       case R_SPARC_M44:
 372 +         *(unsigned int *) reloc_addr =
 373 +           ((*(unsigned int *)reloc_addr & ~0x3ff) |
 374 +            ((value >> 12) & 0x3ff));
 375 +         break;
 376 +       case R_SPARC_L44:
 377 +         *(unsigned int *) reloc_addr =
 378 +           ((*(unsigned int *)reloc_addr & ~0xfff) |
 379 +            (value & 0xfff));
 380 +         break;
 381 +
 382 +       /* MEDANY code model relocs */
 383 +       case R_SPARC_HH22:
 384 +         *(unsigned int *) reloc_addr =
 385 +           ((*(unsigned int *)reloc_addr & 0xffc00000) |
 386 +            (value >> 42));
 387 +         break;
 388 +       case R_SPARC_HM10:
 389 +         *(unsigned int *) reloc_addr =
 390 +           ((*(unsigned int *)reloc_addr & ~0x3ff) |
 391 +            ((value >> 32) & 0x3ff));
 392 +         break;
 393 +       case R_SPARC_LM22:
 394 +         *(unsigned int *) reloc_addr =
 395 +           ((*(unsigned int *)reloc_addr & 0xffc00000) |
 396 +            ((value >> 10) & 0x003fffff));
 397 +         break;
 398 +#endif
 399 +       case R_SPARC_JMP_SLOT:
 400 +#ifdef RESOLVE_CONFLICT_FIND_MAP
 401 +         /* R_SPARC_JMP_SLOT conflicts against .plt[32768+]
 402 +            relocs should be turned into R_SPARC_64 relocs
 403 +            in .gnu.conflict section.
 404 +            r_addend non-zero does not mean it is a .plt[32768+]
 405 +            reloc, instead it is the actual address of the function
 406 +            to call.  */
 407 +         sparc64_fixup_plt (NULL, reloc, reloc_addr, value, 0, 0);
 408 +#else
 409 +         sparc64_fixup_plt (map, reloc, reloc_addr, value,
 410 +                            reloc->r_addend, 0);
 411 +#endif
 412 +         break;
 413 +#ifndef RTLD_BOOTSTRAP
 414 +       case R_SPARC_UA16:
 415 +         ((unsigned char *) reloc_addr_arg) [0] = value >> 8;
 416 +         ((unsigned char *) reloc_addr_arg) [1] = value;
 417 +         break;
 418 +       case R_SPARC_UA32:
 419 +         ((unsigned char *) reloc_addr_arg) [0] = value >> 24;
 420 +         ((unsigned char *) reloc_addr_arg) [1] = value >> 16;
 421 +         ((unsigned char *) reloc_addr_arg) [2] = value >> 8;
 422 +         ((unsigned char *) reloc_addr_arg) [3] = value;
 423 +         break;
 424 +       case R_SPARC_UA64:
 425 +         if (! ((long) reloc_addr_arg & 3))
 426 +           {
 427 +             /* Common in .eh_frame */
 428 +             ((unsigned int *) reloc_addr_arg) [0] = value >> 32;
 429 +             ((unsigned int *) reloc_addr_arg) [1] = value;
 430 +             break;
 431 +           }
 432 +         ((unsigned char *) reloc_addr_arg) [0] = value >> 56;
 433 +         ((unsigned char *) reloc_addr_arg) [1] = value >> 48;
 434 +         ((unsigned char *) reloc_addr_arg) [2] = value >> 40;
 435 +         ((unsigned char *) reloc_addr_arg) [3] = value >> 32;
 436 +         ((unsigned char *) reloc_addr_arg) [4] = value >> 24;
 437 +         ((unsigned char *) reloc_addr_arg) [5] = value >> 16;
 438 +         ((unsigned char *) reloc_addr_arg) [6] = value >> 8;
 439 +         ((unsigned char *) reloc_addr_arg) [7] = value;
 440 +         break;
 441 +#endif
 442 +#if !defined RTLD_BOOTSTRAP || defined _NDEBUG
 443 +       default:
 444 +         _dl_reloc_bad_type (map, r_type, 0);
 445 +         break;
 446 +#endif
 447 +       }
 448 +    }
 449 +}
 450 +
 451 +auto inline void
 452 +__attribute__ ((always_inline))
 453 +elf_machine_rela_relative (Elf64_Addr l_addr, const Elf64_Rela *reloc,
 454 +                          void *const reloc_addr_arg)
 455 +{
 456 +  Elf64_Addr *const reloc_addr = reloc_addr_arg;
 457 +  *reloc_addr = l_addr + reloc->r_addend;
 458 +}
 459 +
 460 +auto inline void
 461 +__attribute__ ((always_inline))
 462 +elf_machine_lazy_rel (struct link_map *map,
 463 +                     Elf64_Addr l_addr, const Elf64_Rela *reloc)
 464 +{
 465 +  switch (ELF64_R_TYPE (reloc->r_info))
 466 +    {
 467 +    case R_SPARC_NONE:
 468 +      break;
 469 +    case R_SPARC_JMP_SLOT:
 470 +      break;
 471 +    default:
 472 +      _dl_reloc_bad_type (map, ELFW(R_TYPE) (reloc->r_info), 1);
 473 +      break;
 474 +    }
 475 +}
 476 +
 477 +#endif /* RESOLVE */