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