1/* DWARF 2 Expression Evaluator. 2 3 Copyright (C) 2001, 2002, 2003, 2005, 2007 Free Software Foundation, Inc. 4 5 Contributed by Daniel Berlin (dan@dberlin.org) 6 7 This file is part of GDB. 8 9 This program is free software; you can redistribute it and/or modify 10 it under the terms of the GNU General Public License as published by 11 the Free Software Foundation; either version 3 of the License, or 12 (at your option) any later version. 13 14 This program is distributed in the hope that it will be useful, 15 but WITHOUT ANY WARRANTY; without even the implied warranty of 16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17 GNU General Public License for more details. 18 19 You should have received a copy of the GNU General Public License 20 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 21 22#include "defs.h" 23#include "symtab.h" 24#include "gdbtypes.h" 25#include "value.h" 26#include "gdbcore.h" 27#include "elf/dwarf2.h" 28#include "dwarf2expr.h" 29 30/* Local prototypes. */ 31 32static void execute_stack_op (struct dwarf_expr_context *, 33 gdb_byte *, gdb_byte *); 34static struct type *unsigned_address_type (void); 35 36/* Create a new context for the expression evaluator. */ 37 38struct dwarf_expr_context * 39new_dwarf_expr_context (void) 40{ 41 struct dwarf_expr_context *retval; 42 retval = xcalloc (1, sizeof (struct dwarf_expr_context)); 43 retval->stack_len = 0; 44 retval->stack_allocated = 10; 45 retval->stack = xmalloc (retval->stack_allocated * sizeof (CORE_ADDR)); 46 retval->num_pieces = 0; 47 retval->pieces = 0; 48 return retval; 49} 50 51/* Release the memory allocated to CTX. */ 52 53void 54free_dwarf_expr_context (struct dwarf_expr_context *ctx) 55{ 56 xfree (ctx->stack); 57 xfree (ctx->pieces); 58 xfree (ctx); 59} 60 61/* Expand the memory allocated to CTX's stack to contain at least 62 NEED more elements than are currently used. */ 63 64static void 65dwarf_expr_grow_stack (struct dwarf_expr_context *ctx, size_t need) 66{ 67 if (ctx->stack_len + need > ctx->stack_allocated) 68 { 69 size_t newlen = ctx->stack_len + need + 10; 70 ctx->stack = xrealloc (ctx->stack, 71 newlen * sizeof (CORE_ADDR)); 72 ctx->stack_allocated = newlen; 73 } 74} 75 76/* Push VALUE onto CTX's stack. */ 77 78void 79dwarf_expr_push (struct dwarf_expr_context *ctx, CORE_ADDR value) 80{ 81 dwarf_expr_grow_stack (ctx, 1); 82 ctx->stack[ctx->stack_len++] = value; 83} 84 85/* Pop the top item off of CTX's stack. */ 86 87void 88dwarf_expr_pop (struct dwarf_expr_context *ctx) 89{ 90 if (ctx->stack_len <= 0) 91 error (_("dwarf expression stack underflow")); 92 ctx->stack_len--; 93} 94 95/* Retrieve the N'th item on CTX's stack. */ 96 97CORE_ADDR 98dwarf_expr_fetch (struct dwarf_expr_context *ctx, int n) 99{ 100 if (ctx->stack_len <= n) 101 error (_("Asked for position %d of stack, stack only has %d elements on it."), 102 n, ctx->stack_len); 103 return ctx->stack[ctx->stack_len - (1 + n)]; 104 105} 106 107/* Add a new piece to CTX's piece list. */ 108static void 109add_piece (struct dwarf_expr_context *ctx, 110 int in_reg, CORE_ADDR value, ULONGEST size) 111{ 112 struct dwarf_expr_piece *p; 113 114 ctx->num_pieces++; 115 116 if (ctx->pieces) 117 ctx->pieces = xrealloc (ctx->pieces, 118 (ctx->num_pieces 119 * sizeof (struct dwarf_expr_piece))); 120 else 121 ctx->pieces = xmalloc (ctx->num_pieces 122 * sizeof (struct dwarf_expr_piece)); 123 124 p = &ctx->pieces[ctx->num_pieces - 1]; 125 p->in_reg = in_reg; 126 p->value = value; 127 p->size = size; 128} 129 130/* Evaluate the expression at ADDR (LEN bytes long) using the context 131 CTX. */ 132 133void 134dwarf_expr_eval (struct dwarf_expr_context *ctx, gdb_byte *addr, size_t len) 135{ 136 execute_stack_op (ctx, addr, addr + len); 137} 138 139/* Decode the unsigned LEB128 constant at BUF into the variable pointed to 140 by R, and return the new value of BUF. Verify that it doesn't extend 141 past BUF_END. */ 142 143gdb_byte * 144read_uleb128 (gdb_byte *buf, gdb_byte *buf_end, ULONGEST * r) 145{ 146 unsigned shift = 0; 147 ULONGEST result = 0; 148 gdb_byte byte; 149 150 while (1) 151 { 152 if (buf >= buf_end) 153 error (_("read_uleb128: Corrupted DWARF expression.")); 154 155 byte = *buf++; 156 result |= (byte & 0x7f) << shift; 157 if ((byte & 0x80) == 0) 158 break; 159 shift += 7; 160 } 161 *r = result; 162 return buf; 163} 164 165/* Decode the signed LEB128 constant at BUF into the variable pointed to 166 by R, and return the new value of BUF. Verify that it doesn't extend 167 past BUF_END. */ 168 169gdb_byte * 170read_sleb128 (gdb_byte *buf, gdb_byte *buf_end, LONGEST * r) 171{ 172 unsigned shift = 0; 173 LONGEST result = 0; 174 gdb_byte byte; 175 176 while (1) 177 { 178 if (buf >= buf_end) 179 error (_("read_sleb128: Corrupted DWARF expression.")); 180 181 byte = *buf++; 182 result |= (byte & 0x7f) << shift; 183 shift += 7; 184 if ((byte & 0x80) == 0) 185 break; 186 } 187 if (shift < (sizeof (*r) * 8) && (byte & 0x40) != 0) 188 result |= -(1 << shift); 189 190 *r = result; 191 return buf; 192} 193 194/* Read an address from BUF, and verify that it doesn't extend past 195 BUF_END. The address is returned, and *BYTES_READ is set to the 196 number of bytes read from BUF. */ 197 198CORE_ADDR 199dwarf2_read_address (gdb_byte *buf, gdb_byte *buf_end, int *bytes_read) 200{ 201 CORE_ADDR result; 202 203 if (buf_end - buf < gdbarch_addr_bit (current_gdbarch) / TARGET_CHAR_BIT) 204 error (_("dwarf2_read_address: Corrupted DWARF expression.")); 205 206 *bytes_read = gdbarch_addr_bit (current_gdbarch) / TARGET_CHAR_BIT; 207 208 /* For most architectures, calling extract_unsigned_integer() alone 209 is sufficient for extracting an address. However, some 210 architectures (e.g. MIPS) use signed addresses and using 211 extract_unsigned_integer() will not produce a correct 212 result. Turning the unsigned integer into a value and then 213 decomposing that value as an address will cause 214 gdbarch_integer_to_address() to be invoked for those 215 architectures which require it. Thus, using value_as_address() 216 will produce the correct result for both types of architectures. 217 218 One concern regarding the use of values for this purpose is 219 efficiency. Obviously, these extra calls will take more time to 220 execute and creating a value takes more space, space which will 221 have to be garbage collected at a later time. If constructing 222 and then decomposing a value for this purpose proves to be too 223 inefficient, then gdbarch_integer_to_address() can be called 224 directly. 225 226 The use of `unsigned_address_type' in the code below refers to 227 the type of buf and has no bearing on the signedness of the 228 address being returned. */ 229 230 result = value_as_address (value_from_longest 231 (unsigned_address_type (), 232 extract_unsigned_integer 233 (buf, 234 gdbarch_addr_bit (current_gdbarch) 235 / TARGET_CHAR_BIT))); 236 237 return result; 238} 239 240/* Return the type of an address, for unsigned arithmetic. */ 241 242static struct type * 243unsigned_address_type (void) 244{ 245 switch (gdbarch_addr_bit (current_gdbarch) / TARGET_CHAR_BIT) 246 { 247 case 2: 248 return builtin_type_uint16; 249 case 4: 250 return builtin_type_uint32; 251 case 8: 252 return builtin_type_uint64; 253 default: 254 internal_error (__FILE__, __LINE__, 255 _("Unsupported address size.\n")); 256 } 257} 258 259/* Return the type of an address, for signed arithmetic. */ 260 261static struct type * 262signed_address_type (void) 263{ 264 switch (gdbarch_addr_bit (current_gdbarch) / TARGET_CHAR_BIT) 265 { 266 case 2: 267 return builtin_type_int16; 268 case 4: 269 return builtin_type_int32; 270 case 8: 271 return builtin_type_int64; 272 default: 273 internal_error (__FILE__, __LINE__, 274 _("Unsupported address size.\n")); 275 } 276} 277 278/* The engine for the expression evaluator. Using the context in CTX, 279 evaluate the expression between OP_PTR and OP_END. */ 280 281static void 282execute_stack_op (struct dwarf_expr_context *ctx, 283 gdb_byte *op_ptr, gdb_byte *op_end) 284{ 285 ctx->in_reg = 0; 286 ctx->initialized = 1; /* Default is initialized. */ 287 288 while (op_ptr < op_end) 289 { 290 enum dwarf_location_atom op = *op_ptr++; 291 CORE_ADDR result; 292 ULONGEST uoffset, reg; 293 LONGEST offset; 294 int bytes_read; 295 296 switch (op) 297 { 298 case DW_OP_lit0: 299 case DW_OP_lit1: 300 case DW_OP_lit2: 301 case DW_OP_lit3: 302 case DW_OP_lit4: 303 case DW_OP_lit5: 304 case DW_OP_lit6: 305 case DW_OP_lit7: 306 case DW_OP_lit8: 307 case DW_OP_lit9: 308 case DW_OP_lit10: 309 case DW_OP_lit11: 310 case DW_OP_lit12: 311 case DW_OP_lit13: 312 case DW_OP_lit14: 313 case DW_OP_lit15: 314 case DW_OP_lit16: 315 case DW_OP_lit17: 316 case DW_OP_lit18: 317 case DW_OP_lit19: 318 case DW_OP_lit20: 319 case DW_OP_lit21: 320 case DW_OP_lit22: 321 case DW_OP_lit23: 322 case DW_OP_lit24: 323 case DW_OP_lit25: 324 case DW_OP_lit26: 325 case DW_OP_lit27: 326 case DW_OP_lit28: 327 case DW_OP_lit29: 328 case DW_OP_lit30: 329 case DW_OP_lit31: 330 result = op - DW_OP_lit0; 331 break; 332 333 case DW_OP_addr: 334 result = dwarf2_read_address (op_ptr, op_end, &bytes_read); 335 op_ptr += bytes_read; 336 break; 337 338 case DW_OP_const1u: 339 result = extract_unsigned_integer (op_ptr, 1); 340 op_ptr += 1; 341 break; 342 case DW_OP_const1s: 343 result = extract_signed_integer (op_ptr, 1); 344 op_ptr += 1; 345 break; 346 case DW_OP_const2u: 347 result = extract_unsigned_integer (op_ptr, 2); 348 op_ptr += 2; 349 break; 350 case DW_OP_const2s: 351 result = extract_signed_integer (op_ptr, 2); 352 op_ptr += 2; 353 break; 354 case DW_OP_const4u: 355 result = extract_unsigned_integer (op_ptr, 4); 356 op_ptr += 4; 357 break; 358 case DW_OP_const4s: 359 result = extract_signed_integer (op_ptr, 4); 360 op_ptr += 4; 361 break; 362 case DW_OP_const8u: 363 result = extract_unsigned_integer (op_ptr, 8); 364 op_ptr += 8; 365 break; 366 case DW_OP_const8s: 367 result = extract_signed_integer (op_ptr, 8); 368 op_ptr += 8; 369 break; 370 case DW_OP_constu: 371 op_ptr = read_uleb128 (op_ptr, op_end, &uoffset); 372 result = uoffset; 373 break; 374 case DW_OP_consts: 375 op_ptr = read_sleb128 (op_ptr, op_end, &offset); 376 result = offset; 377 break; 378 379 /* The DW_OP_reg operations are required to occur alone in 380 location expressions. */ 381 case DW_OP_reg0: 382 case DW_OP_reg1: 383 case DW_OP_reg2: 384 case DW_OP_reg3: 385 case DW_OP_reg4: 386 case DW_OP_reg5: 387 case DW_OP_reg6: 388 case DW_OP_reg7: 389 case DW_OP_reg8: 390 case DW_OP_reg9: 391 case DW_OP_reg10: 392 case DW_OP_reg11: 393 case DW_OP_reg12: 394 case DW_OP_reg13: 395 case DW_OP_reg14: 396 case DW_OP_reg15: 397 case DW_OP_reg16: 398 case DW_OP_reg17: 399 case DW_OP_reg18: 400 case DW_OP_reg19: 401 case DW_OP_reg20: 402 case DW_OP_reg21: 403 case DW_OP_reg22: 404 case DW_OP_reg23: 405 case DW_OP_reg24: 406 case DW_OP_reg25: 407 case DW_OP_reg26: 408 case DW_OP_reg27: 409 case DW_OP_reg28: 410 case DW_OP_reg29: 411 case DW_OP_reg30: 412 case DW_OP_reg31: 413 if (op_ptr != op_end 414 && *op_ptr != DW_OP_piece 415 && *op_ptr != DW_OP_GNU_uninit) 416 error (_("DWARF-2 expression error: DW_OP_reg operations must be " 417 "used either alone or in conjuction with DW_OP_piece.")); 418 419 result = op - DW_OP_reg0; 420 ctx->in_reg = 1; 421 422 break; 423 424 case DW_OP_regx: 425 op_ptr = read_uleb128 (op_ptr, op_end, ®); 426 if (op_ptr != op_end && *op_ptr != DW_OP_piece) 427 error (_("DWARF-2 expression error: DW_OP_reg operations must be " 428 "used either alone or in conjuction with DW_OP_piece.")); 429 430 result = reg; 431 ctx->in_reg = 1; 432 break; 433 434 case DW_OP_breg0: 435 case DW_OP_breg1: 436 case DW_OP_breg2: 437 case DW_OP_breg3: 438 case DW_OP_breg4: 439 case DW_OP_breg5: 440 case DW_OP_breg6: 441 case DW_OP_breg7: 442 case DW_OP_breg8: 443 case DW_OP_breg9: 444 case DW_OP_breg10: 445 case DW_OP_breg11: 446 case DW_OP_breg12: 447 case DW_OP_breg13: 448 case DW_OP_breg14: 449 case DW_OP_breg15: 450 case DW_OP_breg16: 451 case DW_OP_breg17: 452 case DW_OP_breg18: 453 case DW_OP_breg19: 454 case DW_OP_breg20: 455 case DW_OP_breg21: 456 case DW_OP_breg22: 457 case DW_OP_breg23: 458 case DW_OP_breg24: 459 case DW_OP_breg25: 460 case DW_OP_breg26: 461 case DW_OP_breg27: 462 case DW_OP_breg28: 463 case DW_OP_breg29: 464 case DW_OP_breg30: 465 case DW_OP_breg31: 466 { 467 op_ptr = read_sleb128 (op_ptr, op_end, &offset); 468 result = (ctx->read_reg) (ctx->baton, op - DW_OP_breg0); 469 result += offset; 470 } 471 break; 472 case DW_OP_bregx: 473 { 474 op_ptr = read_uleb128 (op_ptr, op_end, ®); 475 op_ptr = read_sleb128 (op_ptr, op_end, &offset); 476 result = (ctx->read_reg) (ctx->baton, reg); 477 result += offset; 478 } 479 break; 480 case DW_OP_fbreg: 481 { 482 gdb_byte *datastart; 483 size_t datalen; 484 unsigned int before_stack_len; 485 486 op_ptr = read_sleb128 (op_ptr, op_end, &offset); 487 /* Rather than create a whole new context, we simply 488 record the stack length before execution, then reset it 489 afterwards, effectively erasing whatever the recursive 490 call put there. */ 491 before_stack_len = ctx->stack_len; 492 /* FIXME: cagney/2003-03-26: This code should be using 493 get_frame_base_address(), and then implement a dwarf2 494 specific this_base method. */ 495 (ctx->get_frame_base) (ctx->baton, &datastart, &datalen); 496 dwarf_expr_eval (ctx, datastart, datalen); 497 result = dwarf_expr_fetch (ctx, 0); 498 if (ctx->in_reg) 499 result = (ctx->read_reg) (ctx->baton, result); 500 result = result + offset; 501 ctx->stack_len = before_stack_len; 502 ctx->in_reg = 0; 503 } 504 break; 505 case DW_OP_dup: 506 result = dwarf_expr_fetch (ctx, 0); 507 break; 508 509 case DW_OP_drop: 510 dwarf_expr_pop (ctx); 511 goto no_push; 512 513 case DW_OP_pick: 514 offset = *op_ptr++; 515 result = dwarf_expr_fetch (ctx, offset); 516 break; 517 518 case DW_OP_over: 519 result = dwarf_expr_fetch (ctx, 1); 520 break; 521 522 case DW_OP_rot: 523 { 524 CORE_ADDR t1, t2, t3; 525 526 if (ctx->stack_len < 3) 527 error (_("Not enough elements for DW_OP_rot. Need 3, have %d."), 528 ctx->stack_len); 529 t1 = ctx->stack[ctx->stack_len - 1]; 530 t2 = ctx->stack[ctx->stack_len - 2]; 531 t3 = ctx->stack[ctx->stack_len - 3]; 532 ctx->stack[ctx->stack_len - 1] = t2; 533 ctx->stack[ctx->stack_len - 2] = t3; 534 ctx->stack[ctx->stack_len - 3] = t1; 535 goto no_push; 536 } 537 538 case DW_OP_deref: 539 case DW_OP_deref_size: 540 case DW_OP_abs: 541 case DW_OP_neg: 542 case DW_OP_not: 543 case DW_OP_plus_uconst: 544 /* Unary operations. */ 545 result = dwarf_expr_fetch (ctx, 0); 546 dwarf_expr_pop (ctx); 547 548 switch (op) 549 { 550 case DW_OP_deref: 551 { 552 gdb_byte *buf = alloca (gdbarch_addr_bit (current_gdbarch) 553 / TARGET_CHAR_BIT); 554 int bytes_read; 555 556 (ctx->read_mem) (ctx->baton, buf, result, 557 gdbarch_addr_bit (current_gdbarch) 558 / TARGET_CHAR_BIT); 559 result = dwarf2_read_address (buf, 560 buf + (gdbarch_addr_bit 561 (current_gdbarch) 562 / TARGET_CHAR_BIT), 563 &bytes_read); 564 } 565 break; 566 567 case DW_OP_deref_size: 568 { 569 gdb_byte *buf 570 = alloca (gdbarch_addr_bit (current_gdbarch) 571 / TARGET_CHAR_BIT); 572 int bytes_read; 573 574 (ctx->read_mem) (ctx->baton, buf, result, *op_ptr++); 575 result = dwarf2_read_address (buf, 576 buf + (gdbarch_addr_bit 577 (current_gdbarch) 578 / TARGET_CHAR_BIT), 579 &bytes_read); 580 } 581 break; 582 583 case DW_OP_abs: 584 if ((signed int) result < 0) 585 result = -result; 586 break; 587 case DW_OP_neg: 588 result = -result; 589 break; 590 case DW_OP_not: 591 result = ~result; 592 break; 593 case DW_OP_plus_uconst: 594 op_ptr = read_uleb128 (op_ptr, op_end, ®); 595 result += reg; 596 break; 597 } 598 break; 599 600 case DW_OP_and: 601 case DW_OP_div: 602 case DW_OP_minus: 603 case DW_OP_mod: 604 case DW_OP_mul: 605 case DW_OP_or: 606 case DW_OP_plus: 607 case DW_OP_shl: 608 case DW_OP_shr: 609 case DW_OP_shra: 610 case DW_OP_xor: 611 case DW_OP_le: 612 case DW_OP_ge: 613 case DW_OP_eq: 614 case DW_OP_lt: 615 case DW_OP_gt: 616 case DW_OP_ne: 617 { 618 /* Binary operations. Use the value engine to do computations in 619 the right width. */ 620 CORE_ADDR first, second; 621 enum exp_opcode binop; 622 struct value *val1, *val2; 623 624 second = dwarf_expr_fetch (ctx, 0); 625 dwarf_expr_pop (ctx); 626 627 first = dwarf_expr_fetch (ctx, 0); 628 dwarf_expr_pop (ctx); 629 630 val1 = value_from_longest (unsigned_address_type (), first); 631 val2 = value_from_longest (unsigned_address_type (), second); 632 633 switch (op) 634 { 635 case DW_OP_and: 636 binop = BINOP_BITWISE_AND; 637 break; 638 case DW_OP_div: 639 binop = BINOP_DIV; 640 break; 641 case DW_OP_minus: 642 binop = BINOP_SUB; 643 break; 644 case DW_OP_mod: 645 binop = BINOP_MOD; 646 break; 647 case DW_OP_mul: 648 binop = BINOP_MUL; 649 break; 650 case DW_OP_or: 651 binop = BINOP_BITWISE_IOR; 652 break; 653 case DW_OP_plus: 654 binop = BINOP_ADD; 655 break; 656 case DW_OP_shl: 657 binop = BINOP_LSH; 658 break; 659 case DW_OP_shr: 660 binop = BINOP_RSH; 661 break; 662 case DW_OP_shra: 663 binop = BINOP_RSH; 664 val1 = value_from_longest (signed_address_type (), first); 665 break; 666 case DW_OP_xor: 667 binop = BINOP_BITWISE_XOR; 668 break; 669 case DW_OP_le: 670 binop = BINOP_LEQ; 671 break; 672 case DW_OP_ge: 673 binop = BINOP_GEQ; 674 break; 675 case DW_OP_eq: 676 binop = BINOP_EQUAL; 677 break; 678 case DW_OP_lt: 679 binop = BINOP_LESS; 680 break; 681 case DW_OP_gt: 682 binop = BINOP_GTR; 683 break; 684 case DW_OP_ne: 685 binop = BINOP_NOTEQUAL; 686 break; 687 default: 688 internal_error (__FILE__, __LINE__, 689 _("Can't be reached.")); 690 } 691 result = value_as_long (value_binop (val1, val2, binop)); 692 } 693 break; 694 695 case DW_OP_GNU_push_tls_address: 696 /* Variable is at a constant offset in the thread-local 697 storage block into the objfile for the current thread and 698 the dynamic linker module containing this expression. Here 699 we return returns the offset from that base. The top of the 700 stack has the offset from the beginning of the thread 701 control block at which the variable is located. Nothing 702 should follow this operator, so the top of stack would be 703 returned. */ 704 result = dwarf_expr_fetch (ctx, 0); 705 dwarf_expr_pop (ctx); 706 result = (ctx->get_tls_address) (ctx->baton, result); 707 break; 708 709 case DW_OP_skip: 710 offset = extract_signed_integer (op_ptr, 2); 711 op_ptr += 2; 712 op_ptr += offset; 713 goto no_push; 714 715 case DW_OP_bra: 716 offset = extract_signed_integer (op_ptr, 2); 717 op_ptr += 2; 718 if (dwarf_expr_fetch (ctx, 0) != 0) 719 op_ptr += offset; 720 dwarf_expr_pop (ctx); 721 goto no_push; 722 723 case DW_OP_nop: 724 goto no_push; 725 726 case DW_OP_piece: 727 { 728 ULONGEST size; 729 CORE_ADDR addr_or_regnum; 730 731 /* Record the piece. */ 732 op_ptr = read_uleb128 (op_ptr, op_end, &size); 733 addr_or_regnum = dwarf_expr_fetch (ctx, 0); 734 add_piece (ctx, ctx->in_reg, addr_or_regnum, size); 735 736 /* Pop off the address/regnum, and clear the in_reg flag. */ 737 dwarf_expr_pop (ctx); 738 ctx->in_reg = 0; 739 } 740 goto no_push; 741 742 case DW_OP_GNU_uninit: 743 if (op_ptr != op_end) 744 error (_("DWARF-2 expression error: DW_OP_GNU_unint must always " 745 "be the very last op.")); 746 747 ctx->initialized = 0; 748 goto no_push; 749 750 default: 751 error (_("Unhandled dwarf expression opcode 0x%x"), op); 752 } 753 754 /* Most things push a result value. */ 755 dwarf_expr_push (ctx, result); 756 no_push:; 757 } 758} 759