arch/x86/kernel/krtld/64/doreloc.c

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21
  22 /*
  23  * Copyright (c) 2004, 2010, Oracle and/or its affiliates. All rights reserved.
  24  */
  25
  26 #if     defined(_KERNEL)
  27 #include        <sys/types.h>
  28 #include        <krtld/reloc.h>
  29 #else
  30 #define ELF_TARGET_AMD64
  31 #if defined(DO_RELOC_LIBLD)
  32 #undef DO_RELOC_LIBLD
  33 #define DO_RELOC_LIBLD_X86
  34 #endif
  35 #include        <stdio.h>
  36 #include        "sgs.h"
  37 #include        "machdep.h"
  38 #include        "libld.h"
  39 #include        <krtld/reloc.h>
  40 #include        "conv.h"
  41 #include        "msg.h"
  42 #endif
  43
  44 /*
  45  * We need to build this code differently when it is used for
  46  * cross linking:
  47  *      - Data alignment requirements can differ from those
  48  *              of the running system, so we can't access data
  49  *              in units larger than a byte
  50  *      - We have to include code to do byte swapping when the
  51  *              target and linker host use different byte ordering,
  52  *              but such code is a waste when running natively.
  53  */
  54 #if !defined(DO_RELOC_LIBLD) || defined(__i386) || defined(__amd64)
  55 #define DORELOC_NATIVE
  56 #endif
  57
  58 /*
  59  * This table represents the current relocations that do_reloc() is able to
  60  * process.  The relocations below that are marked SPECIAL are relocations that
  61  * take special processing and shouldn't actually ever be passed to do_reloc().
  62  */
  63 const Rel_entry reloc_table[R_AMD64_NUM] = {
  64 /* R_AMD64_NONE */      {0, FLG_RE_NOTREL, 0, 0, 0},
  65 /* R_AMD64_64 */        {0, FLG_RE_NOTREL, 8, 0, 0},
  66 /* R_AMD64_PC32 */      {0, FLG_RE_PCREL, 4, 0, 0},
  67 /* R_AMD64_GOT32 */     {0, FLG_RE_NOTSUP, 0, 0, 0},
  68 /* R_AMD64_PLT32 */     {0, FLG_RE_PCREL | FLG_RE_PLTREL |
  69                             FLG_RE_VERIFY | FLG_RE_SIGN, 4, 0, 0},
  70 /* R_AMD64_COPY */      {0, FLG_RE_NOTSUP, 0, 0, 0},    /* SPECIAL */
  71 /* R_AMD64_GLOB_DAT */  {0, FLG_RE_NOTREL, 8, 0, 0},
  72 /* R_AMD64_JUMP_SLOT */ {0, FLG_RE_NOTSUP, 0, 0, 0},    /* SPECIAL */
  73 /* R_AMD64_RELATIVE */  {0, FLG_RE_NOTREL, 8, 0, 0},
  74 /* R_AMD64_GOTPCREL */  {0, FLG_RE_GOTPC | FLG_RE_GOTADD, 4, 0, 0},
  75 /* R_AMD64_32 */        {0, FLG_RE_NOTREL, 4, 0, 0},
  76 /* R_AMD64_32S */       {0, FLG_RE_NOTREL, 4, 0, 0},
  77 /* R_AMD64_16 */        {0, FLG_RE_NOTREL, 2, 0, 0},
  78 /* R_AMD64_PC16 */      {0, FLG_RE_PCREL, 2, 0, 0},
  79 /* R_AMD64_8 */         {0, FLG_RE_NOTREL, 1, 0, 0},
  80 /* R_AMD64_PC8 */       {0, FLG_RE_PCREL, 1, 0, 0},
  81 /* R_AMD64_DTPMOD64 */  {0, FLG_RE_NOTREL, 8, 0, 0},
  82 /* R_AMD64_DTPOFF64 */  {0, FLG_RE_NOTREL, 8, 0, 0},
  83 /* R_AMD64_TPOFF64 */   {0, FLG_RE_NOTREL, 8, 0, 0},
  84 /* R_AMD64_TLSGD */     {0, FLG_RE_GOTPC | FLG_RE_GOTADD | FLG_RE_TLSGD,
  85                             4, 0, 0},
  86 /* R_AMD64_TLSLD */     {0, FLG_RE_GOTPC | FLG_RE_GOTADD | FLG_RE_TLSLD,
  87                             4, 0, 0},
  88 /* R_AMD64_DTPOFF32 */  {0, FLG_RE_TLSLD, 4},
  89 /* R_AMD64_GOTTPOFF */  {0, FLG_RE_GOTPC | FLG_RE_GOTADD | FLG_RE_TLSIE,
  90                             4, 0, 0},
  91 /* R_AMD64_TPOFF32 */   {0, FLG_RE_TLSLE, 4, 0, 0},
  92 /* R_AMD64_PC64 */      {0, FLG_RE_PCREL, 8, 0, 0},
  93 /* R_AMD64_GOTOFF64 */  {0, FLG_RE_GOTREL, 8, 0, 0},
  94 /* R_AMD64_GOTPC32 */   {0, FLG_RE_PCREL | FLG_RE_GOTPC | FLG_RE_LOCLBND,
  95                             4, 0, 0},
  96 /* R_AMD64_GOT64 */     {0, FLG_RE_NOTSUP, 0, 0, 0},
  97 /* R_AMD64_GOTPCREL64 */        {FLG_RE_NOTSUP, 0, 0, 0},
  98 /* R_AMD64_GOTPC6 */    {0, FLG_RE_NOTSUP, 0, 0, 0},
  99 /* R_AMD64_GOTPLT64 */  {0, FLG_RE_NOTSUP, 0, 0, 0},
 100 /* R_AMD64_PLTOFF64 */  {0, FLG_RE_NOTSUP, 0, 0, 0},
 101 /* R_AMD64_SIZE32 */    {0, FLG_RE_SIZE, 4, 0, 0},
 102 /* R_AMD64_SIZE64 */    {0, FLG_RE_SIZE, 8, 0, 0}
 103 };
 104 #if     (R_AMD64_NUM != (R_AMD64_SIZE64 + 1))
 105 #error  "R_AMD64_NUM has grown"
 106 #endif
 107
 108 /*
 109  * Write a single relocated value to its reference location.
 110  * We assume we wish to add the relocation amount, value, to the
 111  * value of the address already present at the offset.
 112  *
 113  * NAME                 VALUE   FIELD           CALCULATION
 114  *
 115  * R_AMD64_NONE          0      none            none
 116  * R_AMD64_64            1      word64          S + A
 117  * R_AMD64_PC32          2      word64          S + A
 118  * R_AMD64_GOT32         3      word32          G + A
 119  * R_AMD64_PLT32         4      word32          L + A - P
 120  * R_AMD64_COPY          5      none            none
 121  * R_AMD64_GLOB_DAT      6      word64          S
 122  * R_AMD64_JUMP_SLOT     7      word64          S
 123  * R_AMD64_RELATIVE      8      word64          B + A
 124  * R_AMD64_GOTPCREL      9      word32          G + GOT + A - P
 125  * R_AMD64_32           10      word32          S + A
 126  * R_AMD64_32S          11      word32          S + A
 127  * R_AMD64_16           12      word16          S + A
 128  * R_AMD64_PC16         13      word16          S + A - P
 129  * R_AMD64_8            14      word8           S + A
 130  * R_AMD64_PC8          15      word8           S + A - P
 131  * R_AMD64_DTPMOD64     16      word64
 132  * R_AMD64_DTPOFF64     17      word64
 133  * R_AMD64_TPOFF64      18      word64
 134  * R_AMD64_TLSGD        19      word32
 135  * R_AMD64_TLSLD        20      word32
 136  * R_AMD64_DTPOFF32     21      word32
 137  * R_AMD64_GOTTPOFF     22      word32
 138  * R_AMD64_TPOFF32      23      word32
 139  * R_AMD64_PC64         24      word32          S + A - P
 140  * R_AMD64_GOTOFF64     25      word32          S + A - GOT
 141  * R_AMD64_GOTPC32      26      word32          GOT + A - P
 142  * R_AMD64_GOT64        27                      reserved for future expansion
 143  * R_AMD64_GOTPCREL64   28                      reserved for future expansion
 144  * R_AMD64_GOTPC64      29                      reserved for future expansion
 145  * R_AMD64_GOTPLT64     30                      reserved for future expansion
 146  * R_AMD64_PLTOFF64     31                      reserved for future expansion
 147  * R_AMD64_SIZE32       32      word32          Z + A
 148  * R_AMD64_SIZE64       33      word64          Z + A
 149  *
 150  * Relocation calculations:
 151  *      A       Represents the addend used to compute the value of the
 152  *              relocatable field.
 153  *
 154  *      B       Represents the base address at which a shared objects has
 155  *              been loaded into memory during executaion.  Generally, a
 156  *              shared objects is built with a 0 base virtual address,
 157  *              but the execution address will be different.
 158  *
 159  *      G       Represents the offset into the global offset table
 160  *              at which the relocation entry's symbol will reside
 161  *              during execution.
 162  *
 163  *      GOT     Rrepresents the address of the global offset table.
 164  *
 165  *      L       Represents the place (section offset or address) of
 166  *              the Procedure Linkage Table entry for a symbol.
 167  *
 168  *      P       Represents the place (section offset or address) of the
 169  *              storage unit being relocated (computed using r_offset).
 170  *
 171  *      S       Represents the value of the symbol whose index resides
 172  *              in the relocation entry.
 173  *
 174  *      Z       the size of the symbol whose index resides in the relocation
 175  *              entry
 176  */
 177
 178
 179 /*
 180  * Bits that must be cleared or identical for a value to act as if extended in
 181  * the given way.
 182  */
 183 #define ZEROEXBITS      0xffffffff00000000ULL
 184 #define SIGNEXBITS      0xffffffff80000000ULL
 185
 186 #if defined(_KERNEL)
 187 #define lml     0               /* Needed by arglist of REL_ERR_* macros */
 188 int
 189 do_reloc_krtld(uchar_t rtype, uchar_t *off, Xword *value, const char *sym,
 190     const char *file)
 191 #elif defined(DO_RELOC_LIBLD)
 192 /*ARGSUSED5*/
 193 int
 194 do_reloc_ld(Rel_desc *rdesc, uchar_t *off, Xword *value,
 195     rel_desc_sname_func_t rel_desc_sname_func,
 196     const char *file, int bswap, void *lml)
 197 #else
 198 int
 199 do_reloc_rtld(uchar_t rtype, uchar_t *off, Xword *value, const char *sym,
 200     const char *file, void *lml)
 201 #endif
 202 {
 203 #ifdef DO_RELOC_LIBLD
 204 #define sym (* rel_desc_sname_func)(rdesc)
 205         uchar_t rtype = rdesc->rel_rtype;
 206 #endif
 207         const Rel_entry *rep;
 208
 209         rep = &reloc_table[rtype];
 210
 211         switch (rep->re_fsize) {
 212         case 1:
 213                 /* LINTED */
 214                 *((uchar_t *)off) = (uchar_t)(*value);
 215                 break;
 216
 217         case 2:
 218 #if defined(DORELOC_NATIVE)
 219                 /* LINTED */
 220                 *((Half *)off) = (Half)(*value);
 221 #else
 222                 {
 223                         Half    v = (Half)(*value);
 224                         uchar_t *v_bytes = (uchar_t *)&v;
 225
 226                         if (bswap) {
 227                                 UL_ASSIGN_BSWAP_HALF(off, v_bytes);
 228                         } else {
 229                                 UL_ASSIGN_HALF(off, v_bytes);
 230                         }
 231                 }
 232 #endif
 233                 break;
 234
 235         case 4:
 236                 /*
 237                  * The amd64 psABI requires that we perform the following
 238                  * verifications:
 239                  *
 240                  *    The R_AMD64_32 and R_AMD64_32S relocations truncate the
 241                  *    computed value to 32bits.  Verify that the generated value
 242                  *    for the R_AMD64_32/32S relocation zero-extends (sign
 243                  *    extends) to the original 64-bit value.
 244                  *
 245                  * Also, the following relocations are all 32 bit PC relative
 246                  * references.  Validate that the value being written will fit
 247                  * in the field provided.
 248                  *
 249                  *    R_AMD64_PC32, R_AMD64_GOTPC32, R_AMD64_GOTPCREL
 250                  */
 251                 if (rtype == R_AMD64_32) {
 252                         /*
 253                          * Verify that this value will act as a zero-extended
 254                          * unsigned 32 bit value.  That is, that the upper
 255                          * 32 bits are zero.
 256                          */
 257                         if ((*value & ZEROEXBITS) != 0) {
 258                                 /*
 259                                  * To keep chkmsg() happy:
 260                                  *  MSG_INTL(MSG_REL_NOFIT)
 261                                  */
 262                                 REL_ERR_NOFIT(lml, file, sym, rtype, *value);
 263                                 return (0);
 264                         }
 265                 } else if ((rtype == R_AMD64_32S) || (rtype == R_AMD64_PC32) ||
 266                     (rtype == R_AMD64_GOTPCREL) || (rtype == R_AMD64_GOTPC32)) {
 267                         /*
 268                          * Verify that this value will act as a sign-extended
 269                          * signed 32 bit value, that is that the upper 33 bits
 270                          * are either all zero or all one.
 271                          */
 272                         if (((*value & SIGNEXBITS) != SIGNEXBITS) &&
 273                             ((*value & SIGNEXBITS) != 0)) {
 274                                 /*
 275                                  * To keep chkmsg() happy:
 276                                  *  MSG_INTL(MSG_REL_NOFIT)
 277                                  */
 278                                 REL_ERR_NOFIT(lml, file, sym, rtype, *value);
 279                                 return (0);
 280                         }
 281                 }
 282
 283 #if defined(DORELOC_NATIVE)
 284                 /* LINTED */
 285                 *((Word *)off) += *value;
 286 #else
 287                 {
 288                         Word    v;
 289                         uchar_t *v_bytes = (uchar_t *)&v;
 290
 291                         if (bswap) {
 292                                 UL_ASSIGN_BSWAP_WORD(v_bytes, off);
 293                                 v += *value;
 294                                 UL_ASSIGN_BSWAP_WORD(off, v_bytes);
 295                         } else {
 296                                 UL_ASSIGN_WORD(v_bytes, off);
 297                                 v += *value;
 298                                 UL_ASSIGN_WORD(off, v_bytes);
 299                         }
 300                 }
 301 #endif
 302                 break;
 303
 304         case 8:
 305 #if defined(DORELOC_NATIVE)
 306                 /* LINTED */
 307                 *((Xword *)off) += *value;
 308 #else
 309                 {
 310                         Xword   v;
 311                         uchar_t *v_bytes = (uchar_t *)&v;
 312
 313                         if (bswap) {
 314                                 UL_ASSIGN_BSWAP_XWORD(v_bytes, off);
 315                                 v += *value;
 316                                 UL_ASSIGN_BSWAP_XWORD(off, v_bytes);
 317                         } else {
 318                                 UL_ASSIGN_XWORD(v_bytes, off);
 319                                 v += *value;
 320                                 UL_ASSIGN_XWORD(off, v_bytes);
 321                         }
 322                 }
 323 #endif
 324                 break;
 325         default:
 326                 /*
 327                  * To keep chkmsg() happy: MSG_INTL(MSG_REL_UNSUPSZ)
 328                  */
 329                 REL_ERR_UNSUPSZ(lml, file, sym, rtype, rep->re_fsize);
 330                 return (0);
 331         }
 332         return (1);
 333
 334 #ifdef DO_RELOC_LIBLD
 335 #undef sym
 336 #endif
 337 }