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> 4 5This file is part of libunwind. 6 7Permission is hereby granted, free of charge, to any person obtaining 8a copy of this software and associated documentation files (the 9"Software"), to deal in the Software without restriction, including 10without limitation the rights to use, copy, modify, merge, publish, 11distribute, sublicense, and/or sell copies of the Software, and to 12permit persons to whom the Software is furnished to do so, subject to 13the following conditions: 14 15The above copyright notice and this permission notice shall be 16included in all copies or substantial portions of the Software. 17 18THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 19EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 20MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 21NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE 22LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION 23OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION 24WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ 25 26#include "dwarf_i.h" 27#include "libunwind_i.h" 28 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 34 35#define NUM_OPERANDS(signature) (((signature) >> 6) & 0x3) 36#define OPND1_TYPE(signature) (((signature) >> 3) & 0x7) 37#define OPND2_TYPE(signature) (((signature) >> 0) & 0x7) 38 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) 42 43#define VAL8 0x0 44#define VAL16 0x1 45#define VAL32 0x2 46#define VAL64 0x3 47#define ULEB128 0x4 48#define SLEB128 0x5 49#define OFFSET 0x6 /* 32-bit offset for 32-bit DWARF, 64-bit otherwise */ 50#define ADDR 0x7 /* Machine address. */ 51 52static const uint8_t operands[256] = 53 { 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) 108 }; 109 110static inline unw_sword_t 111sword (unw_addr_space_t as, unw_word_t val) 112{ 113 switch (dwarf_addr_size (as)) 114 { 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; 119 default: abort (); 120 } 121} 122 123static inline unw_word_t 124read_operand (unw_addr_space_t as, unw_accessors_t *a, 125 unw_word_t *addr, int operand_type, unw_word_t *val, void *arg) 126{ 127 uint8_t u8; 128 uint16_t u16; 129 uint32_t u32; 130 uint64_t u64; 131 int ret; 132 133 if (operand_type == ADDR) 134 switch (dwarf_addr_size (as)) 135 { 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; 140 default: abort (); 141 } 142 143 switch (operand_type) 144 { 145 case VAL8: 146 ret = dwarf_readu8 (as, a, addr, &u8, arg); 147 if (ret < 0) 148 return ret; 149 *val = u8; 150 break; 151 152 case VAL16: 153 ret = dwarf_readu16 (as, a, addr, &u16, arg); 154 if (ret < 0) 155 return ret; 156 *val = u16; 157 break; 158 159 case VAL32: 160 ret = dwarf_readu32 (as, a, addr, &u32, arg); 161 if (ret < 0) 162 return ret; 163 *val = u32; 164 break; 165 166 case VAL64: 167 ret = dwarf_readu64 (as, a, addr, &u64, arg); 168 if (ret < 0) 169 return ret; 170 *val = u64; 171 break; 172 173 case ULEB128: 174 ret = dwarf_read_uleb128 (as, a, addr, val, arg); 175 break; 176 177 case SLEB128: 178 ret = dwarf_read_sleb128 (as, a, addr, val, arg); 179 break; 180 181 case OFFSET: /* only used by DW_OP_call_ref, which we don't implement */ 182 default: 183 Debug (1, "Unexpected operand type %d\n", operand_type); 184 ret = -UNW_EINVAL; 185 } 186 return ret; 187} 188 189HIDDEN int 190dwarf_eval_expr (struct dwarf_cursor *c, unw_word_t *addr, unw_word_t len, 191 unw_word_t *valp, int *is_register) 192{ 193 unw_word_t operand1 = 0, operand2 = 0, tmp1, tmp2, tmp3, end_addr; 194 uint8_t opcode, operands_signature, u8; 195 unw_addr_space_t as; 196 unw_accessors_t *a; 197 void *arg; 198 unw_word_t stack[MAX_EXPR_STACK_SIZE]; 199 unsigned int tos = 0; 200 uint16_t u16; 201 uint32_t u32; 202 uint64_t u64; 203 int ret; 204# define pop() \ 205({ \ 206 if ((tos - 1) >= MAX_EXPR_STACK_SIZE) \ 207 { \ 208 Debug (1, "Stack underflow\n"); \ 209 return -UNW_EINVAL; \ 210 } \ 211 stack[--tos]; \ 212}) 213# define push(x) \ 214do { \ 215 if (tos >= MAX_EXPR_STACK_SIZE) \ 216 { \ 217 Debug (1, "Stack overflow\n"); \ 218 return -UNW_EINVAL; \ 219 } \ 220 stack[tos++] = (x); \ 221} while (0) 222# define pick(n) \ 223({ \ 224 unsigned int _index = tos - 1 - (n); \ 225 if (_index >= MAX_EXPR_STACK_SIZE) \ 226 { \ 227 Debug (1, "Out-of-stack pick\n"); \ 228 return -UNW_EINVAL; \ 229 } \ 230 stack[_index]; \ 231}) 232 233 as = c->as; 234 arg = c->as_arg; 235 a = unw_get_accessors (as); 236 end_addr = *addr + len; 237 *is_register = 0; 238 239 Debug (14, "len=%lu, pushing cfa=0x%lx\n", 240 (unsigned long) len, (unsigned long) c->cfa); 241 242 push (c->cfa); /* push current CFA as required by DWARF spec */ 243 244 while (*addr < end_addr) 245 { 246 if ((ret = dwarf_readu8 (as, a, addr, &opcode, arg)) < 0) 247 return ret; 248 249 operands_signature = operands[opcode]; 250 251 if (unlikely (NUM_OPERANDS (operands_signature) > 0)) 252 { 253 if ((ret = read_operand (as, a, addr, 254 OPND1_TYPE (operands_signature), 255 &operand1, arg)) < 0) 256 return ret; 257 if (NUM_OPERANDS (operands_signature) > 1) 258 if ((ret = read_operand (as, a, addr, 259 OPND2_TYPE (operands_signature), 260 &operand2, arg)) < 0) 261 return ret; 262 } 263 264 switch ((dwarf_expr_op_t) opcode) 265 { 266 case DW_OP_lit0: case DW_OP_lit1: case DW_OP_lit2: 267 case DW_OP_lit3: case DW_OP_lit4: case DW_OP_lit5: 268 case DW_OP_lit6: case DW_OP_lit7: case DW_OP_lit8: 269 case DW_OP_lit9: case DW_OP_lit10: case DW_OP_lit11: 270 case DW_OP_lit12: case DW_OP_lit13: case DW_OP_lit14: 271 case DW_OP_lit15: case DW_OP_lit16: case DW_OP_lit17: 272 case DW_OP_lit18: case DW_OP_lit19: case DW_OP_lit20: 273 case DW_OP_lit21: case DW_OP_lit22: case DW_OP_lit23: 274 case DW_OP_lit24: case DW_OP_lit25: case DW_OP_lit26: 275 case DW_OP_lit27: case DW_OP_lit28: case DW_OP_lit29: 276 case DW_OP_lit30: case DW_OP_lit31: 277 Debug (15, "OP_lit(%d)\n", (int) opcode - DW_OP_lit0); 278 push (opcode - DW_OP_lit0); 279 break; 280 281 case DW_OP_breg0: case DW_OP_breg1: case DW_OP_breg2: 282 case DW_OP_breg3: case DW_OP_breg4: case DW_OP_breg5: 283 case DW_OP_breg6: case DW_OP_breg7: case DW_OP_breg8: 284 case DW_OP_breg9: case DW_OP_breg10: case DW_OP_breg11: 285 case DW_OP_breg12: case DW_OP_breg13: case DW_OP_breg14: 286 case DW_OP_breg15: case DW_OP_breg16: case DW_OP_breg17: 287 case DW_OP_breg18: case DW_OP_breg19: case DW_OP_breg20: 288 case DW_OP_breg21: case DW_OP_breg22: case DW_OP_breg23: 289 case DW_OP_breg24: case DW_OP_breg25: case DW_OP_breg26: 290 case DW_OP_breg27: case DW_OP_breg28: case DW_OP_breg29: 291 case DW_OP_breg30: case DW_OP_breg31: 292 Debug (15, "OP_breg(r%d,0x%lx)\n", 293 (int) opcode - DW_OP_breg0, (unsigned long) operand1); 294 if ((ret = unw_get_reg (dwarf_to_cursor (c), 295 dwarf_to_unw_regnum (opcode - DW_OP_breg0), 296 &tmp1)) < 0) 297 return ret; 298 push (tmp1 + operand1); 299 break; 300 301 case DW_OP_bregx: 302 Debug (15, "OP_bregx(r%d,0x%lx)\n", 303 (int) operand1, (unsigned long) operand2); 304 if ((ret = unw_get_reg (dwarf_to_cursor (c), 305 dwarf_to_unw_regnum (operand1), &tmp1)) < 0) 306 return ret; 307 push (tmp1 + operand2); 308 break; 309 310 case DW_OP_reg0: case DW_OP_reg1: case DW_OP_reg2: 311 case DW_OP_reg3: case DW_OP_reg4: case DW_OP_reg5: 312 case DW_OP_reg6: case DW_OP_reg7: case DW_OP_reg8: 313 case DW_OP_reg9: case DW_OP_reg10: case DW_OP_reg11: 314 case DW_OP_reg12: case DW_OP_reg13: case DW_OP_reg14: 315 case DW_OP_reg15: case DW_OP_reg16: case DW_OP_reg17: 316 case DW_OP_reg18: case DW_OP_reg19: case DW_OP_reg20: 317 case DW_OP_reg21: case DW_OP_reg22: case DW_OP_reg23: 318 case DW_OP_reg24: case DW_OP_reg25: case DW_OP_reg26: 319 case DW_OP_reg27: case DW_OP_reg28: case DW_OP_reg29: 320 case DW_OP_reg30: case DW_OP_reg31: 321 Debug (15, "OP_reg(r%d)\n", (int) opcode - DW_OP_reg0); 322 *valp = dwarf_to_unw_regnum (opcode - DW_OP_reg0); 323 *is_register = 1; 324 return 0; 325 326 case DW_OP_regx: 327 Debug (15, "OP_regx(r%d)\n", (int) operand1); 328 *valp = dwarf_to_unw_regnum (operand1); 329 *is_register = 1; 330 return 0; 331 332 case DW_OP_addr: 333 case DW_OP_const1u: 334 case DW_OP_const2u: 335 case DW_OP_const4u: 336 case DW_OP_const8u: 337 case DW_OP_constu: 338 case DW_OP_const8s: 339 case DW_OP_consts: 340 Debug (15, "OP_const(0x%lx)\n", (unsigned long) operand1); 341 push (operand1); 342 break; 343 344 case DW_OP_const1s: 345 if (operand1 & 0x80) 346 operand1 |= ((unw_word_t) -1) << 8; 347 Debug (15, "OP_const1s(%ld)\n", (long) operand1); 348 push (operand1); 349 break; 350 351 case DW_OP_const2s: 352 if (operand1 & 0x8000) 353 operand1 |= ((unw_word_t) -1) << 16; 354 Debug (15, "OP_const2s(%ld)\n", (long) operand1); 355 push (operand1); 356 break; 357 358 case DW_OP_const4s: 359 if (operand1 & 0x80000000) 360 operand1 |= (((unw_word_t) -1) << 16) << 16; 361 Debug (15, "OP_const4s(%ld)\n", (long) operand1); 362 push (operand1); 363 break; 364 365 case DW_OP_deref: 366 Debug (15, "OP_deref\n"); 367 tmp1 = pop (); 368 if ((ret = dwarf_readw (as, a, &tmp1, &tmp2, arg)) < 0) 369 return ret; 370 push (tmp2); 371 break; 372 373 case DW_OP_deref_size: 374 Debug (15, "OP_deref_size(%d)\n", (int) operand1); 375 tmp1 = pop (); 376 switch (operand1) 377 { 378 default: 379 Debug (1, "Unexpected DW_OP_deref_size size %d\n", 380 (int) operand1); 381 return -UNW_EINVAL; 382 383 case 1: 384 if ((ret = dwarf_readu8 (as, a, &tmp1, &u8, arg)) < 0) 385 return ret; 386 tmp2 = u8; 387 break; 388 389 case 2: 390 if ((ret = dwarf_readu16 (as, a, &tmp1, &u16, arg)) < 0) 391 return ret; 392 tmp2 = u16; 393 break; 394 395 case 3: 396 case 4: 397 if ((ret = dwarf_readu32 (as, a, &tmp1, &u32, arg)) < 0) 398 return ret; 399 tmp2 = u32; 400 if (operand1 == 3) 401 { 402 if (dwarf_is_big_endian (as)) 403 tmp2 >>= 8; 404 else 405 tmp2 &= 0xffffff; 406 } 407 break; 408 case 5: 409 case 6: 410 case 7: 411 case 8: 412 if ((ret = dwarf_readu64 (as, a, &tmp1, &u64, arg)) < 0) 413 return ret; 414 tmp2 = u64; 415 if (operand1 != 8) 416 { 417 if (dwarf_is_big_endian (as)) 418 tmp2 >>= 64 - 8 * operand1; 419 else 420 tmp2 &= (~ (unw_word_t) 0) << (8 * operand1); 421 } 422 break; 423 } 424 push (tmp2); 425 break; 426 427 case DW_OP_dup: 428 Debug (15, "OP_dup\n"); 429 push (pick (0)); 430 break; 431 432 case DW_OP_drop: 433 Debug (15, "OP_drop\n"); 434 (void) pop (); 435 break; 436 437 case DW_OP_pick: 438 Debug (15, "OP_pick(%d)\n", (int) operand1); 439 push (pick (operand1)); 440 break; 441 442 case DW_OP_over: 443 Debug (15, "OP_over\n"); 444 push (pick (1)); 445 break; 446 447 case DW_OP_swap: 448 Debug (15, "OP_swap\n"); 449 tmp1 = pop (); 450 tmp2 = pop (); 451 push (tmp1); 452 push (tmp2); 453 break; 454 455 case DW_OP_rot: 456 Debug (15, "OP_rot\n"); 457 tmp1 = pop (); 458 tmp2 = pop (); 459 tmp3 = pop (); 460 push (tmp1); 461 push (tmp3); 462 push (tmp2); 463 break; 464 465 case DW_OP_abs: 466 Debug (15, "OP_abs\n"); 467 tmp1 = pop (); 468 if (tmp1 & ((unw_word_t) 1 << (8 * dwarf_addr_size (as) - 1))) 469 tmp1 = -tmp1; 470 push (tmp1); 471 break; 472 473 case DW_OP_and: 474 Debug (15, "OP_and\n"); 475 tmp1 = pop (); 476 tmp2 = pop (); 477 push (tmp1 & tmp2); 478 break; 479 480 case DW_OP_div: 481 Debug (15, "OP_div\n"); 482 tmp1 = pop (); 483 tmp2 = pop (); 484 if (tmp1) 485 tmp1 = sword (as, tmp2) / sword (as, tmp1); 486 push (tmp1); 487 break; 488 489 case DW_OP_minus: 490 Debug (15, "OP_minus\n"); 491 tmp1 = pop (); 492 tmp2 = pop (); 493 tmp1 = tmp2 - tmp1; 494 push (tmp1); 495 break; 496 497 case DW_OP_mod: 498 Debug (15, "OP_mod\n"); 499 tmp1 = pop (); 500 tmp2 = pop (); 501 if (tmp1) 502 tmp1 = tmp2 % tmp1; 503 push (tmp1); 504 break; 505 506 case DW_OP_mul: 507 Debug (15, "OP_mul\n"); 508 tmp1 = pop (); 509 tmp2 = pop (); 510 if (tmp1) 511 tmp1 = tmp2 * tmp1; 512 push (tmp1); 513 break; 514 515 case DW_OP_neg: 516 Debug (15, "OP_neg\n"); 517 push (-pop ()); 518 break; 519 520 case DW_OP_not: 521 Debug (15, "OP_not\n"); 522 push (~pop ()); 523 break; 524 525 case DW_OP_or: 526 Debug (15, "OP_or\n"); 527 tmp1 = pop (); 528 tmp2 = pop (); 529 push (tmp1 | tmp2); 530 break; 531 532 case DW_OP_plus: 533 Debug (15, "OP_plus\n"); 534 tmp1 = pop (); 535 tmp2 = pop (); 536 push (tmp1 + tmp2); 537 break; 538 539 case DW_OP_plus_uconst: 540 Debug (15, "OP_plus_uconst(%lu)\n", (unsigned long) operand1); 541 tmp1 = pop (); 542 push (tmp1 + operand1); 543 break; 544 545 case DW_OP_shl: 546 Debug (15, "OP_shl\n"); 547 tmp1 = pop (); 548 tmp2 = pop (); 549 push (tmp2 << tmp1); 550 break; 551 552 case DW_OP_shr: 553 Debug (15, "OP_shr\n"); 554 tmp1 = pop (); 555 tmp2 = pop (); 556 push (tmp2 >> tmp1); 557 break; 558 559 case DW_OP_shra: 560 Debug (15, "OP_shra\n"); 561 tmp1 = pop (); 562 tmp2 = pop (); 563 push (sword (as, tmp2) >> tmp1); 564 break; 565 566 case DW_OP_xor: 567 Debug (15, "OP_xor\n"); 568 tmp1 = pop (); 569 tmp2 = pop (); 570 push (tmp1 ^ tmp2); 571 break; 572 573 case DW_OP_le: 574 Debug (15, "OP_le\n"); 575 tmp1 = pop (); 576 tmp2 = pop (); 577 push (sword (as, tmp2) <= sword (as, tmp1)); 578 break; 579 580 case DW_OP_ge: 581 Debug (15, "OP_ge\n"); 582 tmp1 = pop (); 583 tmp2 = pop (); 584 push (sword (as, tmp2) >= sword (as, tmp1)); 585 break; 586 587 case DW_OP_eq: 588 Debug (15, "OP_eq\n"); 589 tmp1 = pop (); 590 tmp2 = pop (); 591 push (sword (as, tmp2) == sword (as, tmp1)); 592 break; 593 594 case DW_OP_lt: 595 Debug (15, "OP_lt\n"); 596 tmp1 = pop (); 597 tmp2 = pop (); 598 push (sword (as, tmp2) < sword (as, tmp1)); 599 break; 600 601 case DW_OP_gt: 602 Debug (15, "OP_gt\n"); 603 tmp1 = pop (); 604 tmp2 = pop (); 605 push (sword (as, tmp2) > sword (as, tmp1)); 606 break; 607 608 case DW_OP_ne: 609 Debug (15, "OP_ne\n"); 610 tmp1 = pop (); 611 tmp2 = pop (); 612 push (sword (as, tmp2) != sword (as, tmp1)); 613 break; 614 615 case DW_OP_skip: 616 Debug (15, "OP_skip(%d)\n", (int16_t) operand1); 617 *addr += (int16_t) operand1; 618 break; 619 620 case DW_OP_bra: 621 Debug (15, "OP_skip(%d)\n", (int16_t) operand1); 622 tmp1 = pop (); 623 if (tmp1) 624 *addr += (int16_t) operand1; 625 break; 626 627 case DW_OP_nop: 628 Debug (15, "OP_nop\n"); 629 break; 630 631 case DW_OP_call2: 632 case DW_OP_call4: 633 case DW_OP_call_ref: 634 case DW_OP_fbreg: 635 case DW_OP_piece: 636 case DW_OP_push_object_address: 637 case DW_OP_xderef: 638 case DW_OP_xderef_size: 639 default: 640 Debug (1, "Unexpected opcode 0x%x\n", opcode); 641 return -UNW_EINVAL; 642 } 643 } 644 *valp = pop (); 645 Debug (14, "final value = 0x%lx\n", (unsigned long) *valp); 646 return 0; 647} 648