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 * sh_base - Base address of ELF section containing desired datum
194 * sh_offset - Offset relative to sh_base of desired datum.
195 */
196 uint64_t
197 dwarf_ehe_extract(unsigned char *data, uint64_t *dotp, uint_t ehe_flags,
198 unsigned char *eident, boolean_t frame_hdr, uint64_t sh_base,
199 uint64_t sh_offset, uint64_t dbase)
200 {
201 uint64_t dot = *dotp;
202 uint_t lsb;
203 uint_t wordsize;
204 uint_t fsize;
205 uint64_t result;
206
207 if (eident[EI_DATA] == ELFDATA2LSB)
208 lsb = 1;
209 else
210 lsb = 0;
211
212 if (eident[EI_CLASS] == ELFCLASS64)
213 wordsize = 8;
214 else
215 wordsize = 4;
216
217 switch (ehe_flags & 0x0f) {
218 case DW_EH_PE_omit:
219 return (0);
220 case DW_EH_PE_absptr:
221 fsize = wordsize;
222 break;
223 case DW_EH_PE_udata8:
224 case DW_EH_PE_sdata8:
225 fsize = 8;
226 break;
227 case DW_EH_PE_udata4:
228 case DW_EH_PE_sdata4:
229 fsize = 4;
230 break;
231 case DW_EH_PE_udata2:
232 case DW_EH_PE_sdata2:
233 fsize = 2;
234 break;
235 case DW_EH_PE_uleb128:
236 return (uleb_extract(data, dotp));
237 case DW_EH_PE_sleb128:
238 return ((uint64_t)sleb_extract(data, dotp));
239 default:
240 return (0);
241 }
242
243 if (lsb) {
244 /*
245 * Extract unaligned LSB formated data
246 */
247 uint_t cnt;
248
249 result = 0;
250 for (cnt = 0; cnt < fsize;
251 cnt++, dot++) {
252 uint64_t val;
253 val = data[dot];
254 result |= val << (cnt * 8);
255 }
256 } else {
257 /*
258 * Extract unaligned MSB formated data
259 */
260 uint_t cnt;
261 result = 0;
262 for (cnt = 0; cnt < fsize;
263 cnt++, dot++) {
264 uint64_t val;
265 val = data[dot];
266 result |= val << ((fsize - cnt - 1) * 8);
267 }
268 }
269 /*
270 * perform sign extension
271 */
272 if ((ehe_flags & DW_EH_PE_signed) &&
273 (fsize < sizeof (uint64_t))) {
274 int64_t sresult;
275 uint_t bitshift;
276 sresult = result;
277 bitshift = (sizeof (uint64_t) - fsize) * 8;
278 sresult = (sresult << bitshift) >> bitshift;
279 result = sresult;
280 }
281
282 /*
283 * If value is relative to a base address, adjust it
284 */
285 switch (ehe_flags & 0xf0) {
286 case DW_EH_PE_pcrel:
287 result += sh_base + sh_offset;
288 break;
289
290 /*
291 * datarel is relative to .eh_frame_hdr if within .eh_frame,
292 * but GOT if not.
293 */
294 case DW_EH_PE_datarel:
295 if (frame_hdr)
296 result += sh_base;
297 else
298 result += dbase;
299 break;
300 }
301
302 /* Truncate the result to its specified size */
303 result = (result << ((sizeof (uint64_t) - fsize) * 8)) >>
304 ((sizeof (uint64_t) - fsize) * 8);
305
306 *dotp = dot;
307 return (result);
308 }