usr/src/cmd/sgs/tools/common/leb128.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 2009 Sun Microsystems, Inc.  All rights reserved.
  24  * Use is subject to license terms.
  25  */
  26
  27 #include <stdio.h>
  28 #include <dwarf.h>
  29 #include <sys/types.h>
  30 #include <sys/elf.h>
  31
  32 /*
  33  * Little Endian Base 128 (LEB128) numbers.
  34  * ----------------------------------------
  35  *
  36  * LEB128 is a scheme for encoding integers densely that exploits the
  37  * assumption that most integers are small in magnitude. (This encoding
  38  * is equally suitable whether the target machine architecture represents
  39  * data in big-endian or little- endian
  40  *
  41  * Unsigned LEB128 numbers are encoded as follows: start at the low order
  42  * end of an unsigned integer and chop it into 7-bit chunks. Place each
  43  * chunk into the low order 7 bits of a byte. Typically, several of the
  44  * high order bytes will be zero; discard them. Emit the remaining bytes in
  45  * a stream, starting with the low order byte; set the high order bit on
  46  * each byte except the last emitted byte. The high bit of zero on the last
  47  * byte indicates to the decoder that it has encountered the last byte.
  48  * The integer zero is a special case, consisting of a single zero byte.
  49  *
  50  * Signed, 2s complement LEB128 numbers are encoded in a similar except
  51  * that the criterion for discarding high order bytes is not whether they
  52  * are zero, but whether they consist entirely of sign extension bits.
  53  * Consider the 32-bit integer -2. The three high level bytes of the number
  54  * are sign extension, thus LEB128 would represent it as a single byte
  55  * containing the low order 7 bits, with the high order bit cleared to
  56  * indicate the end of the byte stream.
  57  *
  58  * Note that there is nothing within the LEB128 representation that
  59  * indicates whether an encoded number is signed or unsigned. The decoder
  60  * must know what type of number to expect.
  61  *
  62  * DWARF Exception Header Encoding
  63  * -------------------------------
  64  *
  65  * The DWARF Exception Header Encoding is used to describe the type of data
  66  * used in the .eh_frame_hdr section. The upper 4 bits indicate how the
  67  * value is to be applied. The lower 4 bits indicate the format of the data.
  68  *
  69  * DWARF Exception Header value format
  70  *
  71  * Name         Value Meaning
  72  * DW_EH_PE_omit            0xff No value is present.
  73  * DW_EH_PE_absptr          0x00 Value is a void*
  74  * DW_EH_PE_uleb128         0x01 Unsigned value is encoded using the
  75  *                               Little Endian Base 128 (LEB128)
  76  * DW_EH_PE_udata2          0x02 A 2 bytes unsigned value.
  77  * DW_EH_PE_udata4          0x03 A 4 bytes unsigned value.
  78  * DW_EH_PE_udata8          0x04 An 8 bytes unsigned value.
  79  * DW_EH_PE_signed          0x08 bit on for all signed encodings
  80  * DW_EH_PE_sleb128         0x09 Signed value is encoded using the
  81  *                               Little Endian Base 128 (LEB128)
  82  * DW_EH_PE_sdata2          0x0A A 2 bytes signed value.
  83  * DW_EH_PE_sdata4          0x0B A 4 bytes signed value.
  84  * DW_EH_PE_sdata8          0x0C An 8 bytes signed value.
  85  *
  86  * DWARF Exception Header application
  87  *
  88  * Name     Value Meaning
  89  * DW_EH_PE_absptr         0x00 Value is used with no modification.
  90  * DW_EH_PE_pcrel          0x10 Value is reletive to the location of itself
  91  * DW_EH_PE_textrel        0x20
  92  * DW_EH_PE_datarel        0x30 Value is reletive to the beginning of the
  93  *                              eh_frame_hdr segment ( segment type
  94  *                              PT_GNU_EH_FRAME )
  95  * DW_EH_PE_funcrel        0x40
  96  * DW_EH_PE_aligned        0x50 value is an aligned void*
  97  * DW_EH_PE_indirect       0x80 bit to signal indirection after relocation
  98  * DW_EH_PE_omit           0xff No value is present.
  99  *
 100  */
 101
 102 dwarf_error_t
 103 uleb_extract(unsigned char *data, uint64_t *dotp, size_t len, uint64_t *ret)
 104 {
 105         uint64_t        dot = *dotp;
 106         uint64_t        res = 0;
 107         int             more = 1;
 108         int             shift = 0;
 109         int             val;
 110
 111         data += dot;
 112
 113         while (more) {
 114                 if (dot > len)
 115                         return (DW_OVERFLOW);
 116
 117                 /*
 118                  * Pull off lower 7 bits
 119                  */
 120                 val = (*data) & 0x7f;
 121
 122                 /*
 123                  * Add prepend value to head of number.
 124                  */
 125                 res = res | (val << shift);
 126
 127                 /*
 128                  * Increment shift & dot pointer
 129                  */
 130                 shift += 7;
 131                 dot++;
 132
 133                 /*
 134                  * Check to see if hi bit is set - if not, this
 135                  * is the last byte.
 136                  */
 137                 more = ((*data++) & 0x80) >> 7;
 138         }
 139         *dotp = dot;
 140         *ret = res;
 141         return (DW_SUCCESS);
 142 }
 143
 144 dwarf_error_t
 145 sleb_extract(unsigned char *data, uint64_t *dotp, size_t len, int64_t *ret)
 146 {
 147         uint64_t        dot = *dotp;
 148         int64_t         res = 0;
 149         int             more = 1;
 150         int             shift = 0;
 151         int             val;
 152
 153         data += dot;
 154
 155         while (more) {
 156                 if (dot > len)
 157                         return (DW_OVERFLOW);
 158
 159                 /*
 160                  * Pull off lower 7 bits
 161                  */
 162                 val = (*data) & 0x7f;
 163
 164                 /*
 165                  * Add prepend value to head of number.
 166                  */
 167                 res = res | (val << shift);
 168
 169                 /*
 170                  * Increment shift & dot pointer
 171                  */
 172                 shift += 7;
 173                 dot++;
 174
 175                 /*
 176                  * Check to see if hi bit is set - if not, this
 177                  * is the last byte.
 178                  */
 179                 more = ((*data++) & 0x80) >> 7;
 180         }
 181         *dotp = dot;
 182
 183         /*
 184          * Make sure value is properly sign extended.
 185          */
 186         res = (res << (64 - shift)) >> (64 - shift);
 187         *ret = res;
 188         return (DW_SUCCESS);
 189 }
 190
 191 /*
 192  * Extract a DWARF encoded datum
 193  *
 194  * entry:
 195  *      data - Base of data buffer containing encoded bytes
 196  *      dotp - Address of variable containing index within data
 197  *              at which the desired datum starts.
 198  *      ehe_flags - DWARF encoding
 199  *      eident - ELF header e_ident[] array for object being processed
 200  *      frame_hdr - Boolean, true if we're extracting from .eh_frame_hdr
 201  *      sh_base - Base address of ELF section containing desired datum
 202  *      sh_offset - Offset relative to sh_base of desired datum.
 203  *      dbase - The base address to which DW_EH_PE_datarel is relative
 204  *              (if frame_hdr is false)
 205  */
 206 dwarf_error_t
 207 dwarf_ehe_extract(unsigned char *data, size_t len, uint64_t *dotp,
 208     uint64_t *ret, uint_t ehe_flags, unsigned char *eident,
 209     boolean_t frame_hdr, uint64_t sh_base, uint64_t sh_offset,
 210     uint64_t dbase)
 211 {
 212         uint64_t    dot = *dotp;
 213         uint_t      lsb;
 214         uint_t      wordsize;
 215         uint_t      fsize;
 216         uint64_t    result;
 217
 218         if (eident[EI_DATA] == ELFDATA2LSB)
 219                 lsb = 1;
 220         else
 221                 lsb = 0;
 222
 223         if (eident[EI_CLASS] == ELFCLASS64)
 224                 wordsize = 8;
 225         else
 226                 wordsize = 4;
 227
 228         switch (ehe_flags & 0x0f) {
 229         case DW_EH_PE_omit:
 230                 *ret = 0;
 231                 return (DW_SUCCESS);
 232         case DW_EH_PE_absptr:
 233                 fsize = wordsize;
 234                 break;
 235         case DW_EH_PE_udata8:
 236         case DW_EH_PE_sdata8:
 237                 fsize = 8;
 238                 break;
 239         case DW_EH_PE_udata4:
 240         case DW_EH_PE_sdata4:
 241                 fsize = 4;
 242                 break;
 243         case DW_EH_PE_udata2:
 244         case DW_EH_PE_sdata2:
 245                 fsize = 2;
 246                 break;
 247         case DW_EH_PE_uleb128:
 248                 return (uleb_extract(data, dotp, len, ret));
 249         case DW_EH_PE_sleb128:
 250                 return (sleb_extract(data, dotp, len, (int64_t *)ret));
 251         default:
 252                 *ret = 0;
 253                 return (DW_BAD_ENCODING);
 254         }
 255
 256         if (lsb) {
 257                 /*
 258                  * Extract unaligned LSB formated data
 259                  */
 260                 uint_t  cnt;
 261
 262                 result = 0;
 263                 for (cnt = 0; cnt < fsize;
 264                     cnt++, dot++) {
 265                         uint64_t val;
 266
 267                         if (dot > len)
 268                                 return (DW_OVERFLOW);
 269                         val = data[dot];
 270                         result |= val << (cnt * 8);
 271                 }
 272         } else {
 273                 /*
 274                  * Extract unaligned MSB formated data
 275                  */
 276                 uint_t  cnt;
 277                 result = 0;
 278                 for (cnt = 0; cnt < fsize;
 279                     cnt++, dot++) {
 280                         uint64_t val;
 281
 282                         if (dot > len)
 283                                 return (DW_OVERFLOW);
 284                         val = data[dot];
 285                         result |= val << ((fsize - cnt - 1) * 8);
 286                 }
 287         }
 288         /*
 289          * perform sign extension
 290          */
 291         if ((ehe_flags & DW_EH_PE_signed) &&
 292             (fsize < sizeof (uint64_t))) {
 293                 int64_t sresult;
 294                 uint_t  bitshift;
 295                 sresult = result;
 296                 bitshift = (sizeof (uint64_t) - fsize) * 8;
 297                 sresult = (sresult << bitshift) >> bitshift;
 298                 result = sresult;
 299         }
 300
 301         /*
 302          * If value is relative to a base address, adjust it
 303          */
 304         switch (ehe_flags & 0xf0) {
 305         case DW_EH_PE_pcrel:
 306                 result += sh_base + sh_offset;
 307                 break;
 308
 309         /*
 310          * datarel is relative to .eh_frame_hdr if within .eh_frame,
 311          * but GOT if not.
 312          */
 313         case DW_EH_PE_datarel:
 314                 if (frame_hdr)
 315                         result += sh_base;
 316                 else
 317                         result += dbase;
 318                 break;
 319         }
 320
 321         /* Truncate the result to its specified size */
 322         result = (result << ((sizeof (uint64_t) - fsize) * 8)) >>
 323             ((sizeof (uint64_t) - fsize) * 8);
 324
 325         *dotp = dot;
 326         *ret = result;
 327         return (DW_SUCCESS);
 328 }