1 /* DWARF 2 Expression Evaluator. 2 3 Copyright (C) 2001-2013 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 "dwarf2.h" 28 #include "dwarf2expr.h" 29 #include "gdb_assert.h" 30 31 /* Local prototypes. */ 32 33 static void execute_stack_op (struct dwarf_expr_context *, 34 const gdb_byte *, const gdb_byte *); 35 36 /* Cookie for gdbarch data. */ 37 38 static struct gdbarch_data *dwarf_arch_cookie; 39 40 /* This holds gdbarch-specific types used by the DWARF expression 41 evaluator. See comments in execute_stack_op. */ 42 43 struct dwarf_gdbarch_types 44 { 45 struct type *dw_types[3]; 46 }; 47 48 /* Allocate and fill in dwarf_gdbarch_types for an arch. */ 49 50 static void * 51 dwarf_gdbarch_types_init (struct gdbarch *gdbarch) 52 { 53 struct dwarf_gdbarch_types *types 54 = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct dwarf_gdbarch_types); 55 56 /* The types themselves are lazily initialized. */ 57 58 return types; 59 } 60 61 /* Return the type used for DWARF operations where the type is 62 unspecified in the DWARF spec. Only certain sizes are 63 supported. */ 64 65 static struct type * 66 dwarf_expr_address_type (struct dwarf_expr_context *ctx) 67 { 68 struct dwarf_gdbarch_types *types = gdbarch_data (ctx->gdbarch, 69 dwarf_arch_cookie); 70 int ndx; 71 72 if (ctx->addr_size == 2) 73 ndx = 0; 74 else if (ctx->addr_size == 4) 75 ndx = 1; 76 else if (ctx->addr_size == 8) 77 ndx = 2; 78 else 79 error (_("Unsupported address size in DWARF expressions: %d bits"), 80 8 * ctx->addr_size); 81 82 if (types->dw_types[ndx] == NULL) 83 types->dw_types[ndx] 84 = arch_integer_type (ctx->gdbarch, 85 8 * ctx->addr_size, 86 0, "<signed DWARF address type>"); 87 88 return types->dw_types[ndx]; 89 } 90 91 /* Create a new context for the expression evaluator. */ 92 93 struct dwarf_expr_context * 94 new_dwarf_expr_context (void) 95 { 96 struct dwarf_expr_context *retval; 97 98 retval = xcalloc (1, sizeof (struct dwarf_expr_context)); 99 retval->stack_len = 0; 100 retval->stack_allocated = 10; 101 retval->stack = xmalloc (retval->stack_allocated 102 * sizeof (struct dwarf_stack_value)); 103 retval->num_pieces = 0; 104 retval->pieces = 0; 105 retval->max_recursion_depth = 0x100; 106 return retval; 107 } 108 109 /* Release the memory allocated to CTX. */ 110 111 void 112 free_dwarf_expr_context (struct dwarf_expr_context *ctx) 113 { 114 xfree (ctx->stack); 115 xfree (ctx->pieces); 116 xfree (ctx); 117 } 118 119 /* Helper for make_cleanup_free_dwarf_expr_context. */ 120 121 static void 122 free_dwarf_expr_context_cleanup (void *arg) 123 { 124 free_dwarf_expr_context (arg); 125 } 126 127 /* Return a cleanup that calls free_dwarf_expr_context. */ 128 129 struct cleanup * 130 make_cleanup_free_dwarf_expr_context (struct dwarf_expr_context *ctx) 131 { 132 return make_cleanup (free_dwarf_expr_context_cleanup, ctx); 133 } 134 135 /* Expand the memory allocated to CTX's stack to contain at least 136 NEED more elements than are currently used. */ 137 138 static void 139 dwarf_expr_grow_stack (struct dwarf_expr_context *ctx, size_t need) 140 { 141 if (ctx->stack_len + need > ctx->stack_allocated) 142 { 143 size_t newlen = ctx->stack_len + need + 10; 144 145 ctx->stack = xrealloc (ctx->stack, 146 newlen * sizeof (struct dwarf_stack_value)); 147 ctx->stack_allocated = newlen; 148 } 149 } 150 151 /* Push VALUE onto CTX's stack. */ 152 153 static void 154 dwarf_expr_push (struct dwarf_expr_context *ctx, struct value *value, 155 int in_stack_memory) 156 { 157 struct dwarf_stack_value *v; 158 159 dwarf_expr_grow_stack (ctx, 1); 160 v = &ctx->stack[ctx->stack_len++]; 161 v->value = value; 162 v->in_stack_memory = in_stack_memory; 163 } 164 165 /* Push VALUE onto CTX's stack. */ 166 167 void 168 dwarf_expr_push_address (struct dwarf_expr_context *ctx, CORE_ADDR value, 169 int in_stack_memory) 170 { 171 dwarf_expr_push (ctx, 172 value_from_ulongest (dwarf_expr_address_type (ctx), value), 173 in_stack_memory); 174 } 175 176 /* Pop the top item off of CTX's stack. */ 177 178 static void 179 dwarf_expr_pop (struct dwarf_expr_context *ctx) 180 { 181 if (ctx->stack_len <= 0) 182 error (_("dwarf expression stack underflow")); 183 ctx->stack_len--; 184 } 185 186 /* Retrieve the N'th item on CTX's stack. */ 187 188 struct value * 189 dwarf_expr_fetch (struct dwarf_expr_context *ctx, int n) 190 { 191 if (ctx->stack_len <= n) 192 error (_("Asked for position %d of stack, " 193 "stack only has %d elements on it."), 194 n, ctx->stack_len); 195 return ctx->stack[ctx->stack_len - (1 + n)].value; 196 } 197 198 /* Require that TYPE be an integral type; throw an exception if not. */ 199 200 static void 201 dwarf_require_integral (struct type *type) 202 { 203 if (TYPE_CODE (type) != TYPE_CODE_INT 204 && TYPE_CODE (type) != TYPE_CODE_CHAR 205 && TYPE_CODE (type) != TYPE_CODE_BOOL) 206 error (_("integral type expected in DWARF expression")); 207 } 208 209 /* Return the unsigned form of TYPE. TYPE is necessarily an integral 210 type. */ 211 212 static struct type * 213 get_unsigned_type (struct gdbarch *gdbarch, struct type *type) 214 { 215 switch (TYPE_LENGTH (type)) 216 { 217 case 1: 218 return builtin_type (gdbarch)->builtin_uint8; 219 case 2: 220 return builtin_type (gdbarch)->builtin_uint16; 221 case 4: 222 return builtin_type (gdbarch)->builtin_uint32; 223 case 8: 224 return builtin_type (gdbarch)->builtin_uint64; 225 default: 226 error (_("no unsigned variant found for type, while evaluating " 227 "DWARF expression")); 228 } 229 } 230 231 /* Return the signed form of TYPE. TYPE is necessarily an integral 232 type. */ 233 234 static struct type * 235 get_signed_type (struct gdbarch *gdbarch, struct type *type) 236 { 237 switch (TYPE_LENGTH (type)) 238 { 239 case 1: 240 return builtin_type (gdbarch)->builtin_int8; 241 case 2: 242 return builtin_type (gdbarch)->builtin_int16; 243 case 4: 244 return builtin_type (gdbarch)->builtin_int32; 245 case 8: 246 return builtin_type (gdbarch)->builtin_int64; 247 default: 248 error (_("no signed variant found for type, while evaluating " 249 "DWARF expression")); 250 } 251 } 252 253 /* Retrieve the N'th item on CTX's stack, converted to an address. */ 254 255 CORE_ADDR 256 dwarf_expr_fetch_address (struct dwarf_expr_context *ctx, int n) 257 { 258 struct value *result_val = dwarf_expr_fetch (ctx, n); 259 enum bfd_endian byte_order = gdbarch_byte_order (ctx->gdbarch); 260 ULONGEST result; 261 262 dwarf_require_integral (value_type (result_val)); 263 result = extract_unsigned_integer (value_contents (result_val), 264 TYPE_LENGTH (value_type (result_val)), 265 byte_order); 266 267 /* For most architectures, calling extract_unsigned_integer() alone 268 is sufficient for extracting an address. However, some 269 architectures (e.g. MIPS) use signed addresses and using 270 extract_unsigned_integer() will not produce a correct 271 result. Make sure we invoke gdbarch_integer_to_address() 272 for those architectures which require it. */ 273 if (gdbarch_integer_to_address_p (ctx->gdbarch)) 274 { 275 gdb_byte *buf = alloca (ctx->addr_size); 276 struct type *int_type = get_unsigned_type (ctx->gdbarch, 277 value_type (result_val)); 278 279 store_unsigned_integer (buf, ctx->addr_size, byte_order, result); 280 return gdbarch_integer_to_address (ctx->gdbarch, int_type, buf); 281 } 282 283 return (CORE_ADDR) result; 284 } 285 286 /* Retrieve the in_stack_memory flag of the N'th item on CTX's stack. */ 287 288 int 289 dwarf_expr_fetch_in_stack_memory (struct dwarf_expr_context *ctx, int n) 290 { 291 if (ctx->stack_len <= n) 292 error (_("Asked for position %d of stack, " 293 "stack only has %d elements on it."), 294 n, ctx->stack_len); 295 return ctx->stack[ctx->stack_len - (1 + n)].in_stack_memory; 296 } 297 298 /* Return true if the expression stack is empty. */ 299 300 static int 301 dwarf_expr_stack_empty_p (struct dwarf_expr_context *ctx) 302 { 303 return ctx->stack_len == 0; 304 } 305 306 /* Add a new piece to CTX's piece list. */ 307 static void 308 add_piece (struct dwarf_expr_context *ctx, ULONGEST size, ULONGEST offset) 309 { 310 struct dwarf_expr_piece *p; 311 312 ctx->num_pieces++; 313 314 ctx->pieces = xrealloc (ctx->pieces, 315 (ctx->num_pieces 316 * sizeof (struct dwarf_expr_piece))); 317 318 p = &ctx->pieces[ctx->num_pieces - 1]; 319 p->location = ctx->location; 320 p->size = size; 321 p->offset = offset; 322 323 if (p->location == DWARF_VALUE_LITERAL) 324 { 325 p->v.literal.data = ctx->data; 326 p->v.literal.length = ctx->len; 327 } 328 else if (dwarf_expr_stack_empty_p (ctx)) 329 { 330 p->location = DWARF_VALUE_OPTIMIZED_OUT; 331 /* Also reset the context's location, for our callers. This is 332 a somewhat strange approach, but this lets us avoid setting 333 the location to DWARF_VALUE_MEMORY in all the individual 334 cases in the evaluator. */ 335 ctx->location = DWARF_VALUE_OPTIMIZED_OUT; 336 } 337 else if (p->location == DWARF_VALUE_MEMORY) 338 { 339 p->v.mem.addr = dwarf_expr_fetch_address (ctx, 0); 340 p->v.mem.in_stack_memory = dwarf_expr_fetch_in_stack_memory (ctx, 0); 341 } 342 else if (p->location == DWARF_VALUE_IMPLICIT_POINTER) 343 { 344 p->v.ptr.die.sect_off = ctx->len; 345 p->v.ptr.offset = value_as_long (dwarf_expr_fetch (ctx, 0)); 346 } 347 else if (p->location == DWARF_VALUE_REGISTER) 348 p->v.regno = value_as_long (dwarf_expr_fetch (ctx, 0)); 349 else 350 { 351 p->v.value = dwarf_expr_fetch (ctx, 0); 352 } 353 } 354 355 /* Evaluate the expression at ADDR (LEN bytes long) using the context 356 CTX. */ 357 358 void 359 dwarf_expr_eval (struct dwarf_expr_context *ctx, const gdb_byte *addr, 360 size_t len) 361 { 362 int old_recursion_depth = ctx->recursion_depth; 363 364 execute_stack_op (ctx, addr, addr + len); 365 366 /* CTX RECURSION_DEPTH becomes invalid if an exception was thrown here. */ 367 368 gdb_assert (ctx->recursion_depth == old_recursion_depth); 369 } 370 371 /* Helper to read a uleb128 value or throw an error. */ 372 373 const gdb_byte * 374 safe_read_uleb128 (const gdb_byte *buf, const gdb_byte *buf_end, 375 uint64_t *r) 376 { 377 buf = gdb_read_uleb128 (buf, buf_end, r); 378 if (buf == NULL) 379 error (_("DWARF expression error: ran off end of buffer reading uleb128 value")); 380 return buf; 381 } 382 383 /* Helper to read a sleb128 value or throw an error. */ 384 385 const gdb_byte * 386 safe_read_sleb128 (const gdb_byte *buf, const gdb_byte *buf_end, 387 int64_t *r) 388 { 389 buf = gdb_read_sleb128 (buf, buf_end, r); 390 if (buf == NULL) 391 error (_("DWARF expression error: ran off end of buffer reading sleb128 value")); 392 return buf; 393 } 394 395 const gdb_byte * 396 safe_skip_leb128 (const gdb_byte *buf, const gdb_byte *buf_end) 397 { 398 buf = gdb_skip_leb128 (buf, buf_end); 399 if (buf == NULL) 400 error (_("DWARF expression error: ran off end of buffer reading leb128 value")); 401 return buf; 402 } 403 404 405 /* Check that the current operator is either at the end of an 406 expression, or that it is followed by a composition operator. */ 407 408 void 409 dwarf_expr_require_composition (const gdb_byte *op_ptr, const gdb_byte *op_end, 410 const char *op_name) 411 { 412 /* It seems like DW_OP_GNU_uninit should be handled here. However, 413 it doesn't seem to make sense for DW_OP_*_value, and it was not 414 checked at the other place that this function is called. */ 415 if (op_ptr != op_end && *op_ptr != DW_OP_piece && *op_ptr != DW_OP_bit_piece) 416 error (_("DWARF-2 expression error: `%s' operations must be " 417 "used either alone or in conjunction with DW_OP_piece " 418 "or DW_OP_bit_piece."), 419 op_name); 420 } 421 422 /* Return true iff the types T1 and T2 are "the same". This only does 423 checks that might reasonably be needed to compare DWARF base 424 types. */ 425 426 static int 427 base_types_equal_p (struct type *t1, struct type *t2) 428 { 429 if (TYPE_CODE (t1) != TYPE_CODE (t2)) 430 return 0; 431 if (TYPE_UNSIGNED (t1) != TYPE_UNSIGNED (t2)) 432 return 0; 433 return TYPE_LENGTH (t1) == TYPE_LENGTH (t2); 434 } 435 436 /* A convenience function to call get_base_type on CTX and return the 437 result. DIE is the DIE whose type we need. SIZE is non-zero if 438 this function should verify that the resulting type has the correct 439 size. */ 440 441 static struct type * 442 dwarf_get_base_type (struct dwarf_expr_context *ctx, cu_offset die, int size) 443 { 444 struct type *result; 445 446 if (ctx->funcs->get_base_type) 447 { 448 result = ctx->funcs->get_base_type (ctx, die); 449 if (result == NULL) 450 error (_("Could not find type for DW_OP_GNU_const_type")); 451 if (size != 0 && TYPE_LENGTH (result) != size) 452 error (_("DW_OP_GNU_const_type has different sizes for type and data")); 453 } 454 else 455 /* Anything will do. */ 456 result = builtin_type (ctx->gdbarch)->builtin_int; 457 458 return result; 459 } 460 461 /* If <BUF..BUF_END] contains DW_FORM_block* with single DW_OP_reg* return the 462 DWARF register number. Otherwise return -1. */ 463 464 int 465 dwarf_block_to_dwarf_reg (const gdb_byte *buf, const gdb_byte *buf_end) 466 { 467 uint64_t dwarf_reg; 468 469 if (buf_end <= buf) 470 return -1; 471 if (*buf >= DW_OP_reg0 && *buf <= DW_OP_reg31) 472 { 473 if (buf_end - buf != 1) 474 return -1; 475 return *buf - DW_OP_reg0; 476 } 477 478 if (*buf == DW_OP_GNU_regval_type) 479 { 480 buf++; 481 buf = gdb_read_uleb128 (buf, buf_end, &dwarf_reg); 482 if (buf == NULL) 483 return -1; 484 buf = gdb_skip_leb128 (buf, buf_end); 485 if (buf == NULL) 486 return -1; 487 } 488 else if (*buf == DW_OP_regx) 489 { 490 buf++; 491 buf = gdb_read_uleb128 (buf, buf_end, &dwarf_reg); 492 if (buf == NULL) 493 return -1; 494 } 495 else 496 return -1; 497 if (buf != buf_end || (int) dwarf_reg != dwarf_reg) 498 return -1; 499 return dwarf_reg; 500 } 501 502 /* If <BUF..BUF_END] contains DW_FORM_block* with just DW_OP_breg*(0) and 503 DW_OP_deref* return the DWARF register number. Otherwise return -1. 504 DEREF_SIZE_RETURN contains -1 for DW_OP_deref; otherwise it contains the 505 size from DW_OP_deref_size. */ 506 507 int 508 dwarf_block_to_dwarf_reg_deref (const gdb_byte *buf, const gdb_byte *buf_end, 509 CORE_ADDR *deref_size_return) 510 { 511 uint64_t dwarf_reg; 512 int64_t offset; 513 514 if (buf_end <= buf) 515 return -1; 516 517 if (*buf >= DW_OP_breg0 && *buf <= DW_OP_breg31) 518 { 519 dwarf_reg = *buf - DW_OP_breg0; 520 buf++; 521 if (buf >= buf_end) 522 return -1; 523 } 524 else if (*buf == DW_OP_bregx) 525 { 526 buf++; 527 buf = gdb_read_uleb128 (buf, buf_end, &dwarf_reg); 528 if (buf == NULL) 529 return -1; 530 if ((int) dwarf_reg != dwarf_reg) 531 return -1; 532 } 533 else 534 return -1; 535 536 buf = gdb_read_sleb128 (buf, buf_end, &offset); 537 if (buf == NULL) 538 return -1; 539 if (offset != 0) 540 return -1; 541 542 if (*buf == DW_OP_deref) 543 { 544 buf++; 545 *deref_size_return = -1; 546 } 547 else if (*buf == DW_OP_deref_size) 548 { 549 buf++; 550 if (buf >= buf_end) 551 return -1; 552 *deref_size_return = *buf++; 553 } 554 else 555 return -1; 556 557 if (buf != buf_end) 558 return -1; 559 560 return dwarf_reg; 561 } 562 563 /* If <BUF..BUF_END] contains DW_FORM_block* with single DW_OP_fbreg(X) fill 564 in FB_OFFSET_RETURN with the X offset and return 1. Otherwise return 0. */ 565 566 int 567 dwarf_block_to_fb_offset (const gdb_byte *buf, const gdb_byte *buf_end, 568 CORE_ADDR *fb_offset_return) 569 { 570 int64_t fb_offset; 571 572 if (buf_end <= buf) 573 return 0; 574 575 if (*buf != DW_OP_fbreg) 576 return 0; 577 buf++; 578 579 buf = gdb_read_sleb128 (buf, buf_end, &fb_offset); 580 if (buf == NULL) 581 return 0; 582 *fb_offset_return = fb_offset; 583 if (buf != buf_end || fb_offset != (LONGEST) *fb_offset_return) 584 return 0; 585 586 return 1; 587 } 588 589 /* If <BUF..BUF_END] contains DW_FORM_block* with single DW_OP_bregSP(X) fill 590 in SP_OFFSET_RETURN with the X offset and return 1. Otherwise return 0. 591 The matched SP register number depends on GDBARCH. */ 592 593 int 594 dwarf_block_to_sp_offset (struct gdbarch *gdbarch, const gdb_byte *buf, 595 const gdb_byte *buf_end, CORE_ADDR *sp_offset_return) 596 { 597 uint64_t dwarf_reg; 598 int64_t sp_offset; 599 600 if (buf_end <= buf) 601 return 0; 602 if (*buf >= DW_OP_breg0 && *buf <= DW_OP_breg31) 603 { 604 dwarf_reg = *buf - DW_OP_breg0; 605 buf++; 606 } 607 else 608 { 609 if (*buf != DW_OP_bregx) 610 return 0; 611 buf++; 612 buf = gdb_read_uleb128 (buf, buf_end, &dwarf_reg); 613 if (buf == NULL) 614 return 0; 615 } 616 617 if (gdbarch_dwarf2_reg_to_regnum (gdbarch, dwarf_reg) 618 != gdbarch_sp_regnum (gdbarch)) 619 return 0; 620 621 buf = gdb_read_sleb128 (buf, buf_end, &sp_offset); 622 if (buf == NULL) 623 return 0; 624 *sp_offset_return = sp_offset; 625 if (buf != buf_end || sp_offset != (LONGEST) *sp_offset_return) 626 return 0; 627 628 return 1; 629 } 630 631 /* The engine for the expression evaluator. Using the context in CTX, 632 evaluate the expression between OP_PTR and OP_END. */ 633 634 static void 635 execute_stack_op (struct dwarf_expr_context *ctx, 636 const gdb_byte *op_ptr, const gdb_byte *op_end) 637 { 638 enum bfd_endian byte_order = gdbarch_byte_order (ctx->gdbarch); 639 /* Old-style "untyped" DWARF values need special treatment in a 640 couple of places, specifically DW_OP_mod and DW_OP_shr. We need 641 a special type for these values so we can distinguish them from 642 values that have an explicit type, because explicitly-typed 643 values do not need special treatment. This special type must be 644 different (in the `==' sense) from any base type coming from the 645 CU. */ 646 struct type *address_type = dwarf_expr_address_type (ctx); 647 648 ctx->location = DWARF_VALUE_MEMORY; 649 ctx->initialized = 1; /* Default is initialized. */ 650 651 if (ctx->recursion_depth > ctx->max_recursion_depth) 652 error (_("DWARF-2 expression error: Loop detected (%d)."), 653 ctx->recursion_depth); 654 ctx->recursion_depth++; 655 656 while (op_ptr < op_end) 657 { 658 enum dwarf_location_atom op = *op_ptr++; 659 ULONGEST result; 660 /* Assume the value is not in stack memory. 661 Code that knows otherwise sets this to 1. 662 Some arithmetic on stack addresses can probably be assumed to still 663 be a stack address, but we skip this complication for now. 664 This is just an optimization, so it's always ok to punt 665 and leave this as 0. */ 666 int in_stack_memory = 0; 667 uint64_t uoffset, reg; 668 int64_t offset; 669 struct value *result_val = NULL; 670 671 /* The DWARF expression might have a bug causing an infinite 672 loop. In that case, quitting is the only way out. */ 673 QUIT; 674 675 switch (op) 676 { 677 case DW_OP_lit0: 678 case DW_OP_lit1: 679 case DW_OP_lit2: 680 case DW_OP_lit3: 681 case DW_OP_lit4: 682 case DW_OP_lit5: 683 case DW_OP_lit6: 684 case DW_OP_lit7: 685 case DW_OP_lit8: 686 case DW_OP_lit9: 687 case DW_OP_lit10: 688 case DW_OP_lit11: 689 case DW_OP_lit12: 690 case DW_OP_lit13: 691 case DW_OP_lit14: 692 case DW_OP_lit15: 693 case DW_OP_lit16: 694 case DW_OP_lit17: 695 case DW_OP_lit18: 696 case DW_OP_lit19: 697 case DW_OP_lit20: 698 case DW_OP_lit21: 699 case DW_OP_lit22: 700 case DW_OP_lit23: 701 case DW_OP_lit24: 702 case DW_OP_lit25: 703 case DW_OP_lit26: 704 case DW_OP_lit27: 705 case DW_OP_lit28: 706 case DW_OP_lit29: 707 case DW_OP_lit30: 708 case DW_OP_lit31: 709 result = op - DW_OP_lit0; 710 result_val = value_from_ulongest (address_type, result); 711 break; 712 713 case DW_OP_addr: 714 result = extract_unsigned_integer (op_ptr, 715 ctx->addr_size, byte_order); 716 op_ptr += ctx->addr_size; 717 /* Some versions of GCC emit DW_OP_addr before 718 DW_OP_GNU_push_tls_address. In this case the value is an 719 index, not an address. We don't support things like 720 branching between the address and the TLS op. */ 721 if (op_ptr >= op_end || *op_ptr != DW_OP_GNU_push_tls_address) 722 result += ctx->offset; 723 result_val = value_from_ulongest (address_type, result); 724 break; 725 726 case DW_OP_GNU_addr_index: 727 op_ptr = safe_read_uleb128 (op_ptr, op_end, &uoffset); 728 result = (ctx->funcs->get_addr_index) (ctx->baton, uoffset); 729 result += ctx->offset; 730 result_val = value_from_ulongest (address_type, result); 731 break; 732 case DW_OP_GNU_const_index: 733 op_ptr = safe_read_uleb128 (op_ptr, op_end, &uoffset); 734 result = (ctx->funcs->get_addr_index) (ctx->baton, uoffset); 735 result_val = value_from_ulongest (address_type, result); 736 break; 737 738 case DW_OP_const1u: 739 result = extract_unsigned_integer (op_ptr, 1, byte_order); 740 result_val = value_from_ulongest (address_type, result); 741 op_ptr += 1; 742 break; 743 case DW_OP_const1s: 744 result = extract_signed_integer (op_ptr, 1, byte_order); 745 result_val = value_from_ulongest (address_type, result); 746 op_ptr += 1; 747 break; 748 case DW_OP_const2u: 749 result = extract_unsigned_integer (op_ptr, 2, byte_order); 750 result_val = value_from_ulongest (address_type, result); 751 op_ptr += 2; 752 break; 753 case DW_OP_const2s: 754 result = extract_signed_integer (op_ptr, 2, byte_order); 755 result_val = value_from_ulongest (address_type, result); 756 op_ptr += 2; 757 break; 758 case DW_OP_const4u: 759 result = extract_unsigned_integer (op_ptr, 4, byte_order); 760 result_val = value_from_ulongest (address_type, result); 761 op_ptr += 4; 762 break; 763 case DW_OP_const4s: 764 result = extract_signed_integer (op_ptr, 4, byte_order); 765 result_val = value_from_ulongest (address_type, result); 766 op_ptr += 4; 767 break; 768 case DW_OP_const8u: 769 result = extract_unsigned_integer (op_ptr, 8, byte_order); 770 result_val = value_from_ulongest (address_type, result); 771 op_ptr += 8; 772 break; 773 case DW_OP_const8s: 774 result = extract_signed_integer (op_ptr, 8, byte_order); 775 result_val = value_from_ulongest (address_type, result); 776 op_ptr += 8; 777 break; 778 case DW_OP_constu: 779 op_ptr = safe_read_uleb128 (op_ptr, op_end, &uoffset); 780 result = uoffset; 781 result_val = value_from_ulongest (address_type, result); 782 break; 783 case DW_OP_consts: 784 op_ptr = safe_read_sleb128 (op_ptr, op_end, &offset); 785 result = offset; 786 result_val = value_from_ulongest (address_type, result); 787 break; 788 789 /* The DW_OP_reg operations are required to occur alone in 790 location expressions. */ 791 case DW_OP_reg0: 792 case DW_OP_reg1: 793 case DW_OP_reg2: 794 case DW_OP_reg3: 795 case DW_OP_reg4: 796 case DW_OP_reg5: 797 case DW_OP_reg6: 798 case DW_OP_reg7: 799 case DW_OP_reg8: 800 case DW_OP_reg9: 801 case DW_OP_reg10: 802 case DW_OP_reg11: 803 case DW_OP_reg12: 804 case DW_OP_reg13: 805 case DW_OP_reg14: 806 case DW_OP_reg15: 807 case DW_OP_reg16: 808 case DW_OP_reg17: 809 case DW_OP_reg18: 810 case DW_OP_reg19: 811 case DW_OP_reg20: 812 case DW_OP_reg21: 813 case DW_OP_reg22: 814 case DW_OP_reg23: 815 case DW_OP_reg24: 816 case DW_OP_reg25: 817 case DW_OP_reg26: 818 case DW_OP_reg27: 819 case DW_OP_reg28: 820 case DW_OP_reg29: 821 case DW_OP_reg30: 822 case DW_OP_reg31: 823 if (op_ptr != op_end 824 && *op_ptr != DW_OP_piece 825 && *op_ptr != DW_OP_bit_piece 826 && *op_ptr != DW_OP_GNU_uninit) 827 error (_("DWARF-2 expression error: DW_OP_reg operations must be " 828 "used either alone or in conjunction with DW_OP_piece " 829 "or DW_OP_bit_piece.")); 830 831 result = op - DW_OP_reg0; 832 result_val = value_from_ulongest (address_type, result); 833 ctx->location = DWARF_VALUE_REGISTER; 834 break; 835 836 case DW_OP_regx: 837 op_ptr = safe_read_uleb128 (op_ptr, op_end, ®); 838 dwarf_expr_require_composition (op_ptr, op_end, "DW_OP_regx"); 839 840 result = reg; 841 result_val = value_from_ulongest (address_type, result); 842 ctx->location = DWARF_VALUE_REGISTER; 843 break; 844 845 case DW_OP_implicit_value: 846 { 847 uint64_t len; 848 849 op_ptr = safe_read_uleb128 (op_ptr, op_end, &len); 850 if (op_ptr + len > op_end) 851 error (_("DW_OP_implicit_value: too few bytes available.")); 852 ctx->len = len; 853 ctx->data = op_ptr; 854 ctx->location = DWARF_VALUE_LITERAL; 855 op_ptr += len; 856 dwarf_expr_require_composition (op_ptr, op_end, 857 "DW_OP_implicit_value"); 858 } 859 goto no_push; 860 861 case DW_OP_stack_value: 862 ctx->location = DWARF_VALUE_STACK; 863 dwarf_expr_require_composition (op_ptr, op_end, "DW_OP_stack_value"); 864 goto no_push; 865 866 case DW_OP_GNU_implicit_pointer: 867 { 868 int64_t len; 869 870 if (ctx->ref_addr_size == -1) 871 error (_("DWARF-2 expression error: DW_OP_GNU_implicit_pointer " 872 "is not allowed in frame context")); 873 874 /* The referred-to DIE of sect_offset kind. */ 875 ctx->len = extract_unsigned_integer (op_ptr, ctx->ref_addr_size, 876 byte_order); 877 op_ptr += ctx->ref_addr_size; 878 879 /* The byte offset into the data. */ 880 op_ptr = safe_read_sleb128 (op_ptr, op_end, &len); 881 result = (ULONGEST) len; 882 result_val = value_from_ulongest (address_type, result); 883 884 ctx->location = DWARF_VALUE_IMPLICIT_POINTER; 885 dwarf_expr_require_composition (op_ptr, op_end, 886 "DW_OP_GNU_implicit_pointer"); 887 } 888 break; 889 890 case DW_OP_breg0: 891 case DW_OP_breg1: 892 case DW_OP_breg2: 893 case DW_OP_breg3: 894 case DW_OP_breg4: 895 case DW_OP_breg5: 896 case DW_OP_breg6: 897 case DW_OP_breg7: 898 case DW_OP_breg8: 899 case DW_OP_breg9: 900 case DW_OP_breg10: 901 case DW_OP_breg11: 902 case DW_OP_breg12: 903 case DW_OP_breg13: 904 case DW_OP_breg14: 905 case DW_OP_breg15: 906 case DW_OP_breg16: 907 case DW_OP_breg17: 908 case DW_OP_breg18: 909 case DW_OP_breg19: 910 case DW_OP_breg20: 911 case DW_OP_breg21: 912 case DW_OP_breg22: 913 case DW_OP_breg23: 914 case DW_OP_breg24: 915 case DW_OP_breg25: 916 case DW_OP_breg26: 917 case DW_OP_breg27: 918 case DW_OP_breg28: 919 case DW_OP_breg29: 920 case DW_OP_breg30: 921 case DW_OP_breg31: 922 { 923 op_ptr = safe_read_sleb128 (op_ptr, op_end, &offset); 924 result = (ctx->funcs->read_reg) (ctx->baton, op - DW_OP_breg0); 925 result += offset; 926 result_val = value_from_ulongest (address_type, result); 927 } 928 break; 929 case DW_OP_bregx: 930 { 931 op_ptr = safe_read_uleb128 (op_ptr, op_end, ®); 932 op_ptr = safe_read_sleb128 (op_ptr, op_end, &offset); 933 result = (ctx->funcs->read_reg) (ctx->baton, reg); 934 result += offset; 935 result_val = value_from_ulongest (address_type, result); 936 } 937 break; 938 case DW_OP_fbreg: 939 { 940 const gdb_byte *datastart; 941 size_t datalen; 942 unsigned int before_stack_len; 943 944 op_ptr = safe_read_sleb128 (op_ptr, op_end, &offset); 945 /* Rather than create a whole new context, we simply 946 record the stack length before execution, then reset it 947 afterwards, effectively erasing whatever the recursive 948 call put there. */ 949 before_stack_len = ctx->stack_len; 950 /* FIXME: cagney/2003-03-26: This code should be using 951 get_frame_base_address(), and then implement a dwarf2 952 specific this_base method. */ 953 (ctx->funcs->get_frame_base) (ctx->baton, &datastart, &datalen); 954 dwarf_expr_eval (ctx, datastart, datalen); 955 if (ctx->location == DWARF_VALUE_MEMORY) 956 result = dwarf_expr_fetch_address (ctx, 0); 957 else if (ctx->location == DWARF_VALUE_REGISTER) 958 result = (ctx->funcs->read_reg) (ctx->baton, 959 value_as_long (dwarf_expr_fetch (ctx, 0))); 960 else 961 error (_("Not implemented: computing frame " 962 "base using explicit value operator")); 963 result = result + offset; 964 result_val = value_from_ulongest (address_type, result); 965 in_stack_memory = 1; 966 ctx->stack_len = before_stack_len; 967 ctx->location = DWARF_VALUE_MEMORY; 968 } 969 break; 970 971 case DW_OP_dup: 972 result_val = dwarf_expr_fetch (ctx, 0); 973 in_stack_memory = dwarf_expr_fetch_in_stack_memory (ctx, 0); 974 break; 975 976 case DW_OP_drop: 977 dwarf_expr_pop (ctx); 978 goto no_push; 979 980 case DW_OP_pick: 981 offset = *op_ptr++; 982 result_val = dwarf_expr_fetch (ctx, offset); 983 in_stack_memory = dwarf_expr_fetch_in_stack_memory (ctx, offset); 984 break; 985 986 case DW_OP_swap: 987 { 988 struct dwarf_stack_value t1, t2; 989 990 if (ctx->stack_len < 2) 991 error (_("Not enough elements for " 992 "DW_OP_swap. Need 2, have %d."), 993 ctx->stack_len); 994 t1 = ctx->stack[ctx->stack_len - 1]; 995 t2 = ctx->stack[ctx->stack_len - 2]; 996 ctx->stack[ctx->stack_len - 1] = t2; 997 ctx->stack[ctx->stack_len - 2] = t1; 998 goto no_push; 999 } 1000 1001 case DW_OP_over: 1002 result_val = dwarf_expr_fetch (ctx, 1); 1003 in_stack_memory = dwarf_expr_fetch_in_stack_memory (ctx, 1); 1004 break; 1005 1006 case DW_OP_rot: 1007 { 1008 struct dwarf_stack_value t1, t2, t3; 1009 1010 if (ctx->stack_len < 3) 1011 error (_("Not enough elements for " 1012 "DW_OP_rot. Need 3, have %d."), 1013 ctx->stack_len); 1014 t1 = ctx->stack[ctx->stack_len - 1]; 1015 t2 = ctx->stack[ctx->stack_len - 2]; 1016 t3 = ctx->stack[ctx->stack_len - 3]; 1017 ctx->stack[ctx->stack_len - 1] = t2; 1018 ctx->stack[ctx->stack_len - 2] = t3; 1019 ctx->stack[ctx->stack_len - 3] = t1; 1020 goto no_push; 1021 } 1022 1023 case DW_OP_deref: 1024 case DW_OP_deref_size: 1025 case DW_OP_GNU_deref_type: 1026 { 1027 int addr_size = (op == DW_OP_deref ? ctx->addr_size : *op_ptr++); 1028 gdb_byte *buf = alloca (addr_size); 1029 CORE_ADDR addr = dwarf_expr_fetch_address (ctx, 0); 1030 struct type *type; 1031 1032 dwarf_expr_pop (ctx); 1033 1034 if (op == DW_OP_GNU_deref_type) 1035 { 1036 cu_offset type_die; 1037 1038 op_ptr = safe_read_uleb128 (op_ptr, op_end, &uoffset); 1039 type_die.cu_off = uoffset; 1040 type = dwarf_get_base_type (ctx, type_die, 0); 1041 } 1042 else 1043 type = address_type; 1044 1045 (ctx->funcs->read_mem) (ctx->baton, buf, addr, addr_size); 1046 1047 /* If the size of the object read from memory is different 1048 from the type length, we need to zero-extend it. */ 1049 if (TYPE_LENGTH (type) != addr_size) 1050 { 1051 ULONGEST result = 1052 extract_unsigned_integer (buf, addr_size, byte_order); 1053 1054 buf = alloca (TYPE_LENGTH (type)); 1055 store_unsigned_integer (buf, TYPE_LENGTH (type), 1056 byte_order, result); 1057 } 1058 1059 result_val = value_from_contents_and_address (type, buf, addr); 1060 break; 1061 } 1062 1063 case DW_OP_abs: 1064 case DW_OP_neg: 1065 case DW_OP_not: 1066 case DW_OP_plus_uconst: 1067 { 1068 /* Unary operations. */ 1069 result_val = dwarf_expr_fetch (ctx, 0); 1070 dwarf_expr_pop (ctx); 1071 1072 switch (op) 1073 { 1074 case DW_OP_abs: 1075 if (value_less (result_val, 1076 value_zero (value_type (result_val), not_lval))) 1077 result_val = value_neg (result_val); 1078 break; 1079 case DW_OP_neg: 1080 result_val = value_neg (result_val); 1081 break; 1082 case DW_OP_not: 1083 dwarf_require_integral (value_type (result_val)); 1084 result_val = value_complement (result_val); 1085 break; 1086 case DW_OP_plus_uconst: 1087 dwarf_require_integral (value_type (result_val)); 1088 result = value_as_long (result_val); 1089 op_ptr = safe_read_uleb128 (op_ptr, op_end, ®); 1090 result += reg; 1091 result_val = value_from_ulongest (address_type, result); 1092 break; 1093 } 1094 } 1095 break; 1096 1097 case DW_OP_and: 1098 case DW_OP_div: 1099 case DW_OP_minus: 1100 case DW_OP_mod: 1101 case DW_OP_mul: 1102 case DW_OP_or: 1103 case DW_OP_plus: 1104 case DW_OP_shl: 1105 case DW_OP_shr: 1106 case DW_OP_shra: 1107 case DW_OP_xor: 1108 case DW_OP_le: 1109 case DW_OP_ge: 1110 case DW_OP_eq: 1111 case DW_OP_lt: 1112 case DW_OP_gt: 1113 case DW_OP_ne: 1114 { 1115 /* Binary operations. */ 1116 struct value *first, *second; 1117 1118 second = dwarf_expr_fetch (ctx, 0); 1119 dwarf_expr_pop (ctx); 1120 1121 first = dwarf_expr_fetch (ctx, 0); 1122 dwarf_expr_pop (ctx); 1123 1124 if (! base_types_equal_p (value_type (first), value_type (second))) 1125 error (_("Incompatible types on DWARF stack")); 1126 1127 switch (op) 1128 { 1129 case DW_OP_and: 1130 dwarf_require_integral (value_type (first)); 1131 dwarf_require_integral (value_type (second)); 1132 result_val = value_binop (first, second, BINOP_BITWISE_AND); 1133 break; 1134 case DW_OP_div: 1135 result_val = value_binop (first, second, BINOP_DIV); 1136 break; 1137 case DW_OP_minus: 1138 result_val = value_binop (first, second, BINOP_SUB); 1139 break; 1140 case DW_OP_mod: 1141 { 1142 int cast_back = 0; 1143 struct type *orig_type = value_type (first); 1144 1145 /* We have to special-case "old-style" untyped values 1146 -- these must have mod computed using unsigned 1147 math. */ 1148 if (orig_type == address_type) 1149 { 1150 struct type *utype 1151 = get_unsigned_type (ctx->gdbarch, orig_type); 1152 1153 cast_back = 1; 1154 first = value_cast (utype, first); 1155 second = value_cast (utype, second); 1156 } 1157 /* Note that value_binop doesn't handle float or 1158 decimal float here. This seems unimportant. */ 1159 result_val = value_binop (first, second, BINOP_MOD); 1160 if (cast_back) 1161 result_val = value_cast (orig_type, result_val); 1162 } 1163 break; 1164 case DW_OP_mul: 1165 result_val = value_binop (first, second, BINOP_MUL); 1166 break; 1167 case DW_OP_or: 1168 dwarf_require_integral (value_type (first)); 1169 dwarf_require_integral (value_type (second)); 1170 result_val = value_binop (first, second, BINOP_BITWISE_IOR); 1171 break; 1172 case DW_OP_plus: 1173 result_val = value_binop (first, second, BINOP_ADD); 1174 break; 1175 case DW_OP_shl: 1176 dwarf_require_integral (value_type (first)); 1177 dwarf_require_integral (value_type (second)); 1178 result_val = value_binop (first, second, BINOP_LSH); 1179 break; 1180 case DW_OP_shr: 1181 dwarf_require_integral (value_type (first)); 1182 dwarf_require_integral (value_type (second)); 1183 if (!TYPE_UNSIGNED (value_type (first))) 1184 { 1185 struct type *utype 1186 = get_unsigned_type (ctx->gdbarch, value_type (first)); 1187 1188 first = value_cast (utype, first); 1189 } 1190 1191 result_val = value_binop (first, second, BINOP_RSH); 1192 /* Make sure we wind up with the same type we started 1193 with. */ 1194 if (value_type (result_val) != value_type (second)) 1195 result_val = value_cast (value_type (second), result_val); 1196 break; 1197 case DW_OP_shra: 1198 dwarf_require_integral (value_type (first)); 1199 dwarf_require_integral (value_type (second)); 1200 if (TYPE_UNSIGNED (value_type (first))) 1201 { 1202 struct type *stype 1203 = get_signed_type (ctx->gdbarch, value_type (first)); 1204 1205 first = value_cast (stype, first); 1206 } 1207 1208 result_val = value_binop (first, second, BINOP_RSH); 1209 /* Make sure we wind up with the same type we started 1210 with. */ 1211 if (value_type (result_val) != value_type (second)) 1212 result_val = value_cast (value_type (second), result_val); 1213 break; 1214 case DW_OP_xor: 1215 dwarf_require_integral (value_type (first)); 1216 dwarf_require_integral (value_type (second)); 1217 result_val = value_binop (first, second, BINOP_BITWISE_XOR); 1218 break; 1219 case DW_OP_le: 1220 /* A <= B is !(B < A). */ 1221 result = ! value_less (second, first); 1222 result_val = value_from_ulongest (address_type, result); 1223 break; 1224 case DW_OP_ge: 1225 /* A >= B is !(A < B). */ 1226 result = ! value_less (first, second); 1227 result_val = value_from_ulongest (address_type, result); 1228 break; 1229 case DW_OP_eq: 1230 result = value_equal (first, second); 1231 result_val = value_from_ulongest (address_type, result); 1232 break; 1233 case DW_OP_lt: 1234 result = value_less (first, second); 1235 result_val = value_from_ulongest (address_type, result); 1236 break; 1237 case DW_OP_gt: 1238 /* A > B is B < A. */ 1239 result = value_less (second, first); 1240 result_val = value_from_ulongest (address_type, result); 1241 break; 1242 case DW_OP_ne: 1243 result = ! value_equal (first, second); 1244 result_val = value_from_ulongest (address_type, result); 1245 break; 1246 default: 1247 internal_error (__FILE__, __LINE__, 1248 _("Can't be reached.")); 1249 } 1250 } 1251 break; 1252 1253 case DW_OP_call_frame_cfa: 1254 result = (ctx->funcs->get_frame_cfa) (ctx->baton); 1255 result_val = value_from_ulongest (address_type, result); 1256 in_stack_memory = 1; 1257 break; 1258 1259 case DW_OP_GNU_push_tls_address: 1260 /* Variable is at a constant offset in the thread-local 1261 storage block into the objfile for the current thread and 1262 the dynamic linker module containing this expression. Here 1263 we return returns the offset from that base. The top of the 1264 stack has the offset from the beginning of the thread 1265 control block at which the variable is located. Nothing 1266 should follow this operator, so the top of stack would be 1267 returned. */ 1268 result = value_as_long (dwarf_expr_fetch (ctx, 0)); 1269 dwarf_expr_pop (ctx); 1270 result = (ctx->funcs->get_tls_address) (ctx->baton, result); 1271 result_val = value_from_ulongest (address_type, result); 1272 break; 1273 1274 case DW_OP_skip: 1275 offset = extract_signed_integer (op_ptr, 2, byte_order); 1276 op_ptr += 2; 1277 op_ptr += offset; 1278 goto no_push; 1279 1280 case DW_OP_bra: 1281 { 1282 struct value *val; 1283 1284 offset = extract_signed_integer (op_ptr, 2, byte_order); 1285 op_ptr += 2; 1286 val = dwarf_expr_fetch (ctx, 0); 1287 dwarf_require_integral (value_type (val)); 1288 if (value_as_long (val) != 0) 1289 op_ptr += offset; 1290 dwarf_expr_pop (ctx); 1291 } 1292 goto no_push; 1293 1294 case DW_OP_nop: 1295 goto no_push; 1296 1297 case DW_OP_piece: 1298 { 1299 uint64_t size; 1300 1301 /* Record the piece. */ 1302 op_ptr = safe_read_uleb128 (op_ptr, op_end, &size); 1303 add_piece (ctx, 8 * size, 0); 1304 1305 /* Pop off the address/regnum, and reset the location 1306 type. */ 1307 if (ctx->location != DWARF_VALUE_LITERAL 1308 && ctx->location != DWARF_VALUE_OPTIMIZED_OUT) 1309 dwarf_expr_pop (ctx); 1310 ctx->location = DWARF_VALUE_MEMORY; 1311 } 1312 goto no_push; 1313 1314 case DW_OP_bit_piece: 1315 { 1316 uint64_t size, offset; 1317 1318 /* Record the piece. */ 1319 op_ptr = safe_read_uleb128 (op_ptr, op_end, &size); 1320 op_ptr = safe_read_uleb128 (op_ptr, op_end, &offset); 1321 add_piece (ctx, size, offset); 1322 1323 /* Pop off the address/regnum, and reset the location 1324 type. */ 1325 if (ctx->location != DWARF_VALUE_LITERAL 1326 && ctx->location != DWARF_VALUE_OPTIMIZED_OUT) 1327 dwarf_expr_pop (ctx); 1328 ctx->location = DWARF_VALUE_MEMORY; 1329 } 1330 goto no_push; 1331 1332 case DW_OP_GNU_uninit: 1333 if (op_ptr != op_end) 1334 error (_("DWARF-2 expression error: DW_OP_GNU_uninit must always " 1335 "be the very last op.")); 1336 1337 ctx->initialized = 0; 1338 goto no_push; 1339 1340 case DW_OP_call2: 1341 { 1342 cu_offset offset; 1343 1344 offset.cu_off = extract_unsigned_integer (op_ptr, 2, byte_order); 1345 op_ptr += 2; 1346 ctx->funcs->dwarf_call (ctx, offset); 1347 } 1348 goto no_push; 1349 1350 case DW_OP_call4: 1351 { 1352 cu_offset offset; 1353 1354 offset.cu_off = extract_unsigned_integer (op_ptr, 4, byte_order); 1355 op_ptr += 4; 1356 ctx->funcs->dwarf_call (ctx, offset); 1357 } 1358 goto no_push; 1359 1360 case DW_OP_GNU_entry_value: 1361 { 1362 uint64_t len; 1363 CORE_ADDR deref_size; 1364 union call_site_parameter_u kind_u; 1365 1366 op_ptr = safe_read_uleb128 (op_ptr, op_end, &len); 1367 if (op_ptr + len > op_end) 1368 error (_("DW_OP_GNU_entry_value: too few bytes available.")); 1369 1370 kind_u.dwarf_reg = dwarf_block_to_dwarf_reg (op_ptr, op_ptr + len); 1371 if (kind_u.dwarf_reg != -1) 1372 { 1373 op_ptr += len; 1374 ctx->funcs->push_dwarf_reg_entry_value (ctx, 1375 CALL_SITE_PARAMETER_DWARF_REG, 1376 kind_u, 1377 -1 /* deref_size */); 1378 goto no_push; 1379 } 1380 1381 kind_u.dwarf_reg = dwarf_block_to_dwarf_reg_deref (op_ptr, 1382 op_ptr + len, 1383 &deref_size); 1384 if (kind_u.dwarf_reg != -1) 1385 { 1386 if (deref_size == -1) 1387 deref_size = ctx->addr_size; 1388 op_ptr += len; 1389 ctx->funcs->push_dwarf_reg_entry_value (ctx, 1390 CALL_SITE_PARAMETER_DWARF_REG, 1391 kind_u, deref_size); 1392 goto no_push; 1393 } 1394 1395 error (_("DWARF-2 expression error: DW_OP_GNU_entry_value is " 1396 "supported only for single DW_OP_reg* " 1397 "or for DW_OP_breg*(0)+DW_OP_deref*")); 1398 } 1399 1400 case DW_OP_GNU_parameter_ref: 1401 { 1402 union call_site_parameter_u kind_u; 1403 1404 kind_u.param_offset.cu_off = extract_unsigned_integer (op_ptr, 4, 1405 byte_order); 1406 op_ptr += 4; 1407 ctx->funcs->push_dwarf_reg_entry_value (ctx, 1408 CALL_SITE_PARAMETER_PARAM_OFFSET, 1409 kind_u, 1410 -1 /* deref_size */); 1411 } 1412 goto no_push; 1413 1414 case DW_OP_GNU_const_type: 1415 { 1416 cu_offset type_die; 1417 int n; 1418 const gdb_byte *data; 1419 struct type *type; 1420 1421 op_ptr = safe_read_uleb128 (op_ptr, op_end, &uoffset); 1422 type_die.cu_off = uoffset; 1423 n = *op_ptr++; 1424 data = op_ptr; 1425 op_ptr += n; 1426 1427 type = dwarf_get_base_type (ctx, type_die, n); 1428 result_val = value_from_contents (type, data); 1429 } 1430 break; 1431 1432 case DW_OP_GNU_regval_type: 1433 { 1434 cu_offset type_die; 1435 struct type *type; 1436 1437 op_ptr = safe_read_uleb128 (op_ptr, op_end, ®); 1438 op_ptr = safe_read_uleb128 (op_ptr, op_end, &uoffset); 1439 type_die.cu_off = uoffset; 1440 1441 type = dwarf_get_base_type (ctx, type_die, 0); 1442 result = (ctx->funcs->read_reg) (ctx->baton, reg); 1443 result_val = value_from_ulongest (address_type, result); 1444 result_val = value_from_contents (type, 1445 value_contents_all (result_val)); 1446 } 1447 break; 1448 1449 case DW_OP_GNU_convert: 1450 case DW_OP_GNU_reinterpret: 1451 { 1452 cu_offset type_die; 1453 struct type *type; 1454 1455 op_ptr = safe_read_uleb128 (op_ptr, op_end, &uoffset); 1456 type_die.cu_off = uoffset; 1457 1458 if (type_die.cu_off == 0) 1459 type = address_type; 1460 else 1461 type = dwarf_get_base_type (ctx, type_die, 0); 1462 1463 result_val = dwarf_expr_fetch (ctx, 0); 1464 dwarf_expr_pop (ctx); 1465 1466 if (op == DW_OP_GNU_convert) 1467 result_val = value_cast (type, result_val); 1468 else if (type == value_type (result_val)) 1469 { 1470 /* Nothing. */ 1471 } 1472 else if (TYPE_LENGTH (type) 1473 != TYPE_LENGTH (value_type (result_val))) 1474 error (_("DW_OP_GNU_reinterpret has wrong size")); 1475 else 1476 result_val 1477 = value_from_contents (type, 1478 value_contents_all (result_val)); 1479 } 1480 break; 1481 1482 default: 1483 error (_("Unhandled dwarf expression opcode 0x%x"), op); 1484 } 1485 1486 /* Most things push a result value. */ 1487 gdb_assert (result_val != NULL); 1488 dwarf_expr_push (ctx, result_val, in_stack_memory); 1489 no_push: 1490 ; 1491 } 1492 1493 /* To simplify our main caller, if the result is an implicit 1494 pointer, then make a pieced value. This is ok because we can't 1495 have implicit pointers in contexts where pieces are invalid. */ 1496 if (ctx->location == DWARF_VALUE_IMPLICIT_POINTER) 1497 add_piece (ctx, 8 * ctx->addr_size, 0); 1498 1499 abort_expression: 1500 ctx->recursion_depth--; 1501 gdb_assert (ctx->recursion_depth >= 0); 1502 } 1503 1504 /* Stub dwarf_expr_context_funcs.get_frame_base implementation. */ 1505 1506 void 1507 ctx_no_get_frame_base (void *baton, const gdb_byte **start, size_t *length) 1508 { 1509 error (_("%s is invalid in this context"), "DW_OP_fbreg"); 1510 } 1511 1512 /* Stub dwarf_expr_context_funcs.get_frame_cfa implementation. */ 1513 1514 CORE_ADDR 1515 ctx_no_get_frame_cfa (void *baton) 1516 { 1517 error (_("%s is invalid in this context"), "DW_OP_call_frame_cfa"); 1518 } 1519 1520 /* Stub dwarf_expr_context_funcs.get_frame_pc implementation. */ 1521 1522 CORE_ADDR 1523 ctx_no_get_frame_pc (void *baton) 1524 { 1525 error (_("%s is invalid in this context"), "DW_OP_GNU_implicit_pointer"); 1526 } 1527 1528 /* Stub dwarf_expr_context_funcs.get_tls_address implementation. */ 1529 1530 CORE_ADDR 1531 ctx_no_get_tls_address (void *baton, CORE_ADDR offset) 1532 { 1533 error (_("%s is invalid in this context"), "DW_OP_GNU_push_tls_address"); 1534 } 1535 1536 /* Stub dwarf_expr_context_funcs.dwarf_call implementation. */ 1537 1538 void 1539 ctx_no_dwarf_call (struct dwarf_expr_context *ctx, cu_offset die_offset) 1540 { 1541 error (_("%s is invalid in this context"), "DW_OP_call*"); 1542 } 1543 1544 /* Stub dwarf_expr_context_funcs.get_base_type implementation. */ 1545 1546 struct type * 1547 ctx_no_get_base_type (struct dwarf_expr_context *ctx, cu_offset die) 1548 { 1549 error (_("Support for typed DWARF is not supported in this context")); 1550 } 1551 1552 /* Stub dwarf_expr_context_funcs.push_dwarf_block_entry_value 1553 implementation. */ 1554 1555 void 1556 ctx_no_push_dwarf_reg_entry_value (struct dwarf_expr_context *ctx, 1557 enum call_site_parameter_kind kind, 1558 union call_site_parameter_u kind_u, 1559 int deref_size) 1560 { 1561 internal_error (__FILE__, __LINE__, 1562 _("Support for DW_OP_GNU_entry_value is unimplemented")); 1563 } 1564 1565 /* Stub dwarf_expr_context_funcs.get_addr_index implementation. */ 1566 1567 CORE_ADDR 1568 ctx_no_get_addr_index (void *baton, unsigned int index) 1569 { 1570 error (_("%s is invalid in this context"), "DW_OP_GNU_addr_index"); 1571 } 1572 1573 /* Provide a prototype to silence -Wmissing-prototypes. */ 1574 extern initialize_file_ftype _initialize_dwarf2expr; 1575 1576 void 1577 _initialize_dwarf2expr (void) 1578 { 1579 dwarf_arch_cookie 1580 = gdbarch_data_register_post_init (dwarf_gdbarch_types_init); 1581 } 1582