1 /*-
2 * Copyright (c) 2007 John Birrell (jb@freebsd.org)
3 * Copyright (c) 2014 Kai Wang
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 * 1. Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 *
15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
16 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
17 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
18 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
19 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
20 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
21 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
22 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
23 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
24 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
25 * SUCH DAMAGE.
26 */
27
28 #include "_libdwarf.h"
29
30 ELFTC_VCSID("$Id: libdwarf_loc.c 3070 2014-06-23 03:08:33Z kaiwang27 $");
31
32 /*
33 * Given an array of bytes of length 'len' representing a
34 * DWARF expression, compute the number of operations based
35 * on there being one byte describing the operation and
36 * zero or more bytes of operands as defined in the standard
37 * for each operation type. Also, if lbuf is non-null, store
38 * the opcode and oprand in it.
39 */
40 static int
_dwarf_loc_fill_loc(Dwarf_Debug dbg,Dwarf_Locdesc * lbuf,uint8_t pointer_size,uint8_t offset_size,uint8_t version,uint8_t * p,int len)41 _dwarf_loc_fill_loc(Dwarf_Debug dbg, Dwarf_Locdesc *lbuf, uint8_t pointer_size,
42 uint8_t offset_size, uint8_t version, uint8_t *p, int len)
43 {
44 int count;
45 uint64_t operand1;
46 uint64_t operand2;
47 uint8_t *ps, *pe, s;
48
49 count = 0;
50 ps = p;
51 pe = p + len;
52
53 /*
54 * Process each byte. If an error occurs, then the
55 * count will be set to -1.
56 */
57 while (p < pe) {
58
59 operand1 = 0;
60 operand2 = 0;
61
62 if (lbuf != NULL) {
63 lbuf->ld_s[count].lr_atom = *p;
64 lbuf->ld_s[count].lr_offset = p - ps;
65 }
66
67 switch (*p++) {
68 /* Operations with no operands. */
69 case DW_OP_deref:
70 case DW_OP_reg0:
71 case DW_OP_reg1:
72 case DW_OP_reg2:
73 case DW_OP_reg3:
74 case DW_OP_reg4:
75 case DW_OP_reg5:
76 case DW_OP_reg6:
77 case DW_OP_reg7:
78 case DW_OP_reg8:
79 case DW_OP_reg9:
80 case DW_OP_reg10:
81 case DW_OP_reg11:
82 case DW_OP_reg12:
83 case DW_OP_reg13:
84 case DW_OP_reg14:
85 case DW_OP_reg15:
86 case DW_OP_reg16:
87 case DW_OP_reg17:
88 case DW_OP_reg18:
89 case DW_OP_reg19:
90 case DW_OP_reg20:
91 case DW_OP_reg21:
92 case DW_OP_reg22:
93 case DW_OP_reg23:
94 case DW_OP_reg24:
95 case DW_OP_reg25:
96 case DW_OP_reg26:
97 case DW_OP_reg27:
98 case DW_OP_reg28:
99 case DW_OP_reg29:
100 case DW_OP_reg30:
101 case DW_OP_reg31:
102
103 case DW_OP_lit0:
104 case DW_OP_lit1:
105 case DW_OP_lit2:
106 case DW_OP_lit3:
107 case DW_OP_lit4:
108 case DW_OP_lit5:
109 case DW_OP_lit6:
110 case DW_OP_lit7:
111 case DW_OP_lit8:
112 case DW_OP_lit9:
113 case DW_OP_lit10:
114 case DW_OP_lit11:
115 case DW_OP_lit12:
116 case DW_OP_lit13:
117 case DW_OP_lit14:
118 case DW_OP_lit15:
119 case DW_OP_lit16:
120 case DW_OP_lit17:
121 case DW_OP_lit18:
122 case DW_OP_lit19:
123 case DW_OP_lit20:
124 case DW_OP_lit21:
125 case DW_OP_lit22:
126 case DW_OP_lit23:
127 case DW_OP_lit24:
128 case DW_OP_lit25:
129 case DW_OP_lit26:
130 case DW_OP_lit27:
131 case DW_OP_lit28:
132 case DW_OP_lit29:
133 case DW_OP_lit30:
134 case DW_OP_lit31:
135
136 case DW_OP_dup:
137 case DW_OP_drop:
138
139 case DW_OP_over:
140
141 case DW_OP_swap:
142 case DW_OP_rot:
143 case DW_OP_xderef:
144
145 case DW_OP_abs:
146 case DW_OP_and:
147 case DW_OP_div:
148 case DW_OP_minus:
149 case DW_OP_mod:
150 case DW_OP_mul:
151 case DW_OP_neg:
152 case DW_OP_not:
153 case DW_OP_or:
154 case DW_OP_plus:
155
156 case DW_OP_shl:
157 case DW_OP_shr:
158 case DW_OP_shra:
159 case DW_OP_xor:
160
161 case DW_OP_eq:
162 case DW_OP_ge:
163 case DW_OP_gt:
164 case DW_OP_le:
165 case DW_OP_lt:
166 case DW_OP_ne:
167
168 case DW_OP_nop:
169 case DW_OP_push_object_address:
170 case DW_OP_form_tls_address:
171 case DW_OP_call_frame_cfa:
172 case DW_OP_stack_value:
173 case DW_OP_GNU_push_tls_address:
174 case DW_OP_GNU_uninit:
175 break;
176
177 /* Operations with 1-byte operands. */
178 case DW_OP_const1u:
179 case DW_OP_pick:
180 case DW_OP_deref_size:
181 case DW_OP_xderef_size:
182 operand1 = *p++;
183 break;
184
185 case DW_OP_const1s:
186 operand1 = (int8_t) *p++;
187 break;
188
189 /* Operations with 2-byte operands. */
190 case DW_OP_call2:
191 case DW_OP_const2u:
192 case DW_OP_bra:
193 case DW_OP_skip:
194 operand1 = dbg->decode(&p, 2);
195 break;
196
197 case DW_OP_const2s:
198 operand1 = (int16_t) dbg->decode(&p, 2);
199 break;
200
201 /* Operations with 4-byte operands. */
202 case DW_OP_call4:
203 case DW_OP_const4u:
204 case DW_OP_GNU_parameter_ref:
205 operand1 = dbg->decode(&p, 4);
206 break;
207
208 case DW_OP_const4s:
209 operand1 = (int32_t) dbg->decode(&p, 4);
210 break;
211
212 /* Operations with 8-byte operands. */
213 case DW_OP_const8u:
214 case DW_OP_const8s:
215 operand1 = dbg->decode(&p, 8);
216 break;
217
218 /* Operations with an unsigned LEB128 operand. */
219 case DW_OP_constu:
220 case DW_OP_plus_uconst:
221 case DW_OP_regx:
222 case DW_OP_piece:
223 case DW_OP_GNU_deref_type:
224 case DW_OP_GNU_convert:
225 case DW_OP_GNU_reinterpret:
226 operand1 = _dwarf_decode_uleb128(&p);
227 break;
228
229 /* Operations with a signed LEB128 operand. */
230 case DW_OP_consts:
231 case DW_OP_breg0:
232 case DW_OP_breg1:
233 case DW_OP_breg2:
234 case DW_OP_breg3:
235 case DW_OP_breg4:
236 case DW_OP_breg5:
237 case DW_OP_breg6:
238 case DW_OP_breg7:
239 case DW_OP_breg8:
240 case DW_OP_breg9:
241 case DW_OP_breg10:
242 case DW_OP_breg11:
243 case DW_OP_breg12:
244 case DW_OP_breg13:
245 case DW_OP_breg14:
246 case DW_OP_breg15:
247 case DW_OP_breg16:
248 case DW_OP_breg17:
249 case DW_OP_breg18:
250 case DW_OP_breg19:
251 case DW_OP_breg20:
252 case DW_OP_breg21:
253 case DW_OP_breg22:
254 case DW_OP_breg23:
255 case DW_OP_breg24:
256 case DW_OP_breg25:
257 case DW_OP_breg26:
258 case DW_OP_breg27:
259 case DW_OP_breg28:
260 case DW_OP_breg29:
261 case DW_OP_breg30:
262 case DW_OP_breg31:
263 case DW_OP_fbreg:
264 operand1 = _dwarf_decode_sleb128(&p);
265 break;
266
267 /*
268 * Oeration with two unsigned LEB128 operands.
269 */
270 case DW_OP_bit_piece:
271 case DW_OP_GNU_regval_type:
272 operand1 = _dwarf_decode_uleb128(&p);
273 operand2 = _dwarf_decode_uleb128(&p);
274 break;
275
276 /*
277 * Operations with an unsigned LEB128 operand
278 * followed by a signed LEB128 operand.
279 */
280 case DW_OP_bregx:
281 operand1 = _dwarf_decode_uleb128(&p);
282 operand2 = _dwarf_decode_sleb128(&p);
283 break;
284
285 /*
286 * Operation with an unsigned LEB128 operand
287 * representing the size of a block, followed
288 * by the block content.
289 *
290 * Store the size of the block in the operand1
291 * and a pointer to the block in the operand2.
292 */
293 case DW_OP_implicit_value:
294 case DW_OP_GNU_entry_value:
295 operand1 = _dwarf_decode_uleb128(&p);
296 operand2 = (Dwarf_Unsigned) (uintptr_t) p;
297 p += operand1;
298 break;
299
300 /* Target address size operand. */
301 case DW_OP_addr:
302 case DW_OP_GNU_addr_index:
303 case DW_OP_GNU_const_index:
304 operand1 = dbg->decode(&p, pointer_size);
305 break;
306
307 /* Offset size operand. */
308 case DW_OP_call_ref:
309 operand1 = dbg->decode(&p, offset_size);
310 break;
311
312 /*
313 * The first byte is address byte length, followed by
314 * the address value. If the length is 0, the address
315 * size is the same as target pointer size.
316 */
317 case DW_OP_GNU_encoded_addr:
318 s = *p++;
319 if (s == 0)
320 s = pointer_size;
321 operand1 = dbg->decode(&p, s);
322 break;
323
324 /*
325 * Operand1: DIE offset (size depending on DWARF version)
326 * DWARF2: pointer size
327 * DWARF{3,4}: offset size
328 *
329 * Operand2: SLEB128
330 */
331 case DW_OP_GNU_implicit_pointer:
332 if (version == 2)
333 operand1 = dbg->decode(&p, pointer_size);
334 else
335 operand1 = dbg->decode(&p, offset_size);
336 operand2 = _dwarf_decode_sleb128(&p);
337 break;
338
339 /*
340 * Operand1: DIE offset (ULEB128)
341 * Operand2: pointer to a block. The block's first byte
342 * is its size.
343 */
344 case DW_OP_GNU_const_type:
345 operand1 = _dwarf_decode_uleb128(&p);
346 operand2 = (Dwarf_Unsigned) (uintptr_t) p;
347 s = *p++;
348 p += s;
349 break;
350
351 /* All other operations cause an error. */
352 default:
353 count = -1;
354 goto done;
355 }
356
357 if (lbuf != NULL) {
358 lbuf->ld_s[count].lr_number = operand1;
359 lbuf->ld_s[count].lr_number2 = operand2;
360 }
361
362 count++;
363 }
364
365 done:
366 return (count);
367 }
368
369 int
_dwarf_loc_expr_add_atom(Dwarf_Debug dbg,uint8_t * out,uint8_t * end,Dwarf_Small atom,Dwarf_Unsigned operand1,Dwarf_Unsigned operand2,int * length,Dwarf_Error * error)370 _dwarf_loc_expr_add_atom(Dwarf_Debug dbg, uint8_t *out, uint8_t *end,
371 Dwarf_Small atom, Dwarf_Unsigned operand1, Dwarf_Unsigned operand2,
372 int *length, Dwarf_Error *error)
373 {
374 uint8_t buf[64];
375 uint8_t *p, *pe;
376 uint64_t offset;
377 int len;
378
379 if (out != NULL && end != NULL) {
380 p = out;
381 pe = end;
382 } else {
383 p = out = buf;
384 pe = &buf[sizeof(buf)];
385 }
386
387 switch (atom) {
388 /* Operations with no operands. */
389 case DW_OP_deref:
390 case DW_OP_reg0:
391 case DW_OP_reg1:
392 case DW_OP_reg2:
393 case DW_OP_reg3:
394 case DW_OP_reg4:
395 case DW_OP_reg5:
396 case DW_OP_reg6:
397 case DW_OP_reg7:
398 case DW_OP_reg8:
399 case DW_OP_reg9:
400 case DW_OP_reg10:
401 case DW_OP_reg11:
402 case DW_OP_reg12:
403 case DW_OP_reg13:
404 case DW_OP_reg14:
405 case DW_OP_reg15:
406 case DW_OP_reg16:
407 case DW_OP_reg17:
408 case DW_OP_reg18:
409 case DW_OP_reg19:
410 case DW_OP_reg20:
411 case DW_OP_reg21:
412 case DW_OP_reg22:
413 case DW_OP_reg23:
414 case DW_OP_reg24:
415 case DW_OP_reg25:
416 case DW_OP_reg26:
417 case DW_OP_reg27:
418 case DW_OP_reg28:
419 case DW_OP_reg29:
420 case DW_OP_reg30:
421 case DW_OP_reg31:
422
423 case DW_OP_lit0:
424 case DW_OP_lit1:
425 case DW_OP_lit2:
426 case DW_OP_lit3:
427 case DW_OP_lit4:
428 case DW_OP_lit5:
429 case DW_OP_lit6:
430 case DW_OP_lit7:
431 case DW_OP_lit8:
432 case DW_OP_lit9:
433 case DW_OP_lit10:
434 case DW_OP_lit11:
435 case DW_OP_lit12:
436 case DW_OP_lit13:
437 case DW_OP_lit14:
438 case DW_OP_lit15:
439 case DW_OP_lit16:
440 case DW_OP_lit17:
441 case DW_OP_lit18:
442 case DW_OP_lit19:
443 case DW_OP_lit20:
444 case DW_OP_lit21:
445 case DW_OP_lit22:
446 case DW_OP_lit23:
447 case DW_OP_lit24:
448 case DW_OP_lit25:
449 case DW_OP_lit26:
450 case DW_OP_lit27:
451 case DW_OP_lit28:
452 case DW_OP_lit29:
453 case DW_OP_lit30:
454 case DW_OP_lit31:
455
456 case DW_OP_dup:
457 case DW_OP_drop:
458
459 case DW_OP_over:
460
461 case DW_OP_swap:
462 case DW_OP_rot:
463 case DW_OP_xderef:
464
465 case DW_OP_abs:
466 case DW_OP_and:
467 case DW_OP_div:
468 case DW_OP_minus:
469 case DW_OP_mod:
470 case DW_OP_mul:
471 case DW_OP_neg:
472 case DW_OP_not:
473 case DW_OP_or:
474 case DW_OP_plus:
475
476 case DW_OP_shl:
477 case DW_OP_shr:
478 case DW_OP_shra:
479 case DW_OP_xor:
480
481 case DW_OP_eq:
482 case DW_OP_ge:
483 case DW_OP_gt:
484 case DW_OP_le:
485 case DW_OP_lt:
486 case DW_OP_ne:
487
488 case DW_OP_nop:
489 case DW_OP_GNU_push_tls_address:
490 *p++ = atom;
491 break;
492
493 /* Operations with 1-byte operands. */
494 case DW_OP_const1u:
495 case DW_OP_const1s:
496 case DW_OP_pick:
497 case DW_OP_deref_size:
498 case DW_OP_xderef_size:
499 *p++ = atom;
500 *p++ = (uint8_t) operand1;
501 break;
502
503 /* Operations with 2-byte operands. */
504 case DW_OP_const2u:
505 case DW_OP_const2s:
506 case DW_OP_bra:
507 case DW_OP_skip:
508 *p++ = atom;
509 offset = 0;
510 dbg->write(p, &offset, operand1, 2);
511 p += 2;
512 break;
513
514 /* Operations with 4-byte operands. */
515 case DW_OP_const4u:
516 case DW_OP_const4s:
517 *p++ = atom;
518 offset = 0;
519 dbg->write(p, &offset, operand1, 4);
520 p += 4;
521 break;
522
523 /* Operations with 8-byte operands. */
524 case DW_OP_const8u:
525 case DW_OP_const8s:
526 *p++ = atom;
527 offset = 0;
528 dbg->write(p, &offset, operand1, 8);
529 p += 8;
530 break;
531
532 /* Operations with an unsigned LEB128 operand. */
533 case DW_OP_constu:
534 case DW_OP_plus_uconst:
535 case DW_OP_regx:
536 case DW_OP_piece:
537 *p++ = atom;
538 len = _dwarf_write_uleb128(p, pe, operand1);
539 assert(len > 0);
540 p += len;
541 break;
542
543 /* Operations with a signed LEB128 operand. */
544 case DW_OP_consts:
545 case DW_OP_breg0:
546 case DW_OP_breg1:
547 case DW_OP_breg2:
548 case DW_OP_breg3:
549 case DW_OP_breg4:
550 case DW_OP_breg5:
551 case DW_OP_breg6:
552 case DW_OP_breg7:
553 case DW_OP_breg8:
554 case DW_OP_breg9:
555 case DW_OP_breg10:
556 case DW_OP_breg11:
557 case DW_OP_breg12:
558 case DW_OP_breg13:
559 case DW_OP_breg14:
560 case DW_OP_breg15:
561 case DW_OP_breg16:
562 case DW_OP_breg17:
563 case DW_OP_breg18:
564 case DW_OP_breg19:
565 case DW_OP_breg20:
566 case DW_OP_breg21:
567 case DW_OP_breg22:
568 case DW_OP_breg23:
569 case DW_OP_breg24:
570 case DW_OP_breg25:
571 case DW_OP_breg26:
572 case DW_OP_breg27:
573 case DW_OP_breg28:
574 case DW_OP_breg29:
575 case DW_OP_breg30:
576 case DW_OP_breg31:
577 case DW_OP_fbreg:
578 *p++ = atom;
579 len = _dwarf_write_sleb128(p, pe, operand1);
580 assert(len > 0);
581 p += len;
582 break;
583
584 /*
585 * Operations with an unsigned LEB128 operand
586 * followed by a signed LEB128 operand.
587 */
588 case DW_OP_bregx:
589 *p++ = atom;
590 len = _dwarf_write_uleb128(p, pe, operand1);
591 assert(len > 0);
592 p += len;
593 len = _dwarf_write_sleb128(p, pe, operand2);
594 assert(len > 0);
595 p += len;
596 break;
597
598 /* Target address size operand. */
599 case DW_OP_addr:
600 *p++ = atom;
601 offset = 0;
602 dbg->write(p, &offset, operand1, dbg->dbg_pointer_size);
603 p += dbg->dbg_pointer_size;
604 break;
605
606 /* All other operations cause an error. */
607 default:
608 DWARF_SET_ERROR(dbg, error, DW_DLE_LOC_EXPR_BAD);
609 return (DW_DLE_LOC_EXPR_BAD);
610 }
611
612 if (length)
613 *length = p - out;
614
615 return (DW_DLE_NONE);
616 }
617
618 int
_dwarf_loc_fill_locdesc(Dwarf_Debug dbg,Dwarf_Locdesc * llbuf,uint8_t * in,uint64_t in_len,uint8_t pointer_size,uint8_t offset_size,uint8_t version,Dwarf_Error * error)619 _dwarf_loc_fill_locdesc(Dwarf_Debug dbg, Dwarf_Locdesc *llbuf, uint8_t *in,
620 uint64_t in_len, uint8_t pointer_size, uint8_t offset_size,
621 uint8_t version, Dwarf_Error *error)
622 {
623 int num;
624
625 assert(llbuf != NULL);
626 assert(in != NULL);
627 assert(in_len > 0);
628
629 /* Compute the number of locations. */
630 if ((num = _dwarf_loc_fill_loc(dbg, NULL, pointer_size, offset_size,
631 version, in, in_len)) < 0) {
632 DWARF_SET_ERROR(dbg, error, DW_DLE_LOC_EXPR_BAD);
633 return (DW_DLE_LOC_EXPR_BAD);
634 }
635
636 llbuf->ld_cents = num;
637 if (num <= 0)
638 return (DW_DLE_NONE);
639
640 if ((llbuf->ld_s = calloc(num, sizeof(Dwarf_Loc))) == NULL) {
641 DWARF_SET_ERROR(dbg, error, DW_DLE_MEMORY);
642 return (DW_DLE_MEMORY);
643 }
644
645 (void) _dwarf_loc_fill_loc(dbg, llbuf, pointer_size, offset_size,
646 version, in, in_len);
647
648 return (DW_DLE_NONE);
649 }
650
651 int
_dwarf_loc_fill_locexpr(Dwarf_Debug dbg,Dwarf_Locdesc ** ret_llbuf,uint8_t * in,uint64_t in_len,uint8_t pointer_size,uint8_t offset_size,uint8_t version,Dwarf_Error * error)652 _dwarf_loc_fill_locexpr(Dwarf_Debug dbg, Dwarf_Locdesc **ret_llbuf, uint8_t *in,
653 uint64_t in_len, uint8_t pointer_size, uint8_t offset_size,
654 uint8_t version, Dwarf_Error *error)
655 {
656 Dwarf_Locdesc *llbuf;
657 int ret;
658
659 if ((llbuf = malloc(sizeof(Dwarf_Locdesc))) == NULL) {
660 DWARF_SET_ERROR(dbg, error, DW_DLE_MEMORY);
661 return (DW_DLE_MEMORY);
662 }
663 llbuf->ld_lopc = 0;
664 llbuf->ld_hipc = ~0ULL;
665 llbuf->ld_s = NULL;
666
667 ret = _dwarf_loc_fill_locdesc(dbg, llbuf, in, in_len, pointer_size,
668 offset_size, version, error);
669 if (ret != DW_DLE_NONE) {
670 free(llbuf);
671 return (ret);
672 }
673
674 *ret_llbuf = llbuf;
675
676 return (ret);
677 }
678
679 int
_dwarf_loc_add(Dwarf_Die die,Dwarf_Attribute at,Dwarf_Error * error)680 _dwarf_loc_add(Dwarf_Die die, Dwarf_Attribute at, Dwarf_Error *error)
681 {
682 Dwarf_Debug dbg;
683 Dwarf_CU cu;
684 int ret;
685
686 assert(at->at_ld == NULL);
687 assert(at->u[1].u8p != NULL);
688 assert(at->u[0].u64 > 0);
689
690 cu = die->die_cu;
691 assert(cu != NULL);
692
693 dbg = cu->cu_dbg;
694 assert(dbg != NULL);
695
696 ret = _dwarf_loc_fill_locexpr(dbg, &at->at_ld, at->u[1].u8p,
697 at->u[0].u64, cu->cu_pointer_size, cu->cu_length_size == 4 ? 4 : 8,
698 cu->cu_version, error);
699
700 return (ret);
701 }
702