1 /* libunwind - a platform-independent unwind library
2 Copyright (c) 2003, 2005 Hewlett-Packard Development Company, L.P.
3 Contributed by David Mosberger-Tang <davidm@hpl.hp.com>
5 This file is part of libunwind.
7 Permission is hereby granted, free of charge, to any person obtaining
8 a copy of this software and associated documentation files (the
9 "Software"), to deal in the Software without restriction, including
10 without limitation the rights to use, copy, modify, merge, publish,
11 distribute, sublicense, and/or sell copies of the Software, and to
12 permit persons to whom the Software is furnished to do so, subject to
13 the following conditions:
15 The above copyright notice and this permission notice shall be
16 included in all copies or substantial portions of the Software.
18 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
19 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
20 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
21 NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
22 LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
23 OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
24 WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
27 #include "libunwind_i.h"
29 /* The "pick" operator provides an index range of 0..255 indicating
30 that the stack could at least have a depth of up to 256 elements,
31 but the GCC unwinder restricts the depth to 64, which seems
32 reasonable so we use the same value here. */
33 #define MAX_EXPR_STACK_SIZE 64
35 #define NUM_OPERANDS(signature) (((signature) >> 6) & 0x3)
36 #define OPND1_TYPE(signature) (((signature) >> 3) & 0x7)
37 #define OPND2_TYPE(signature) (((signature) >> 0) & 0x7)
39 #define OPND_SIGNATURE(n, t1, t2) (((n) << 6) | ((t1) << 3) | ((t2) << 0))
40 #define OPND1(t1) OPND_SIGNATURE(1, t1, 0)
41 #define OPND2(t1, t2) OPND_SIGNATURE(2, t1, t2)
49 #define OFFSET 0x6 /* 32-bit offset for 32-bit DWARF, 64-bit otherwise */
50 #define ADDR 0x7 /* Machine address. */
52 static const uint8_t operands[256] =
54 [DW_OP_addr] = OPND1 (ADDR),
55 [DW_OP_const1u] = OPND1 (VAL8),
56 [DW_OP_const1s] = OPND1 (VAL8),
57 [DW_OP_const2u] = OPND1 (VAL16),
58 [DW_OP_const2s] = OPND1 (VAL16),
59 [DW_OP_const4u] = OPND1 (VAL32),
60 [DW_OP_const4s] = OPND1 (VAL32),
61 [DW_OP_const8u] = OPND1 (VAL64),
62 [DW_OP_const8s] = OPND1 (VAL64),
63 [DW_OP_pick] = OPND1 (VAL8),
64 [DW_OP_plus_uconst] = OPND1 (ULEB128),
65 [DW_OP_skip] = OPND1 (VAL16),
66 [DW_OP_bra] = OPND1 (VAL16),
67 [DW_OP_breg0 + 0] = OPND1 (SLEB128),
68 [DW_OP_breg0 + 1] = OPND1 (SLEB128),
69 [DW_OP_breg0 + 2] = OPND1 (SLEB128),
70 [DW_OP_breg0 + 3] = OPND1 (SLEB128),
71 [DW_OP_breg0 + 4] = OPND1 (SLEB128),
72 [DW_OP_breg0 + 5] = OPND1 (SLEB128),
73 [DW_OP_breg0 + 6] = OPND1 (SLEB128),
74 [DW_OP_breg0 + 7] = OPND1 (SLEB128),
75 [DW_OP_breg0 + 8] = OPND1 (SLEB128),
76 [DW_OP_breg0 + 9] = OPND1 (SLEB128),
77 [DW_OP_breg0 + 10] = OPND1 (SLEB128),
78 [DW_OP_breg0 + 11] = OPND1 (SLEB128),
79 [DW_OP_breg0 + 12] = OPND1 (SLEB128),
80 [DW_OP_breg0 + 13] = OPND1 (SLEB128),
81 [DW_OP_breg0 + 14] = OPND1 (SLEB128),
82 [DW_OP_breg0 + 15] = OPND1 (SLEB128),
83 [DW_OP_breg0 + 16] = OPND1 (SLEB128),
84 [DW_OP_breg0 + 17] = OPND1 (SLEB128),
85 [DW_OP_breg0 + 18] = OPND1 (SLEB128),
86 [DW_OP_breg0 + 19] = OPND1 (SLEB128),
87 [DW_OP_breg0 + 20] = OPND1 (SLEB128),
88 [DW_OP_breg0 + 21] = OPND1 (SLEB128),
89 [DW_OP_breg0 + 22] = OPND1 (SLEB128),
90 [DW_OP_breg0 + 23] = OPND1 (SLEB128),
91 [DW_OP_breg0 + 24] = OPND1 (SLEB128),
92 [DW_OP_breg0 + 25] = OPND1 (SLEB128),
93 [DW_OP_breg0 + 26] = OPND1 (SLEB128),
94 [DW_OP_breg0 + 27] = OPND1 (SLEB128),
95 [DW_OP_breg0 + 28] = OPND1 (SLEB128),
96 [DW_OP_breg0 + 29] = OPND1 (SLEB128),
97 [DW_OP_breg0 + 30] = OPND1 (SLEB128),
98 [DW_OP_breg0 + 31] = OPND1 (SLEB128),
99 [DW_OP_regx] = OPND1 (ULEB128),
100 [DW_OP_fbreg] = OPND1 (SLEB128),
101 [DW_OP_bregx] = OPND2 (ULEB128, SLEB128),
102 [DW_OP_piece] = OPND1 (ULEB128),
103 [DW_OP_deref_size] = OPND1 (VAL8),
104 [DW_OP_xderef_size] = OPND1 (VAL8),
105 [DW_OP_call2] = OPND1 (VAL16),
106 [DW_OP_call4] = OPND1 (VAL32),
107 [DW_OP_call_ref] = OPND1 (OFFSET)
110 static inline unw_sword_t
111 sword (unw_addr_space_t as, unw_word_t val)
113 switch (dwarf_addr_size (as))
115 case 1: return (int8_t) val;
116 case 2: return (int16_t) val;
117 case 4: return (int32_t) val;
118 case 8: return (int64_t) val;
123 static inline unw_word_t
124 read_operand (unw_addr_space_t as, unw_accessors_t *a,
125 unw_word_t *addr, int operand_type, unw_word_t *val, void *arg)
133 if (operand_type == ADDR)
134 switch (dwarf_addr_size (as))
136 case 1: operand_type = VAL8; break;
137 case 2: operand_type = VAL16; break;
138 case 4: operand_type = VAL32; break;
139 case 8: operand_type = VAL64; break;
143 switch (operand_type)
146 ret = dwarf_readu8 (as, a, addr, &u8, arg);
153 ret = dwarf_readu16 (as, a, addr, &u16, arg);
160 ret = dwarf_readu32 (as, a, addr, &u32, arg);
167 ret = dwarf_readu64 (as, a, addr, &u64, arg);
174 ret = dwarf_read_uleb128 (as, a, addr, val, arg);
178 ret = dwarf_read_sleb128 (as, a, addr, val, arg);
181 case OFFSET: /* only used by DW_OP_call_ref, which we don't implement */
183 Debug (1, "Unexpected operand type %d\n", operand_type);
190 dwarf_stack_aligned(struct dwarf_cursor *c, unw_word_t cfa_addr,
191 unw_word_t rbp_addr, unw_word_t *cfa_offset) {
199 a = unw_get_accessors_int (c->as);
202 ret = dwarf_read_uleb128(c->as, a, &rbp_addr, &len, arg);
203 if (len != 2 || ret < 0)
206 ret = dwarf_readu8(c->as, a, &rbp_addr, &opcode, arg);
207 if (ret < 0 || opcode != DW_OP_breg6)
210 ret = read_operand(c->as, a, &rbp_addr,
211 OPND1_TYPE(operands[opcode]), &operand1, arg);
213 if (ret < 0 || operand1 != 0)
216 ret = dwarf_read_uleb128(c->as, a, &cfa_addr, &len, arg);
217 if (ret < 0 || len != 3)
220 ret = dwarf_readu8(c->as, a, &cfa_addr, &opcode, arg);
221 if (ret < 0 || opcode != DW_OP_breg6)
224 ret = read_operand(c->as, a, &cfa_addr,
225 OPND1_TYPE(operands[opcode]), &operand1, arg);
229 ret = dwarf_readu8(c->as, a, &cfa_addr, &opcode, arg);
230 if (ret < 0 || opcode != DW_OP_deref)
233 *cfa_offset = operand1;
238 dwarf_eval_expr (struct dwarf_cursor *c, unw_word_t *addr, unw_word_t len,
239 unw_word_t *valp, int *is_register)
241 unw_word_t operand1 = 0, operand2 = 0, tmp1, tmp2 = 0, tmp3, end_addr;
242 uint8_t opcode, operands_signature, u8;
246 unw_word_t stack[MAX_EXPR_STACK_SIZE];
247 unsigned int tos = 0;
254 if ((tos - 1) >= MAX_EXPR_STACK_SIZE) \
256 Debug (1, "Stack underflow\n"); \
257 return -UNW_EINVAL; \
263 unw_word_t _x = (x); \
264 if (tos >= MAX_EXPR_STACK_SIZE) \
266 Debug (1, "Stack overflow\n"); \
267 return -UNW_EINVAL; \
273 unsigned int _index = tos - 1 - (n); \
274 if (_index >= MAX_EXPR_STACK_SIZE) \
276 Debug (1, "Out-of-stack pick\n"); \
277 return -UNW_EINVAL; \
284 a = unw_get_accessors_int (as);
285 end_addr = *addr + len;
288 Debug (14, "len=%lu, pushing cfa=0x%lx\n",
289 (unsigned long) len, (unsigned long) c->cfa);
291 push (c->cfa); /* push current CFA as required by DWARF spec */
293 while (*addr < end_addr)
295 if ((ret = dwarf_readu8 (as, a, addr, &opcode, arg)) < 0)
298 operands_signature = operands[opcode];
300 if (unlikely (NUM_OPERANDS (operands_signature) > 0))
302 if ((ret = read_operand (as, a, addr,
303 OPND1_TYPE (operands_signature),
304 &operand1, arg)) < 0)
306 if (NUM_OPERANDS (operands_signature) > 1)
307 if ((ret = read_operand (as, a, addr,
308 OPND2_TYPE (operands_signature),
309 &operand2, arg)) < 0)
313 switch ((dwarf_expr_op_t) opcode)
315 case DW_OP_lit0: case DW_OP_lit1: case DW_OP_lit2:
316 case DW_OP_lit3: case DW_OP_lit4: case DW_OP_lit5:
317 case DW_OP_lit6: case DW_OP_lit7: case DW_OP_lit8:
318 case DW_OP_lit9: case DW_OP_lit10: case DW_OP_lit11:
319 case DW_OP_lit12: case DW_OP_lit13: case DW_OP_lit14:
320 case DW_OP_lit15: case DW_OP_lit16: case DW_OP_lit17:
321 case DW_OP_lit18: case DW_OP_lit19: case DW_OP_lit20:
322 case DW_OP_lit21: case DW_OP_lit22: case DW_OP_lit23:
323 case DW_OP_lit24: case DW_OP_lit25: case DW_OP_lit26:
324 case DW_OP_lit27: case DW_OP_lit28: case DW_OP_lit29:
325 case DW_OP_lit30: case DW_OP_lit31:
326 Debug (15, "OP_lit(%d)\n", (int) opcode - DW_OP_lit0);
327 push (opcode - DW_OP_lit0);
330 case DW_OP_breg0: case DW_OP_breg1: case DW_OP_breg2:
331 case DW_OP_breg3: case DW_OP_breg4: case DW_OP_breg5:
332 case DW_OP_breg6: case DW_OP_breg7: case DW_OP_breg8:
333 case DW_OP_breg9: case DW_OP_breg10: case DW_OP_breg11:
334 case DW_OP_breg12: case DW_OP_breg13: case DW_OP_breg14:
335 case DW_OP_breg15: case DW_OP_breg16: case DW_OP_breg17:
336 case DW_OP_breg18: case DW_OP_breg19: case DW_OP_breg20:
337 case DW_OP_breg21: case DW_OP_breg22: case DW_OP_breg23:
338 case DW_OP_breg24: case DW_OP_breg25: case DW_OP_breg26:
339 case DW_OP_breg27: case DW_OP_breg28: case DW_OP_breg29:
340 case DW_OP_breg30: case DW_OP_breg31:
341 Debug (15, "OP_breg(r%d,0x%lx)\n",
342 (int) opcode - DW_OP_breg0, (unsigned long) operand1);
343 if ((ret = unw_get_reg (dwarf_to_cursor (c),
344 dwarf_to_unw_regnum (opcode - DW_OP_breg0),
347 push (tmp1 + operand1);
351 Debug (15, "OP_bregx(r%d,0x%lx)\n",
352 (int) operand1, (unsigned long) operand2);
353 if ((ret = unw_get_reg (dwarf_to_cursor (c),
354 dwarf_to_unw_regnum (operand1), &tmp1)) < 0)
356 push (tmp1 + operand2);
359 case DW_OP_reg0: case DW_OP_reg1: case DW_OP_reg2:
360 case DW_OP_reg3: case DW_OP_reg4: case DW_OP_reg5:
361 case DW_OP_reg6: case DW_OP_reg7: case DW_OP_reg8:
362 case DW_OP_reg9: case DW_OP_reg10: case DW_OP_reg11:
363 case DW_OP_reg12: case DW_OP_reg13: case DW_OP_reg14:
364 case DW_OP_reg15: case DW_OP_reg16: case DW_OP_reg17:
365 case DW_OP_reg18: case DW_OP_reg19: case DW_OP_reg20:
366 case DW_OP_reg21: case DW_OP_reg22: case DW_OP_reg23:
367 case DW_OP_reg24: case DW_OP_reg25: case DW_OP_reg26:
368 case DW_OP_reg27: case DW_OP_reg28: case DW_OP_reg29:
369 case DW_OP_reg30: case DW_OP_reg31:
370 Debug (15, "OP_reg(r%d)\n", (int) opcode - DW_OP_reg0);
371 *valp = dwarf_to_unw_regnum (opcode - DW_OP_reg0);
376 Debug (15, "OP_regx(r%d)\n", (int) operand1);
377 *valp = dwarf_to_unw_regnum (operand1);
389 Debug (15, "OP_const(0x%lx)\n", (unsigned long) operand1);
395 operand1 |= ((unw_word_t) -1) << 8;
396 Debug (15, "OP_const1s(%ld)\n", (long) operand1);
401 if (operand1 & 0x8000)
402 operand1 |= ((unw_word_t) -1) << 16;
403 Debug (15, "OP_const2s(%ld)\n", (long) operand1);
408 if (operand1 & 0x80000000)
409 operand1 |= (((unw_word_t) -1) << 16) << 16;
410 Debug (15, "OP_const4s(%ld)\n", (long) operand1);
415 Debug (15, "OP_deref\n");
417 if ((ret = dwarf_readw (as, a, &tmp1, &tmp2, arg)) < 0)
422 case DW_OP_deref_size:
423 Debug (15, "OP_deref_size(%d)\n", (int) operand1);
428 Debug (1, "Unexpected DW_OP_deref_size size %d\n",
433 if ((ret = dwarf_readu8 (as, a, &tmp1, &u8, arg)) < 0)
439 if ((ret = dwarf_readu16 (as, a, &tmp1, &u16, arg)) < 0)
446 if ((ret = dwarf_readu32 (as, a, &tmp1, &u32, arg)) < 0)
451 if (dwarf_is_big_endian (as))
461 if ((ret = dwarf_readu64 (as, a, &tmp1, &u64, arg)) < 0)
466 if (dwarf_is_big_endian (as))
467 tmp2 >>= 64 - 8 * operand1;
469 tmp2 &= (~ (unw_word_t) 0) << (8 * operand1);
477 Debug (15, "OP_dup\n");
482 Debug (15, "OP_drop\n");
487 Debug (15, "OP_pick(%d)\n", (int) operand1);
488 push (pick (operand1));
492 Debug (15, "OP_over\n");
497 Debug (15, "OP_swap\n");
505 Debug (15, "OP_rot\n");
515 Debug (15, "OP_abs\n");
517 if (tmp1 & ((unw_word_t) 1 << (8 * dwarf_addr_size (as) - 1)))
523 Debug (15, "OP_and\n");
530 Debug (15, "OP_div\n");
534 tmp1 = sword (as, tmp2) / sword (as, tmp1);
539 Debug (15, "OP_minus\n");
547 Debug (15, "OP_mod\n");
556 Debug (15, "OP_mul\n");
565 Debug (15, "OP_neg\n");
570 Debug (15, "OP_not\n");
575 Debug (15, "OP_or\n");
582 Debug (15, "OP_plus\n");
588 case DW_OP_plus_uconst:
589 Debug (15, "OP_plus_uconst(%lu)\n", (unsigned long) operand1);
591 push (tmp1 + operand1);
595 Debug (15, "OP_shl\n");
602 Debug (15, "OP_shr\n");
609 Debug (15, "OP_shra\n");
612 push (sword (as, tmp2) >> tmp1);
616 Debug (15, "OP_xor\n");
623 Debug (15, "OP_le\n");
626 push (sword (as, tmp2) <= sword (as, tmp1));
630 Debug (15, "OP_ge\n");
633 push (sword (as, tmp2) >= sword (as, tmp1));
637 Debug (15, "OP_eq\n");
640 push (sword (as, tmp2) == sword (as, tmp1));
644 Debug (15, "OP_lt\n");
647 push (sword (as, tmp2) < sword (as, tmp1));
651 Debug (15, "OP_gt\n");
654 push (sword (as, tmp2) > sword (as, tmp1));
658 Debug (15, "OP_ne\n");
661 push (sword (as, tmp2) != sword (as, tmp1));
665 Debug (15, "OP_skip(%d)\n", (int16_t) operand1);
666 *addr += (int16_t) operand1;
670 Debug (15, "OP_skip(%d)\n", (int16_t) operand1);
673 *addr += (int16_t) operand1;
677 Debug (15, "OP_nop\n");
685 case DW_OP_push_object_address:
687 case DW_OP_xderef_size:
689 Debug (1, "Unexpected opcode 0x%x\n", opcode);
694 Debug (14, "final value = 0x%lx\n", (unsigned long) *valp);