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