1 /* DWARF 2 Expression Evaluator. 2 3 Copyright (C) 2001, 2002, 2003, 2005, 2007, 2008, 2009, 2010, 2011 4 Free Software Foundation, Inc. 5 6 Contributed by Daniel Berlin (dan@dberlin.org) 7 8 This file is part of GDB. 9 10 This program is free software; you can redistribute it and/or modify 11 it under the terms of the GNU General Public License as published by 12 the Free Software Foundation; either version 3 of the License, or 13 (at your option) any later version. 14 15 This program is distributed in the hope that it will be useful, 16 but WITHOUT ANY WARRANTY; without even the implied warranty of 17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 18 GNU General Public License for more details. 19 20 You should have received a copy of the GNU General Public License 21 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 22 23 #include "defs.h" 24 #include "symtab.h" 25 #include "gdbtypes.h" 26 #include "value.h" 27 #include "gdbcore.h" 28 #include "dwarf2.h" 29 #include "dwarf2expr.h" 30 #include "gdb_assert.h" 31 32 /* Local prototypes. */ 33 34 static void execute_stack_op (struct dwarf_expr_context *, 35 const gdb_byte *, const gdb_byte *); 36 37 /* Create a new context for the expression evaluator. */ 38 39 struct dwarf_expr_context * 40 new_dwarf_expr_context (void) 41 { 42 struct dwarf_expr_context *retval; 43 44 retval = xcalloc (1, sizeof (struct dwarf_expr_context)); 45 retval->stack_len = 0; 46 retval->stack_allocated = 10; 47 retval->stack = xmalloc (retval->stack_allocated 48 * sizeof (struct dwarf_stack_value)); 49 retval->num_pieces = 0; 50 retval->pieces = 0; 51 retval->max_recursion_depth = 0x100; 52 return retval; 53 } 54 55 /* Release the memory allocated to CTX. */ 56 57 void 58 free_dwarf_expr_context (struct dwarf_expr_context *ctx) 59 { 60 xfree (ctx->stack); 61 xfree (ctx->pieces); 62 xfree (ctx); 63 } 64 65 /* Helper for make_cleanup_free_dwarf_expr_context. */ 66 67 static void 68 free_dwarf_expr_context_cleanup (void *arg) 69 { 70 free_dwarf_expr_context (arg); 71 } 72 73 /* Return a cleanup that calls free_dwarf_expr_context. */ 74 75 struct cleanup * 76 make_cleanup_free_dwarf_expr_context (struct dwarf_expr_context *ctx) 77 { 78 return make_cleanup (free_dwarf_expr_context_cleanup, ctx); 79 } 80 81 /* Expand the memory allocated to CTX's stack to contain at least 82 NEED more elements than are currently used. */ 83 84 static void 85 dwarf_expr_grow_stack (struct dwarf_expr_context *ctx, size_t need) 86 { 87 if (ctx->stack_len + need > ctx->stack_allocated) 88 { 89 size_t newlen = ctx->stack_len + need + 10; 90 91 ctx->stack = xrealloc (ctx->stack, 92 newlen * sizeof (struct dwarf_stack_value)); 93 ctx->stack_allocated = newlen; 94 } 95 } 96 97 /* Push VALUE onto CTX's stack. */ 98 99 void 100 dwarf_expr_push (struct dwarf_expr_context *ctx, ULONGEST value, 101 int in_stack_memory) 102 { 103 struct dwarf_stack_value *v; 104 105 /* We keep all stack elements within the range defined by the 106 DWARF address size. */ 107 if (ctx->addr_size < sizeof (ULONGEST)) 108 value &= ((ULONGEST) 1 << (ctx->addr_size * HOST_CHAR_BIT)) - 1; 109 110 dwarf_expr_grow_stack (ctx, 1); 111 v = &ctx->stack[ctx->stack_len++]; 112 v->value = value; 113 v->in_stack_memory = in_stack_memory; 114 } 115 116 /* Pop the top item off of CTX's stack. */ 117 118 void 119 dwarf_expr_pop (struct dwarf_expr_context *ctx) 120 { 121 if (ctx->stack_len <= 0) 122 error (_("dwarf expression stack underflow")); 123 ctx->stack_len--; 124 } 125 126 /* Retrieve the N'th item on CTX's stack. */ 127 128 ULONGEST 129 dwarf_expr_fetch (struct dwarf_expr_context *ctx, int n) 130 { 131 if (ctx->stack_len <= n) 132 error (_("Asked for position %d of stack, " 133 "stack only has %d elements on it."), 134 n, ctx->stack_len); 135 return ctx->stack[ctx->stack_len - (1 + n)].value; 136 137 } 138 139 /* Retrieve the N'th item on CTX's stack, converted to an address. */ 140 141 CORE_ADDR 142 dwarf_expr_fetch_address (struct dwarf_expr_context *ctx, int n) 143 { 144 ULONGEST result = dwarf_expr_fetch (ctx, n); 145 146 /* For most architectures, calling extract_unsigned_integer() alone 147 is sufficient for extracting an address. However, some 148 architectures (e.g. MIPS) use signed addresses and using 149 extract_unsigned_integer() will not produce a correct 150 result. Make sure we invoke gdbarch_integer_to_address() 151 for those architectures which require it. */ 152 if (gdbarch_integer_to_address_p (ctx->gdbarch)) 153 { 154 enum bfd_endian byte_order = gdbarch_byte_order (ctx->gdbarch); 155 gdb_byte *buf = alloca (ctx->addr_size); 156 struct type *int_type; 157 158 switch (ctx->addr_size) 159 { 160 case 2: 161 int_type = builtin_type (ctx->gdbarch)->builtin_uint16; 162 break; 163 case 4: 164 int_type = builtin_type (ctx->gdbarch)->builtin_uint32; 165 break; 166 case 8: 167 int_type = builtin_type (ctx->gdbarch)->builtin_uint64; 168 break; 169 default: 170 internal_error (__FILE__, __LINE__, 171 _("Unsupported address size.\n")); 172 } 173 174 store_unsigned_integer (buf, ctx->addr_size, byte_order, result); 175 return gdbarch_integer_to_address (ctx->gdbarch, int_type, buf); 176 } 177 178 return (CORE_ADDR) result; 179 } 180 181 /* Retrieve the in_stack_memory flag of the N'th item on CTX's stack. */ 182 183 int 184 dwarf_expr_fetch_in_stack_memory (struct dwarf_expr_context *ctx, int n) 185 { 186 if (ctx->stack_len <= n) 187 error (_("Asked for position %d of stack, " 188 "stack only has %d elements on it."), 189 n, ctx->stack_len); 190 return ctx->stack[ctx->stack_len - (1 + n)].in_stack_memory; 191 192 } 193 194 /* Return true if the expression stack is empty. */ 195 196 static int 197 dwarf_expr_stack_empty_p (struct dwarf_expr_context *ctx) 198 { 199 return ctx->stack_len == 0; 200 } 201 202 /* Add a new piece to CTX's piece list. */ 203 static void 204 add_piece (struct dwarf_expr_context *ctx, ULONGEST size, ULONGEST offset) 205 { 206 struct dwarf_expr_piece *p; 207 208 ctx->num_pieces++; 209 210 ctx->pieces = xrealloc (ctx->pieces, 211 (ctx->num_pieces 212 * sizeof (struct dwarf_expr_piece))); 213 214 p = &ctx->pieces[ctx->num_pieces - 1]; 215 p->location = ctx->location; 216 p->size = size; 217 p->offset = offset; 218 219 if (p->location == DWARF_VALUE_LITERAL) 220 { 221 p->v.literal.data = ctx->data; 222 p->v.literal.length = ctx->len; 223 } 224 else if (dwarf_expr_stack_empty_p (ctx)) 225 { 226 p->location = DWARF_VALUE_OPTIMIZED_OUT; 227 /* Also reset the context's location, for our callers. This is 228 a somewhat strange approach, but this lets us avoid setting 229 the location to DWARF_VALUE_MEMORY in all the individual 230 cases in the evaluator. */ 231 ctx->location = DWARF_VALUE_OPTIMIZED_OUT; 232 } 233 else if (p->location == DWARF_VALUE_MEMORY) 234 { 235 p->v.mem.addr = dwarf_expr_fetch_address (ctx, 0); 236 p->v.mem.in_stack_memory = dwarf_expr_fetch_in_stack_memory (ctx, 0); 237 } 238 else if (p->location == DWARF_VALUE_IMPLICIT_POINTER) 239 { 240 p->v.ptr.die = ctx->len; 241 p->v.ptr.offset = (LONGEST) dwarf_expr_fetch (ctx, 0); 242 } 243 else 244 { 245 p->v.value = dwarf_expr_fetch (ctx, 0); 246 } 247 } 248 249 /* Evaluate the expression at ADDR (LEN bytes long) using the context 250 CTX. */ 251 252 void 253 dwarf_expr_eval (struct dwarf_expr_context *ctx, const gdb_byte *addr, 254 size_t len) 255 { 256 int old_recursion_depth = ctx->recursion_depth; 257 258 execute_stack_op (ctx, addr, addr + len); 259 260 /* CTX RECURSION_DEPTH becomes invalid if an exception was thrown here. */ 261 262 gdb_assert (ctx->recursion_depth == old_recursion_depth); 263 } 264 265 /* Decode the unsigned LEB128 constant at BUF into the variable pointed to 266 by R, and return the new value of BUF. Verify that it doesn't extend 267 past BUF_END. */ 268 269 const gdb_byte * 270 read_uleb128 (const gdb_byte *buf, const gdb_byte *buf_end, ULONGEST * r) 271 { 272 unsigned shift = 0; 273 ULONGEST result = 0; 274 gdb_byte byte; 275 276 while (1) 277 { 278 if (buf >= buf_end) 279 error (_("read_uleb128: Corrupted DWARF expression.")); 280 281 byte = *buf++; 282 result |= ((ULONGEST) (byte & 0x7f)) << shift; 283 if ((byte & 0x80) == 0) 284 break; 285 shift += 7; 286 } 287 *r = result; 288 return buf; 289 } 290 291 /* Decode the signed LEB128 constant at BUF into the variable pointed to 292 by R, and return the new value of BUF. Verify that it doesn't extend 293 past BUF_END. */ 294 295 const gdb_byte * 296 read_sleb128 (const gdb_byte *buf, const gdb_byte *buf_end, LONGEST * r) 297 { 298 unsigned shift = 0; 299 LONGEST result = 0; 300 gdb_byte byte; 301 302 while (1) 303 { 304 if (buf >= buf_end) 305 error (_("read_sleb128: Corrupted DWARF expression.")); 306 307 byte = *buf++; 308 result |= ((ULONGEST) (byte & 0x7f)) << shift; 309 shift += 7; 310 if ((byte & 0x80) == 0) 311 break; 312 } 313 if (shift < (sizeof (*r) * 8) && (byte & 0x40) != 0) 314 result |= -(1 << shift); 315 316 *r = result; 317 return buf; 318 } 319 320 321 /* Check that the current operator is either at the end of an 322 expression, or that it is followed by a composition operator. */ 323 324 void 325 dwarf_expr_require_composition (const gdb_byte *op_ptr, const gdb_byte *op_end, 326 const char *op_name) 327 { 328 /* It seems like DW_OP_GNU_uninit should be handled here. However, 329 it doesn't seem to make sense for DW_OP_*_value, and it was not 330 checked at the other place that this function is called. */ 331 if (op_ptr != op_end && *op_ptr != DW_OP_piece && *op_ptr != DW_OP_bit_piece) 332 error (_("DWARF-2 expression error: `%s' operations must be " 333 "used either alone or in conjuction with DW_OP_piece " 334 "or DW_OP_bit_piece."), 335 op_name); 336 } 337 338 /* The engine for the expression evaluator. Using the context in CTX, 339 evaluate the expression between OP_PTR and OP_END. */ 340 341 static void 342 execute_stack_op (struct dwarf_expr_context *ctx, 343 const gdb_byte *op_ptr, const gdb_byte *op_end) 344 { 345 #define sign_ext(x) ((LONGEST) (((x) ^ sign_bit) - sign_bit)) 346 ULONGEST sign_bit = (ctx->addr_size >= sizeof (ULONGEST) ? 0 347 : ((ULONGEST) 1) << (ctx->addr_size * 8 - 1)); 348 enum bfd_endian byte_order = gdbarch_byte_order (ctx->gdbarch); 349 350 ctx->location = DWARF_VALUE_MEMORY; 351 ctx->initialized = 1; /* Default is initialized. */ 352 353 if (ctx->recursion_depth > ctx->max_recursion_depth) 354 error (_("DWARF-2 expression error: Loop detected (%d)."), 355 ctx->recursion_depth); 356 ctx->recursion_depth++; 357 358 while (op_ptr < op_end) 359 { 360 enum dwarf_location_atom op = *op_ptr++; 361 ULONGEST result; 362 /* Assume the value is not in stack memory. 363 Code that knows otherwise sets this to 1. 364 Some arithmetic on stack addresses can probably be assumed to still 365 be a stack address, but we skip this complication for now. 366 This is just an optimization, so it's always ok to punt 367 and leave this as 0. */ 368 int in_stack_memory = 0; 369 ULONGEST uoffset, reg; 370 LONGEST offset; 371 372 switch (op) 373 { 374 case DW_OP_lit0: 375 case DW_OP_lit1: 376 case DW_OP_lit2: 377 case DW_OP_lit3: 378 case DW_OP_lit4: 379 case DW_OP_lit5: 380 case DW_OP_lit6: 381 case DW_OP_lit7: 382 case DW_OP_lit8: 383 case DW_OP_lit9: 384 case DW_OP_lit10: 385 case DW_OP_lit11: 386 case DW_OP_lit12: 387 case DW_OP_lit13: 388 case DW_OP_lit14: 389 case DW_OP_lit15: 390 case DW_OP_lit16: 391 case DW_OP_lit17: 392 case DW_OP_lit18: 393 case DW_OP_lit19: 394 case DW_OP_lit20: 395 case DW_OP_lit21: 396 case DW_OP_lit22: 397 case DW_OP_lit23: 398 case DW_OP_lit24: 399 case DW_OP_lit25: 400 case DW_OP_lit26: 401 case DW_OP_lit27: 402 case DW_OP_lit28: 403 case DW_OP_lit29: 404 case DW_OP_lit30: 405 case DW_OP_lit31: 406 result = op - DW_OP_lit0; 407 break; 408 409 case DW_OP_addr: 410 result = extract_unsigned_integer (op_ptr, 411 ctx->addr_size, byte_order); 412 op_ptr += ctx->addr_size; 413 /* Some versions of GCC emit DW_OP_addr before 414 DW_OP_GNU_push_tls_address. In this case the value is an 415 index, not an address. We don't support things like 416 branching between the address and the TLS op. */ 417 if (op_ptr >= op_end || *op_ptr != DW_OP_GNU_push_tls_address) 418 result += ctx->offset; 419 break; 420 421 case DW_OP_const1u: 422 result = extract_unsigned_integer (op_ptr, 1, byte_order); 423 op_ptr += 1; 424 break; 425 case DW_OP_const1s: 426 result = extract_signed_integer (op_ptr, 1, byte_order); 427 op_ptr += 1; 428 break; 429 case DW_OP_const2u: 430 result = extract_unsigned_integer (op_ptr, 2, byte_order); 431 op_ptr += 2; 432 break; 433 case DW_OP_const2s: 434 result = extract_signed_integer (op_ptr, 2, byte_order); 435 op_ptr += 2; 436 break; 437 case DW_OP_const4u: 438 result = extract_unsigned_integer (op_ptr, 4, byte_order); 439 op_ptr += 4; 440 break; 441 case DW_OP_const4s: 442 result = extract_signed_integer (op_ptr, 4, byte_order); 443 op_ptr += 4; 444 break; 445 case DW_OP_const8u: 446 result = extract_unsigned_integer (op_ptr, 8, byte_order); 447 op_ptr += 8; 448 break; 449 case DW_OP_const8s: 450 result = extract_signed_integer (op_ptr, 8, byte_order); 451 op_ptr += 8; 452 break; 453 case DW_OP_constu: 454 op_ptr = read_uleb128 (op_ptr, op_end, &uoffset); 455 result = uoffset; 456 break; 457 case DW_OP_consts: 458 op_ptr = read_sleb128 (op_ptr, op_end, &offset); 459 result = offset; 460 break; 461 462 /* The DW_OP_reg operations are required to occur alone in 463 location expressions. */ 464 case DW_OP_reg0: 465 case DW_OP_reg1: 466 case DW_OP_reg2: 467 case DW_OP_reg3: 468 case DW_OP_reg4: 469 case DW_OP_reg5: 470 case DW_OP_reg6: 471 case DW_OP_reg7: 472 case DW_OP_reg8: 473 case DW_OP_reg9: 474 case DW_OP_reg10: 475 case DW_OP_reg11: 476 case DW_OP_reg12: 477 case DW_OP_reg13: 478 case DW_OP_reg14: 479 case DW_OP_reg15: 480 case DW_OP_reg16: 481 case DW_OP_reg17: 482 case DW_OP_reg18: 483 case DW_OP_reg19: 484 case DW_OP_reg20: 485 case DW_OP_reg21: 486 case DW_OP_reg22: 487 case DW_OP_reg23: 488 case DW_OP_reg24: 489 case DW_OP_reg25: 490 case DW_OP_reg26: 491 case DW_OP_reg27: 492 case DW_OP_reg28: 493 case DW_OP_reg29: 494 case DW_OP_reg30: 495 case DW_OP_reg31: 496 if (op_ptr != op_end 497 && *op_ptr != DW_OP_piece 498 && *op_ptr != DW_OP_bit_piece 499 && *op_ptr != DW_OP_GNU_uninit) 500 error (_("DWARF-2 expression error: DW_OP_reg operations must be " 501 "used either alone or in conjuction with DW_OP_piece " 502 "or DW_OP_bit_piece.")); 503 504 result = op - DW_OP_reg0; 505 ctx->location = DWARF_VALUE_REGISTER; 506 break; 507 508 case DW_OP_regx: 509 op_ptr = read_uleb128 (op_ptr, op_end, ®); 510 dwarf_expr_require_composition (op_ptr, op_end, "DW_OP_regx"); 511 512 result = reg; 513 ctx->location = DWARF_VALUE_REGISTER; 514 break; 515 516 case DW_OP_implicit_value: 517 { 518 ULONGEST len; 519 520 op_ptr = read_uleb128 (op_ptr, op_end, &len); 521 if (op_ptr + len > op_end) 522 error (_("DW_OP_implicit_value: too few bytes available.")); 523 ctx->len = len; 524 ctx->data = op_ptr; 525 ctx->location = DWARF_VALUE_LITERAL; 526 op_ptr += len; 527 dwarf_expr_require_composition (op_ptr, op_end, 528 "DW_OP_implicit_value"); 529 } 530 goto no_push; 531 532 case DW_OP_stack_value: 533 ctx->location = DWARF_VALUE_STACK; 534 dwarf_expr_require_composition (op_ptr, op_end, "DW_OP_stack_value"); 535 goto no_push; 536 537 case DW_OP_GNU_implicit_pointer: 538 { 539 ULONGEST die; 540 LONGEST len; 541 542 /* The referred-to DIE. */ 543 ctx->len = extract_unsigned_integer (op_ptr, ctx->addr_size, 544 byte_order); 545 op_ptr += ctx->addr_size; 546 547 /* The byte offset into the data. */ 548 op_ptr = read_sleb128 (op_ptr, op_end, &len); 549 result = (ULONGEST) len; 550 551 ctx->location = DWARF_VALUE_IMPLICIT_POINTER; 552 dwarf_expr_require_composition (op_ptr, op_end, 553 "DW_OP_GNU_implicit_pointer"); 554 } 555 break; 556 557 case DW_OP_breg0: 558 case DW_OP_breg1: 559 case DW_OP_breg2: 560 case DW_OP_breg3: 561 case DW_OP_breg4: 562 case DW_OP_breg5: 563 case DW_OP_breg6: 564 case DW_OP_breg7: 565 case DW_OP_breg8: 566 case DW_OP_breg9: 567 case DW_OP_breg10: 568 case DW_OP_breg11: 569 case DW_OP_breg12: 570 case DW_OP_breg13: 571 case DW_OP_breg14: 572 case DW_OP_breg15: 573 case DW_OP_breg16: 574 case DW_OP_breg17: 575 case DW_OP_breg18: 576 case DW_OP_breg19: 577 case DW_OP_breg20: 578 case DW_OP_breg21: 579 case DW_OP_breg22: 580 case DW_OP_breg23: 581 case DW_OP_breg24: 582 case DW_OP_breg25: 583 case DW_OP_breg26: 584 case DW_OP_breg27: 585 case DW_OP_breg28: 586 case DW_OP_breg29: 587 case DW_OP_breg30: 588 case DW_OP_breg31: 589 { 590 op_ptr = read_sleb128 (op_ptr, op_end, &offset); 591 result = (ctx->read_reg) (ctx->baton, op - DW_OP_breg0); 592 result += offset; 593 } 594 break; 595 case DW_OP_bregx: 596 { 597 op_ptr = read_uleb128 (op_ptr, op_end, ®); 598 op_ptr = read_sleb128 (op_ptr, op_end, &offset); 599 result = (ctx->read_reg) (ctx->baton, reg); 600 result += offset; 601 } 602 break; 603 case DW_OP_fbreg: 604 { 605 const gdb_byte *datastart; 606 size_t datalen; 607 unsigned int before_stack_len; 608 609 op_ptr = read_sleb128 (op_ptr, op_end, &offset); 610 /* Rather than create a whole new context, we simply 611 record the stack length before execution, then reset it 612 afterwards, effectively erasing whatever the recursive 613 call put there. */ 614 before_stack_len = ctx->stack_len; 615 /* FIXME: cagney/2003-03-26: This code should be using 616 get_frame_base_address(), and then implement a dwarf2 617 specific this_base method. */ 618 (ctx->get_frame_base) (ctx->baton, &datastart, &datalen); 619 dwarf_expr_eval (ctx, datastart, datalen); 620 if (ctx->location == DWARF_VALUE_MEMORY) 621 result = dwarf_expr_fetch_address (ctx, 0); 622 else if (ctx->location == DWARF_VALUE_REGISTER) 623 result = (ctx->read_reg) (ctx->baton, dwarf_expr_fetch (ctx, 0)); 624 else 625 error (_("Not implemented: computing frame " 626 "base using explicit value operator")); 627 result = result + offset; 628 in_stack_memory = 1; 629 ctx->stack_len = before_stack_len; 630 ctx->location = DWARF_VALUE_MEMORY; 631 } 632 break; 633 634 case DW_OP_dup: 635 result = dwarf_expr_fetch (ctx, 0); 636 in_stack_memory = dwarf_expr_fetch_in_stack_memory (ctx, 0); 637 break; 638 639 case DW_OP_drop: 640 dwarf_expr_pop (ctx); 641 goto no_push; 642 643 case DW_OP_pick: 644 offset = *op_ptr++; 645 result = dwarf_expr_fetch (ctx, offset); 646 in_stack_memory = dwarf_expr_fetch_in_stack_memory (ctx, offset); 647 break; 648 649 case DW_OP_swap: 650 { 651 struct dwarf_stack_value t1, t2; 652 653 if (ctx->stack_len < 2) 654 error (_("Not enough elements for " 655 "DW_OP_swap. Need 2, have %d."), 656 ctx->stack_len); 657 t1 = ctx->stack[ctx->stack_len - 1]; 658 t2 = ctx->stack[ctx->stack_len - 2]; 659 ctx->stack[ctx->stack_len - 1] = t2; 660 ctx->stack[ctx->stack_len - 2] = t1; 661 goto no_push; 662 } 663 664 case DW_OP_over: 665 result = dwarf_expr_fetch (ctx, 1); 666 in_stack_memory = dwarf_expr_fetch_in_stack_memory (ctx, 1); 667 break; 668 669 case DW_OP_rot: 670 { 671 struct dwarf_stack_value t1, t2, t3; 672 673 if (ctx->stack_len < 3) 674 error (_("Not enough elements for " 675 "DW_OP_rot. Need 3, have %d."), 676 ctx->stack_len); 677 t1 = ctx->stack[ctx->stack_len - 1]; 678 t2 = ctx->stack[ctx->stack_len - 2]; 679 t3 = ctx->stack[ctx->stack_len - 3]; 680 ctx->stack[ctx->stack_len - 1] = t2; 681 ctx->stack[ctx->stack_len - 2] = t3; 682 ctx->stack[ctx->stack_len - 3] = t1; 683 goto no_push; 684 } 685 686 case DW_OP_deref: 687 case DW_OP_deref_size: 688 { 689 int addr_size = (op == DW_OP_deref ? ctx->addr_size : *op_ptr++); 690 gdb_byte *buf = alloca (addr_size); 691 CORE_ADDR addr = dwarf_expr_fetch_address (ctx, 0); 692 dwarf_expr_pop (ctx); 693 694 (ctx->read_mem) (ctx->baton, buf, addr, addr_size); 695 result = extract_unsigned_integer (buf, addr_size, byte_order); 696 break; 697 } 698 699 case DW_OP_abs: 700 case DW_OP_neg: 701 case DW_OP_not: 702 case DW_OP_plus_uconst: 703 /* Unary operations. */ 704 result = dwarf_expr_fetch (ctx, 0); 705 dwarf_expr_pop (ctx); 706 707 switch (op) 708 { 709 case DW_OP_abs: 710 if (sign_ext (result) < 0) 711 result = -result; 712 break; 713 case DW_OP_neg: 714 result = -result; 715 break; 716 case DW_OP_not: 717 result = ~result; 718 break; 719 case DW_OP_plus_uconst: 720 op_ptr = read_uleb128 (op_ptr, op_end, ®); 721 result += reg; 722 break; 723 } 724 break; 725 726 case DW_OP_and: 727 case DW_OP_div: 728 case DW_OP_minus: 729 case DW_OP_mod: 730 case DW_OP_mul: 731 case DW_OP_or: 732 case DW_OP_plus: 733 case DW_OP_shl: 734 case DW_OP_shr: 735 case DW_OP_shra: 736 case DW_OP_xor: 737 case DW_OP_le: 738 case DW_OP_ge: 739 case DW_OP_eq: 740 case DW_OP_lt: 741 case DW_OP_gt: 742 case DW_OP_ne: 743 { 744 /* Binary operations. */ 745 ULONGEST first, second; 746 747 second = dwarf_expr_fetch (ctx, 0); 748 dwarf_expr_pop (ctx); 749 750 first = dwarf_expr_fetch (ctx, 0); 751 dwarf_expr_pop (ctx); 752 753 switch (op) 754 { 755 case DW_OP_and: 756 result = first & second; 757 break; 758 case DW_OP_div: 759 if (!second) 760 error (_("Division by zero")); 761 result = sign_ext (first) / sign_ext (second); 762 break; 763 case DW_OP_minus: 764 result = first - second; 765 break; 766 case DW_OP_mod: 767 if (!second) 768 error (_("Division by zero")); 769 result = first % second; 770 break; 771 case DW_OP_mul: 772 result = first * second; 773 break; 774 case DW_OP_or: 775 result = first | second; 776 break; 777 case DW_OP_plus: 778 result = first + second; 779 break; 780 case DW_OP_shl: 781 result = first << second; 782 break; 783 case DW_OP_shr: 784 result = first >> second; 785 break; 786 case DW_OP_shra: 787 result = sign_ext (first) >> second; 788 break; 789 case DW_OP_xor: 790 result = first ^ second; 791 break; 792 case DW_OP_le: 793 result = sign_ext (first) <= sign_ext (second); 794 break; 795 case DW_OP_ge: 796 result = sign_ext (first) >= sign_ext (second); 797 break; 798 case DW_OP_eq: 799 result = sign_ext (first) == sign_ext (second); 800 break; 801 case DW_OP_lt: 802 result = sign_ext (first) < sign_ext (second); 803 break; 804 case DW_OP_gt: 805 result = sign_ext (first) > sign_ext (second); 806 break; 807 case DW_OP_ne: 808 result = sign_ext (first) != sign_ext (second); 809 break; 810 default: 811 internal_error (__FILE__, __LINE__, 812 _("Can't be reached.")); 813 } 814 } 815 break; 816 817 case DW_OP_call_frame_cfa: 818 result = (ctx->get_frame_cfa) (ctx->baton); 819 in_stack_memory = 1; 820 break; 821 822 case DW_OP_GNU_push_tls_address: 823 /* Variable is at a constant offset in the thread-local 824 storage block into the objfile for the current thread and 825 the dynamic linker module containing this expression. Here 826 we return returns the offset from that base. The top of the 827 stack has the offset from the beginning of the thread 828 control block at which the variable is located. Nothing 829 should follow this operator, so the top of stack would be 830 returned. */ 831 result = dwarf_expr_fetch (ctx, 0); 832 dwarf_expr_pop (ctx); 833 result = (ctx->get_tls_address) (ctx->baton, result); 834 break; 835 836 case DW_OP_skip: 837 offset = extract_signed_integer (op_ptr, 2, byte_order); 838 op_ptr += 2; 839 op_ptr += offset; 840 goto no_push; 841 842 case DW_OP_bra: 843 offset = extract_signed_integer (op_ptr, 2, byte_order); 844 op_ptr += 2; 845 if (dwarf_expr_fetch (ctx, 0) != 0) 846 op_ptr += offset; 847 dwarf_expr_pop (ctx); 848 goto no_push; 849 850 case DW_OP_nop: 851 goto no_push; 852 853 case DW_OP_piece: 854 { 855 ULONGEST size; 856 857 /* Record the piece. */ 858 op_ptr = read_uleb128 (op_ptr, op_end, &size); 859 add_piece (ctx, 8 * size, 0); 860 861 /* Pop off the address/regnum, and reset the location 862 type. */ 863 if (ctx->location != DWARF_VALUE_LITERAL 864 && ctx->location != DWARF_VALUE_OPTIMIZED_OUT) 865 dwarf_expr_pop (ctx); 866 ctx->location = DWARF_VALUE_MEMORY; 867 } 868 goto no_push; 869 870 case DW_OP_bit_piece: 871 { 872 ULONGEST size, offset; 873 874 /* Record the piece. */ 875 op_ptr = read_uleb128 (op_ptr, op_end, &size); 876 op_ptr = read_uleb128 (op_ptr, op_end, &offset); 877 add_piece (ctx, size, offset); 878 879 /* Pop off the address/regnum, and reset the location 880 type. */ 881 if (ctx->location != DWARF_VALUE_LITERAL 882 && ctx->location != DWARF_VALUE_OPTIMIZED_OUT) 883 dwarf_expr_pop (ctx); 884 ctx->location = DWARF_VALUE_MEMORY; 885 } 886 goto no_push; 887 888 case DW_OP_GNU_uninit: 889 if (op_ptr != op_end) 890 error (_("DWARF-2 expression error: DW_OP_GNU_uninit must always " 891 "be the very last op.")); 892 893 ctx->initialized = 0; 894 goto no_push; 895 896 case DW_OP_call2: 897 result = extract_unsigned_integer (op_ptr, 2, byte_order); 898 op_ptr += 2; 899 ctx->dwarf_call (ctx, result); 900 goto no_push; 901 902 case DW_OP_call4: 903 result = extract_unsigned_integer (op_ptr, 4, byte_order); 904 op_ptr += 4; 905 ctx->dwarf_call (ctx, result); 906 goto no_push; 907 908 case DW_OP_GNU_entry_value: 909 /* This operation is not yet supported by GDB. */ 910 ctx->location = DWARF_VALUE_OPTIMIZED_OUT; 911 ctx->stack_len = 0; 912 ctx->num_pieces = 0; 913 goto abort_expression; 914 915 default: 916 error (_("Unhandled dwarf expression opcode 0x%x"), op); 917 } 918 919 /* Most things push a result value. */ 920 dwarf_expr_push (ctx, result, in_stack_memory); 921 no_push: 922 ; 923 } 924 925 /* To simplify our main caller, if the result is an implicit 926 pointer, then make a pieced value. This is ok because we can't 927 have implicit pointers in contexts where pieces are invalid. */ 928 if (ctx->location == DWARF_VALUE_IMPLICIT_POINTER) 929 add_piece (ctx, 8 * ctx->addr_size, 0); 930 931 abort_expression: 932 ctx->recursion_depth--; 933 gdb_assert (ctx->recursion_depth >= 0); 934 #undef sign_ext 935 } 936