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 uint64_t
 103 uleb_extract(unsigned char *data, uint64_t *dotp)
 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                 /*
 115                  * Pull off lower 7 bits
 116                  */
 117                 val = (*data) & 0x7f;
 118 
 119                 /*
 120                  * Add prepend value to head of number.
 121                  */
 122                 res = res | (val << shift);
 123 
 124                 /*
 125                  * Increment shift & dot pointer
 126                  */
 127                 shift += 7;
 128                 dot++;
 129 
 130                 /*
 131                  * Check to see if hi bit is set - if not, this
 132                  * is the last byte.
 133                  */
 134                 more = ((*data++) & 0x80) >> 7;
 135         }
 136         *dotp = dot;
 137         return (res);
 138 }
 139 
 140 int64_t
 141 sleb_extract(unsigned char *data, uint64_t *dotp)
 142 {
 143         uint64_t        dot = *dotp;
 144         int64_t         res = 0;
 145         int             more = 1;
 146         int             shift = 0;
 147         int             val;
 148 
 149         data += dot;
 150 
 151         while (more) {
 152                 /*
 153                  * Pull off lower 7 bits
 154                  */
 155                 val = (*data) & 0x7f;
 156 
 157                 /*
 158                  * Add prepend value to head of number.
 159                  */
 160                 res = res | (val << shift);
 161 
 162                 /*
 163                  * Increment shift & dot pointer
 164                  */
 165                 shift += 7;
 166                 dot++;
 167 
 168                 /*
 169                  * Check to see if hi bit is set - if not, this
 170                  * is the last byte.
 171                  */
 172                 more = ((*data++) & 0x80) >> 7;
 173         }
 174         *dotp = dot;
 175 
 176         /*
 177          * Make sure value is properly sign extended.
 178          */
 179         res = (res << (64 - shift)) >> (64 - shift);
 180 
 181         return (res);
 182 }
 183 
 184 /*
 185  * Extract a DWARF encoded datum
 186  *
 187  * entry:
 188  *      data - Base of data buffer containing encoded bytes
 189  *      dotp - Address of variable containing index within data
 190  *              at which the desired datum starts.
 191  *      ehe_flags - DWARF encoding
 192  *      eident - ELF header e_ident[] array for object being processed
 193  *      frame_hdr - Boolean, true if we're extracting from .eh_frame_hdr
 194  *      sh_base - Base address of ELF section containing desired datum
 195  *      sh_offset - Offset relative to sh_base of desired datum.
 196  *      dbase - The base address to which DW_EH_PE_datarel is relative
 197  *              (if frame_hdr is false)
 198  */
 199 uint64_t
 200 dwarf_ehe_extract(unsigned char *data, uint64_t *dotp, uint_t ehe_flags,
 201     unsigned char *eident, boolean_t frame_hdr, uint64_t sh_base,
 202     uint64_t sh_offset, uint64_t dbase)
 203 {
 204         uint64_t    dot = *dotp;
 205         uint_t      lsb;
 206         uint_t      wordsize;
 207         uint_t      fsize;
 208         uint64_t    result;
 209 
 210         if (eident[EI_DATA] == ELFDATA2LSB)
 211                 lsb = 1;
 212         else
 213                 lsb = 0;
 214 
 215         if (eident[EI_CLASS] == ELFCLASS64)
 216                 wordsize = 8;
 217         else
 218                 wordsize = 4;
 219 
 220         switch (ehe_flags & 0x0f) {
 221         case DW_EH_PE_omit:
 222                 return (0);
 223         case DW_EH_PE_absptr:
 224                 fsize = wordsize;
 225                 break;
 226         case DW_EH_PE_udata8:
 227         case DW_EH_PE_sdata8:
 228                 fsize = 8;
 229                 break;
 230         case DW_EH_PE_udata4:
 231         case DW_EH_PE_sdata4:
 232                 fsize = 4;
 233                 break;
 234         case DW_EH_PE_udata2:
 235         case DW_EH_PE_sdata2:
 236                 fsize = 2;
 237                 break;
 238         case DW_EH_PE_uleb128:
 239                 return (uleb_extract(data, dotp));
 240         case DW_EH_PE_sleb128:
 241                 return ((uint64_t)sleb_extract(data, dotp));
 242         default:
 243                 return (0);
 244         }
 245 
 246         if (lsb) {
 247                 /*
 248                  * Extract unaligned LSB formated data
 249                  */
 250                 uint_t  cnt;
 251 
 252                 result = 0;
 253                 for (cnt = 0; cnt < fsize;
 254                     cnt++, dot++) {
 255                         uint64_t val;
 256                         val = data[dot];
 257                         result |= val << (cnt * 8);
 258                 }
 259         } else {
 260                 /*
 261                  * Extract unaligned MSB formated data
 262                  */
 263                 uint_t  cnt;
 264                 result = 0;
 265                 for (cnt = 0; cnt < fsize;
 266                     cnt++, dot++) {
 267                         uint64_t        val;
 268                         val = data[dot];
 269                         result |= val << ((fsize - cnt - 1) * 8);
 270                 }
 271         }
 272         /*
 273          * perform sign extension
 274          */
 275         if ((ehe_flags & DW_EH_PE_signed) &&
 276             (fsize < sizeof (uint64_t))) {
 277                 int64_t sresult;
 278                 uint_t  bitshift;
 279                 sresult = result;
 280                 bitshift = (sizeof (uint64_t) - fsize) * 8;
 281                 sresult = (sresult << bitshift) >> bitshift;
 282                 result = sresult;
 283         }
 284 
 285         /*
 286          * If value is relative to a base address, adjust it
 287          */
 288         switch (ehe_flags & 0xf0) {
 289         case DW_EH_PE_pcrel:
 290                 result += sh_base + sh_offset;
 291                 break;
 292 
 293         /*
 294          * datarel is relative to .eh_frame_hdr if within .eh_frame,
 295          * but GOT if not.
 296          */
 297         case DW_EH_PE_datarel:
 298                 if (frame_hdr)
 299                         result += sh_base;
 300                 else
 301                         result += dbase;
 302                 break;
 303         }
 304 
 305         /* Truncate the result to its specified size */
 306         result = (result << ((sizeof (uint64_t) - fsize) * 8)) >>
 307             ((sizeof (uint64_t) - fsize) * 8);
 308 
 309         *dotp = dot;
 310         return (result);
 311 }