loc.c revision 1.1.1.2
1 /* DWARF 2 location expression support for GDB. 2 3 Copyright (C) 2003-2023 Free Software Foundation, Inc. 4 5 Contributed by Daniel Jacobowitz, MontaVista Software, Inc. 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 "ui-out.h" 24 #include "value.h" 25 #include "frame.h" 26 #include "gdbcore.h" 27 #include "target.h" 28 #include "inferior.h" 29 #include "ax.h" 30 #include "ax-gdb.h" 31 #include "regcache.h" 32 #include "objfiles.h" 33 #include "block.h" 34 #include "gdbcmd.h" 35 #include "complaints.h" 36 #include "dwarf2.h" 37 #include "dwarf2/expr.h" 38 #include "dwarf2/loc.h" 39 #include "dwarf2/read.h" 40 #include "dwarf2/frame.h" 41 #include "dwarf2/leb.h" 42 #include "compile/compile.h" 43 #include "gdbsupport/selftest.h" 44 #include <algorithm> 45 #include <vector> 46 #include <unordered_set> 47 #include "gdbsupport/underlying.h" 48 #include "gdbsupport/byte-vector.h" 49 50 static struct value *dwarf2_evaluate_loc_desc_full 51 (struct type *type, frame_info_ptr frame, const gdb_byte *data, 52 size_t size, dwarf2_per_cu_data *per_cu, dwarf2_per_objfile *per_objfile, 53 struct type *subobj_type, LONGEST subobj_byte_offset, bool as_lval = true); 54 55 /* Until these have formal names, we define these here. 56 ref: http://gcc.gnu.org/wiki/DebugFission 57 Each entry in .debug_loc.dwo begins with a byte that describes the entry, 58 and is then followed by data specific to that entry. */ 59 60 enum debug_loc_kind 61 { 62 /* Indicates the end of the list of entries. */ 63 DEBUG_LOC_END_OF_LIST = 0, 64 65 /* This is followed by an unsigned LEB128 number that is an index into 66 .debug_addr and specifies the base address for all following entries. */ 67 DEBUG_LOC_BASE_ADDRESS = 1, 68 69 /* This is followed by two unsigned LEB128 numbers that are indices into 70 .debug_addr and specify the beginning and ending addresses, and then 71 a normal location expression as in .debug_loc. */ 72 DEBUG_LOC_START_END = 2, 73 74 /* This is followed by an unsigned LEB128 number that is an index into 75 .debug_addr and specifies the beginning address, and a 4 byte unsigned 76 number that specifies the length, and then a normal location expression 77 as in .debug_loc. */ 78 DEBUG_LOC_START_LENGTH = 3, 79 80 /* This is followed by two unsigned LEB128 operands. The values of these 81 operands are the starting and ending offsets, respectively, relative to 82 the applicable base address. */ 83 DEBUG_LOC_OFFSET_PAIR = 4, 84 85 /* An internal value indicating there is insufficient data. */ 86 DEBUG_LOC_BUFFER_OVERFLOW = -1, 87 88 /* An internal value indicating an invalid kind of entry was found. */ 89 DEBUG_LOC_INVALID_ENTRY = -2 90 }; 91 92 /* Helper function which throws an error if a synthetic pointer is 93 invalid. */ 94 95 void 96 invalid_synthetic_pointer (void) 97 { 98 error (_("access outside bounds of object " 99 "referenced via synthetic pointer")); 100 } 101 102 /* Decode the addresses in a non-dwo .debug_loc entry. 103 A pointer to the next byte to examine is returned in *NEW_PTR. 104 The encoded low,high addresses are return in *LOW,*HIGH. 105 The result indicates the kind of entry found. */ 106 107 static enum debug_loc_kind 108 decode_debug_loc_addresses (const gdb_byte *loc_ptr, const gdb_byte *buf_end, 109 const gdb_byte **new_ptr, 110 CORE_ADDR *low, CORE_ADDR *high, 111 enum bfd_endian byte_order, 112 unsigned int addr_size, 113 int signed_addr_p) 114 { 115 CORE_ADDR base_mask = ~(~(CORE_ADDR)1 << (addr_size * 8 - 1)); 116 117 if (buf_end - loc_ptr < 2 * addr_size) 118 return DEBUG_LOC_BUFFER_OVERFLOW; 119 120 if (signed_addr_p) 121 *low = extract_signed_integer (loc_ptr, addr_size, byte_order); 122 else 123 *low = extract_unsigned_integer (loc_ptr, addr_size, byte_order); 124 loc_ptr += addr_size; 125 126 if (signed_addr_p) 127 *high = extract_signed_integer (loc_ptr, addr_size, byte_order); 128 else 129 *high = extract_unsigned_integer (loc_ptr, addr_size, byte_order); 130 loc_ptr += addr_size; 131 132 *new_ptr = loc_ptr; 133 134 /* A base-address-selection entry. */ 135 if ((*low & base_mask) == base_mask) 136 return DEBUG_LOC_BASE_ADDRESS; 137 138 /* An end-of-list entry. */ 139 if (*low == 0 && *high == 0) 140 return DEBUG_LOC_END_OF_LIST; 141 142 /* We want the caller to apply the base address, so we must return 143 DEBUG_LOC_OFFSET_PAIR here. */ 144 return DEBUG_LOC_OFFSET_PAIR; 145 } 146 147 /* Decode the addresses in .debug_loclists entry. 148 A pointer to the next byte to examine is returned in *NEW_PTR. 149 The encoded low,high addresses are return in *LOW,*HIGH. 150 The result indicates the kind of entry found. */ 151 152 static enum debug_loc_kind 153 decode_debug_loclists_addresses (dwarf2_per_cu_data *per_cu, 154 dwarf2_per_objfile *per_objfile, 155 const gdb_byte *loc_ptr, 156 const gdb_byte *buf_end, 157 const gdb_byte **new_ptr, 158 CORE_ADDR *low, CORE_ADDR *high, 159 enum bfd_endian byte_order, 160 unsigned int addr_size, 161 int signed_addr_p) 162 { 163 uint64_t u64; 164 165 if (loc_ptr == buf_end) 166 return DEBUG_LOC_BUFFER_OVERFLOW; 167 168 switch (*loc_ptr++) 169 { 170 case DW_LLE_base_addressx: 171 *low = 0; 172 loc_ptr = gdb_read_uleb128 (loc_ptr, buf_end, &u64); 173 if (loc_ptr == NULL) 174 return DEBUG_LOC_BUFFER_OVERFLOW; 175 176 *high = dwarf2_read_addr_index (per_cu, per_objfile, u64); 177 *new_ptr = loc_ptr; 178 return DEBUG_LOC_BASE_ADDRESS; 179 180 case DW_LLE_startx_length: 181 loc_ptr = gdb_read_uleb128 (loc_ptr, buf_end, &u64); 182 if (loc_ptr == NULL) 183 return DEBUG_LOC_BUFFER_OVERFLOW; 184 185 *low = dwarf2_read_addr_index (per_cu, per_objfile, u64); 186 *high = *low; 187 loc_ptr = gdb_read_uleb128 (loc_ptr, buf_end, &u64); 188 if (loc_ptr == NULL) 189 return DEBUG_LOC_BUFFER_OVERFLOW; 190 191 *high += u64; 192 *new_ptr = loc_ptr; 193 return DEBUG_LOC_START_LENGTH; 194 195 case DW_LLE_start_length: 196 if (buf_end - loc_ptr < addr_size) 197 return DEBUG_LOC_BUFFER_OVERFLOW; 198 199 if (signed_addr_p) 200 *low = extract_signed_integer (loc_ptr, addr_size, byte_order); 201 else 202 *low = extract_unsigned_integer (loc_ptr, addr_size, byte_order); 203 204 loc_ptr += addr_size; 205 *high = *low; 206 207 loc_ptr = gdb_read_uleb128 (loc_ptr, buf_end, &u64); 208 if (loc_ptr == NULL) 209 return DEBUG_LOC_BUFFER_OVERFLOW; 210 211 *high += u64; 212 *new_ptr = loc_ptr; 213 return DEBUG_LOC_START_LENGTH; 214 215 case DW_LLE_end_of_list: 216 *new_ptr = loc_ptr; 217 return DEBUG_LOC_END_OF_LIST; 218 219 case DW_LLE_base_address: 220 if (loc_ptr + addr_size > buf_end) 221 return DEBUG_LOC_BUFFER_OVERFLOW; 222 223 if (signed_addr_p) 224 *high = extract_signed_integer (loc_ptr, addr_size, byte_order); 225 else 226 *high = extract_unsigned_integer (loc_ptr, addr_size, byte_order); 227 228 loc_ptr += addr_size; 229 *new_ptr = loc_ptr; 230 return DEBUG_LOC_BASE_ADDRESS; 231 232 case DW_LLE_offset_pair: 233 loc_ptr = gdb_read_uleb128 (loc_ptr, buf_end, &u64); 234 if (loc_ptr == NULL) 235 return DEBUG_LOC_BUFFER_OVERFLOW; 236 237 *low = u64; 238 loc_ptr = gdb_read_uleb128 (loc_ptr, buf_end, &u64); 239 if (loc_ptr == NULL) 240 return DEBUG_LOC_BUFFER_OVERFLOW; 241 242 *high = u64; 243 *new_ptr = loc_ptr; 244 return DEBUG_LOC_OFFSET_PAIR; 245 246 case DW_LLE_start_end: 247 if (loc_ptr + 2 * addr_size > buf_end) 248 return DEBUG_LOC_BUFFER_OVERFLOW; 249 250 if (signed_addr_p) 251 *low = extract_signed_integer (loc_ptr, addr_size, byte_order); 252 else 253 *low = extract_unsigned_integer (loc_ptr, addr_size, byte_order); 254 255 loc_ptr += addr_size; 256 if (signed_addr_p) 257 *high = extract_signed_integer (loc_ptr, addr_size, byte_order); 258 else 259 *high = extract_unsigned_integer (loc_ptr, addr_size, byte_order); 260 261 loc_ptr += addr_size; 262 *new_ptr = loc_ptr; 263 return DEBUG_LOC_START_END; 264 265 /* Following cases are not supported yet. */ 266 case DW_LLE_startx_endx: 267 case DW_LLE_default_location: 268 default: 269 return DEBUG_LOC_INVALID_ENTRY; 270 } 271 } 272 273 /* Decode the addresses in .debug_loc.dwo entry. 274 A pointer to the next byte to examine is returned in *NEW_PTR. 275 The encoded low,high addresses are return in *LOW,*HIGH. 276 The result indicates the kind of entry found. */ 277 278 static enum debug_loc_kind 279 decode_debug_loc_dwo_addresses (dwarf2_per_cu_data *per_cu, 280 dwarf2_per_objfile *per_objfile, 281 const gdb_byte *loc_ptr, 282 const gdb_byte *buf_end, 283 const gdb_byte **new_ptr, 284 CORE_ADDR *low, CORE_ADDR *high, 285 enum bfd_endian byte_order) 286 { 287 uint64_t low_index, high_index; 288 289 if (loc_ptr == buf_end) 290 return DEBUG_LOC_BUFFER_OVERFLOW; 291 292 switch (*loc_ptr++) 293 { 294 case DW_LLE_GNU_end_of_list_entry: 295 *new_ptr = loc_ptr; 296 return DEBUG_LOC_END_OF_LIST; 297 298 case DW_LLE_GNU_base_address_selection_entry: 299 *low = 0; 300 loc_ptr = gdb_read_uleb128 (loc_ptr, buf_end, &high_index); 301 if (loc_ptr == NULL) 302 return DEBUG_LOC_BUFFER_OVERFLOW; 303 304 *high = dwarf2_read_addr_index (per_cu, per_objfile, high_index); 305 *new_ptr = loc_ptr; 306 return DEBUG_LOC_BASE_ADDRESS; 307 308 case DW_LLE_GNU_start_end_entry: 309 loc_ptr = gdb_read_uleb128 (loc_ptr, buf_end, &low_index); 310 if (loc_ptr == NULL) 311 return DEBUG_LOC_BUFFER_OVERFLOW; 312 313 *low = dwarf2_read_addr_index (per_cu, per_objfile, low_index); 314 loc_ptr = gdb_read_uleb128 (loc_ptr, buf_end, &high_index); 315 if (loc_ptr == NULL) 316 return DEBUG_LOC_BUFFER_OVERFLOW; 317 318 *high = dwarf2_read_addr_index (per_cu, per_objfile, high_index); 319 *new_ptr = loc_ptr; 320 return DEBUG_LOC_START_END; 321 322 case DW_LLE_GNU_start_length_entry: 323 loc_ptr = gdb_read_uleb128 (loc_ptr, buf_end, &low_index); 324 if (loc_ptr == NULL) 325 return DEBUG_LOC_BUFFER_OVERFLOW; 326 327 *low = dwarf2_read_addr_index (per_cu, per_objfile, low_index); 328 if (loc_ptr + 4 > buf_end) 329 return DEBUG_LOC_BUFFER_OVERFLOW; 330 331 *high = *low; 332 *high += extract_unsigned_integer (loc_ptr, 4, byte_order); 333 *new_ptr = loc_ptr + 4; 334 return DEBUG_LOC_START_LENGTH; 335 336 default: 337 return DEBUG_LOC_INVALID_ENTRY; 338 } 339 } 340 341 /* A function for dealing with location lists. Given a 342 symbol baton (BATON) and a pc value (PC), find the appropriate 343 location expression, set *LOCEXPR_LENGTH, and return a pointer 344 to the beginning of the expression. Returns NULL on failure. 345 346 For now, only return the first matching location expression; there 347 can be more than one in the list. */ 348 349 const gdb_byte * 350 dwarf2_find_location_expression (struct dwarf2_loclist_baton *baton, 351 size_t *locexpr_length, CORE_ADDR pc) 352 { 353 dwarf2_per_objfile *per_objfile = baton->per_objfile; 354 struct objfile *objfile = per_objfile->objfile; 355 struct gdbarch *gdbarch = objfile->arch (); 356 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); 357 unsigned int addr_size = baton->per_cu->addr_size (); 358 int signed_addr_p = bfd_get_sign_extend_vma (objfile->obfd.get ()); 359 /* Adjustment for relocatable objects. */ 360 CORE_ADDR text_offset = baton->per_objfile->objfile->text_section_offset (); 361 CORE_ADDR base_address = baton->base_address; 362 const gdb_byte *loc_ptr, *buf_end; 363 364 loc_ptr = baton->data; 365 buf_end = baton->data + baton->size; 366 367 while (1) 368 { 369 CORE_ADDR low = 0, high = 0; /* init for gcc -Wall */ 370 int length; 371 enum debug_loc_kind kind; 372 const gdb_byte *new_ptr = NULL; /* init for gcc -Wall */ 373 374 if (baton->per_cu->version () < 5 && baton->from_dwo) 375 kind = decode_debug_loc_dwo_addresses (baton->per_cu, 376 baton->per_objfile, 377 loc_ptr, buf_end, &new_ptr, 378 &low, &high, byte_order); 379 else if (baton->per_cu->version () < 5) 380 kind = decode_debug_loc_addresses (loc_ptr, buf_end, &new_ptr, 381 &low, &high, 382 byte_order, addr_size, 383 signed_addr_p); 384 else 385 kind = decode_debug_loclists_addresses (baton->per_cu, 386 baton->per_objfile, 387 loc_ptr, buf_end, &new_ptr, 388 &low, &high, byte_order, 389 addr_size, signed_addr_p); 390 391 loc_ptr = new_ptr; 392 switch (kind) 393 { 394 case DEBUG_LOC_END_OF_LIST: 395 *locexpr_length = 0; 396 return NULL; 397 398 case DEBUG_LOC_BASE_ADDRESS: 399 base_address = high; 400 continue; 401 402 case DEBUG_LOC_START_END: 403 case DEBUG_LOC_START_LENGTH: 404 case DEBUG_LOC_OFFSET_PAIR: 405 break; 406 407 case DEBUG_LOC_BUFFER_OVERFLOW: 408 case DEBUG_LOC_INVALID_ENTRY: 409 error (_("dwarf2_find_location_expression: " 410 "Corrupted DWARF expression.")); 411 412 default: 413 gdb_assert_not_reached ("bad debug_loc_kind"); 414 } 415 416 /* Otherwise, a location expression entry. 417 If the entry is from a DWO, don't add base address: the entry is from 418 .debug_addr which already has the DWARF "base address". We still add 419 text offset in case we're debugging a PIE executable. However, if the 420 entry is DW_LLE_offset_pair from a DWO, add the base address as the 421 operands are offsets relative to the applicable base address. 422 If the entry is DW_LLE_start_end or DW_LLE_start_length, then 423 it already is an address, and we don't need to add the base. */ 424 low += text_offset; 425 high += text_offset; 426 if (!baton->from_dwo && kind == DEBUG_LOC_OFFSET_PAIR) 427 { 428 low += base_address; 429 high += base_address; 430 } 431 432 if (baton->per_cu->version () < 5) 433 { 434 length = extract_unsigned_integer (loc_ptr, 2, byte_order); 435 loc_ptr += 2; 436 } 437 else 438 { 439 unsigned int bytes_read; 440 441 length = read_unsigned_leb128 (NULL, loc_ptr, &bytes_read); 442 loc_ptr += bytes_read; 443 } 444 445 if (low == high && pc == low) 446 { 447 /* This is entry PC record present only at entry point 448 of a function. Verify it is really the function entry point. */ 449 450 const struct block *pc_block = block_for_pc (pc); 451 struct symbol *pc_func = NULL; 452 453 if (pc_block) 454 pc_func = block_linkage_function (pc_block); 455 456 if (pc_func && pc == pc_func->value_block ()->entry_pc ()) 457 { 458 *locexpr_length = length; 459 return loc_ptr; 460 } 461 } 462 463 if (pc >= low && pc < high) 464 { 465 *locexpr_length = length; 466 return loc_ptr; 467 } 468 469 loc_ptr += length; 470 } 471 } 472 473 /* Implement find_frame_base_location method for LOC_BLOCK functions using 474 DWARF expression for its DW_AT_frame_base. */ 475 476 static void 477 locexpr_find_frame_base_location (struct symbol *framefunc, CORE_ADDR pc, 478 const gdb_byte **start, size_t *length) 479 { 480 struct dwarf2_locexpr_baton *symbaton 481 = (struct dwarf2_locexpr_baton *) SYMBOL_LOCATION_BATON (framefunc); 482 483 *length = symbaton->size; 484 *start = symbaton->data; 485 } 486 487 /* Implement the struct symbol_block_ops::get_frame_base method for 488 LOC_BLOCK functions using a DWARF expression as its DW_AT_frame_base. */ 489 490 static CORE_ADDR 491 locexpr_get_frame_base (struct symbol *framefunc, frame_info_ptr frame) 492 { 493 struct gdbarch *gdbarch; 494 struct type *type; 495 struct dwarf2_locexpr_baton *dlbaton; 496 const gdb_byte *start; 497 size_t length; 498 struct value *result; 499 500 /* If this method is called, then FRAMEFUNC is supposed to be a DWARF block. 501 Thus, it's supposed to provide the find_frame_base_location method as 502 well. */ 503 gdb_assert (SYMBOL_BLOCK_OPS (framefunc)->find_frame_base_location != NULL); 504 505 gdbarch = get_frame_arch (frame); 506 type = builtin_type (gdbarch)->builtin_data_ptr; 507 dlbaton = (struct dwarf2_locexpr_baton *) SYMBOL_LOCATION_BATON (framefunc); 508 509 SYMBOL_BLOCK_OPS (framefunc)->find_frame_base_location 510 (framefunc, get_frame_pc (frame), &start, &length); 511 result = dwarf2_evaluate_loc_desc (type, frame, start, length, 512 dlbaton->per_cu, dlbaton->per_objfile); 513 514 /* The DW_AT_frame_base attribute contains a location description which 515 computes the base address itself. However, the call to 516 dwarf2_evaluate_loc_desc returns a value representing a variable at 517 that address. The frame base address is thus this variable's 518 address. */ 519 return value_address (result); 520 } 521 522 /* Vector for inferior functions as represented by LOC_BLOCK, if the inferior 523 function uses DWARF expression for its DW_AT_frame_base. */ 524 525 const struct symbol_block_ops dwarf2_block_frame_base_locexpr_funcs = 526 { 527 locexpr_find_frame_base_location, 528 locexpr_get_frame_base 529 }; 530 531 /* Implement find_frame_base_location method for LOC_BLOCK functions using 532 DWARF location list for its DW_AT_frame_base. */ 533 534 static void 535 loclist_find_frame_base_location (struct symbol *framefunc, CORE_ADDR pc, 536 const gdb_byte **start, size_t *length) 537 { 538 struct dwarf2_loclist_baton *symbaton 539 = (struct dwarf2_loclist_baton *) SYMBOL_LOCATION_BATON (framefunc); 540 541 *start = dwarf2_find_location_expression (symbaton, length, pc); 542 } 543 544 /* Implement the struct symbol_block_ops::get_frame_base method for 545 LOC_BLOCK functions using a DWARF location list as its DW_AT_frame_base. */ 546 547 static CORE_ADDR 548 loclist_get_frame_base (struct symbol *framefunc, frame_info_ptr frame) 549 { 550 struct gdbarch *gdbarch; 551 struct type *type; 552 struct dwarf2_loclist_baton *dlbaton; 553 const gdb_byte *start; 554 size_t length; 555 struct value *result; 556 557 /* If this method is called, then FRAMEFUNC is supposed to be a DWARF block. 558 Thus, it's supposed to provide the find_frame_base_location method as 559 well. */ 560 gdb_assert (SYMBOL_BLOCK_OPS (framefunc)->find_frame_base_location != NULL); 561 562 gdbarch = get_frame_arch (frame); 563 type = builtin_type (gdbarch)->builtin_data_ptr; 564 dlbaton = (struct dwarf2_loclist_baton *) SYMBOL_LOCATION_BATON (framefunc); 565 566 SYMBOL_BLOCK_OPS (framefunc)->find_frame_base_location 567 (framefunc, get_frame_pc (frame), &start, &length); 568 result = dwarf2_evaluate_loc_desc (type, frame, start, length, 569 dlbaton->per_cu, dlbaton->per_objfile); 570 571 /* The DW_AT_frame_base attribute contains a location description which 572 computes the base address itself. However, the call to 573 dwarf2_evaluate_loc_desc returns a value representing a variable at 574 that address. The frame base address is thus this variable's 575 address. */ 576 return value_address (result); 577 } 578 579 /* Vector for inferior functions as represented by LOC_BLOCK, if the inferior 580 function uses DWARF location list for its DW_AT_frame_base. */ 581 582 const struct symbol_block_ops dwarf2_block_frame_base_loclist_funcs = 583 { 584 loclist_find_frame_base_location, 585 loclist_get_frame_base 586 }; 587 588 /* See dwarf2/loc.h. */ 589 590 void 591 func_get_frame_base_dwarf_block (struct symbol *framefunc, CORE_ADDR pc, 592 const gdb_byte **start, size_t *length) 593 { 594 if (SYMBOL_BLOCK_OPS (framefunc) != NULL) 595 { 596 const struct symbol_block_ops *ops_block = SYMBOL_BLOCK_OPS (framefunc); 597 598 ops_block->find_frame_base_location (framefunc, pc, start, length); 599 } 600 else 601 *length = 0; 602 603 if (*length == 0) 604 error (_("Could not find the frame base for \"%s\"."), 605 framefunc->natural_name ()); 606 } 607 608 /* See loc.h. */ 609 610 value * 611 compute_var_value (const char *name) 612 { 613 struct block_symbol sym = lookup_symbol (name, nullptr, VAR_DOMAIN, 614 nullptr); 615 if (sym.symbol != nullptr) 616 return value_of_variable (sym.symbol, sym.block); 617 return nullptr; 618 } 619 620 /* See dwarf2/loc.h. */ 621 622 unsigned int entry_values_debug = 0; 623 624 /* Helper to set entry_values_debug. */ 625 626 static void 627 show_entry_values_debug (struct ui_file *file, int from_tty, 628 struct cmd_list_element *c, const char *value) 629 { 630 gdb_printf (file, 631 _("Entry values and tail call frames debugging is %s.\n"), 632 value); 633 } 634 635 /* See gdbtypes.h. */ 636 637 void 638 call_site_target::iterate_over_addresses 639 (struct gdbarch *call_site_gdbarch, 640 const struct call_site *call_site, 641 frame_info_ptr caller_frame, 642 iterate_ftype callback) const 643 { 644 switch (m_loc_kind) 645 { 646 case call_site_target::DWARF_BLOCK: 647 { 648 struct dwarf2_locexpr_baton *dwarf_block; 649 struct value *val; 650 struct type *caller_core_addr_type; 651 struct gdbarch *caller_arch; 652 653 dwarf_block = m_loc.dwarf_block; 654 if (dwarf_block == NULL) 655 { 656 struct bound_minimal_symbol msym; 657 658 msym = lookup_minimal_symbol_by_pc (call_site->pc () - 1); 659 throw_error (NO_ENTRY_VALUE_ERROR, 660 _("DW_AT_call_target is not specified at %s in %s"), 661 paddress (call_site_gdbarch, call_site->pc ()), 662 (msym.minsym == NULL ? "???" 663 : msym.minsym->print_name ())); 664 665 } 666 if (caller_frame == NULL) 667 { 668 struct bound_minimal_symbol msym; 669 670 msym = lookup_minimal_symbol_by_pc (call_site->pc () - 1); 671 throw_error (NO_ENTRY_VALUE_ERROR, 672 _("DW_AT_call_target DWARF block resolving " 673 "requires known frame which is currently not " 674 "available at %s in %s"), 675 paddress (call_site_gdbarch, call_site->pc ()), 676 (msym.minsym == NULL ? "???" 677 : msym.minsym->print_name ())); 678 679 } 680 caller_arch = get_frame_arch (caller_frame); 681 caller_core_addr_type = builtin_type (caller_arch)->builtin_func_ptr; 682 val = dwarf2_evaluate_loc_desc (caller_core_addr_type, caller_frame, 683 dwarf_block->data, dwarf_block->size, 684 dwarf_block->per_cu, 685 dwarf_block->per_objfile); 686 /* DW_AT_call_target is a DWARF expression, not a DWARF location. */ 687 if (VALUE_LVAL (val) == lval_memory) 688 callback (value_address (val)); 689 else 690 callback (value_as_address (val)); 691 } 692 break; 693 694 case call_site_target::PHYSNAME: 695 { 696 const char *physname; 697 struct bound_minimal_symbol msym; 698 699 physname = m_loc.physname; 700 701 /* Handle both the mangled and demangled PHYSNAME. */ 702 msym = lookup_minimal_symbol (physname, NULL, NULL); 703 if (msym.minsym == NULL) 704 { 705 msym = lookup_minimal_symbol_by_pc (call_site->pc () - 1); 706 throw_error (NO_ENTRY_VALUE_ERROR, 707 _("Cannot find function \"%s\" for a call site target " 708 "at %s in %s"), 709 physname, paddress (call_site_gdbarch, call_site->pc ()), 710 (msym.minsym == NULL ? "???" 711 : msym.minsym->print_name ())); 712 713 } 714 callback (msym.value_address ()); 715 } 716 break; 717 718 case call_site_target::PHYSADDR: 719 { 720 dwarf2_per_objfile *per_objfile = call_site->per_objfile; 721 compunit_symtab *cust = per_objfile->get_symtab (call_site->per_cu); 722 int sect_idx = cust->block_line_section (); 723 CORE_ADDR delta = per_objfile->objfile->section_offsets[sect_idx]; 724 725 callback (m_loc.physaddr + delta); 726 } 727 break; 728 729 case call_site_target::ADDRESSES: 730 { 731 dwarf2_per_objfile *per_objfile = call_site->per_objfile; 732 compunit_symtab *cust = per_objfile->get_symtab (call_site->per_cu); 733 int sect_idx = cust->block_line_section (); 734 CORE_ADDR delta = per_objfile->objfile->section_offsets[sect_idx]; 735 736 for (unsigned i = 0; i < m_loc.addresses.length; ++i) 737 callback (m_loc.addresses.values[i] + delta); 738 } 739 break; 740 741 default: 742 internal_error (_("invalid call site target kind")); 743 } 744 } 745 746 /* Convert function entry point exact address ADDR to the function which is 747 compliant with TAIL_CALL_LIST_COMPLETE condition. Throw 748 NO_ENTRY_VALUE_ERROR otherwise. */ 749 750 static struct symbol * 751 func_addr_to_tail_call_list (struct gdbarch *gdbarch, CORE_ADDR addr) 752 { 753 struct symbol *sym = find_pc_function (addr); 754 struct type *type; 755 756 if (sym == NULL || sym->value_block ()->entry_pc () != addr) 757 throw_error (NO_ENTRY_VALUE_ERROR, 758 _("DW_TAG_call_site resolving failed to find function " 759 "name for address %s"), 760 paddress (gdbarch, addr)); 761 762 type = sym->type (); 763 gdb_assert (type->code () == TYPE_CODE_FUNC); 764 gdb_assert (TYPE_SPECIFIC_FIELD (type) == TYPE_SPECIFIC_FUNC); 765 766 return sym; 767 } 768 769 /* Verify function with entry point exact address ADDR can never call itself 770 via its tail calls (incl. transitively). Throw NO_ENTRY_VALUE_ERROR if it 771 can call itself via tail calls. 772 773 If a funtion can tail call itself its entry value based parameters are 774 unreliable. There is no verification whether the value of some/all 775 parameters is unchanged through the self tail call, we expect if there is 776 a self tail call all the parameters can be modified. */ 777 778 static void 779 func_verify_no_selftailcall (struct gdbarch *gdbarch, CORE_ADDR verify_addr) 780 { 781 CORE_ADDR addr; 782 783 /* The verification is completely unordered. Track here function addresses 784 which still need to be iterated. */ 785 std::vector<CORE_ADDR> todo; 786 787 /* Track here CORE_ADDRs which were already visited. */ 788 std::unordered_set<CORE_ADDR> addr_hash; 789 790 todo.push_back (verify_addr); 791 while (!todo.empty ()) 792 { 793 struct symbol *func_sym; 794 struct call_site *call_site; 795 796 addr = todo.back (); 797 todo.pop_back (); 798 799 func_sym = func_addr_to_tail_call_list (gdbarch, addr); 800 801 for (call_site = TYPE_TAIL_CALL_LIST (func_sym->type ()); 802 call_site; call_site = call_site->tail_call_next) 803 { 804 /* CALLER_FRAME with registers is not available for tail-call jumped 805 frames. */ 806 call_site->iterate_over_addresses (gdbarch, nullptr, 807 [&] (CORE_ADDR target_addr) 808 { 809 if (target_addr == verify_addr) 810 { 811 struct bound_minimal_symbol msym; 812 813 msym = lookup_minimal_symbol_by_pc (verify_addr); 814 throw_error (NO_ENTRY_VALUE_ERROR, 815 _("DW_OP_entry_value resolving has found " 816 "function \"%s\" at %s can call itself via tail " 817 "calls"), 818 (msym.minsym == NULL ? "???" 819 : msym.minsym->print_name ()), 820 paddress (gdbarch, verify_addr)); 821 } 822 823 if (addr_hash.insert (target_addr).second) 824 todo.push_back (target_addr); 825 }); 826 } 827 } 828 } 829 830 /* Print user readable form of CALL_SITE->PC to gdb_stdlog. Used only for 831 ENTRY_VALUES_DEBUG. */ 832 833 static void 834 tailcall_dump (struct gdbarch *gdbarch, const struct call_site *call_site) 835 { 836 CORE_ADDR addr = call_site->pc (); 837 struct bound_minimal_symbol msym = lookup_minimal_symbol_by_pc (addr - 1); 838 839 gdb_printf (gdb_stdlog, " %s(%s)", paddress (gdbarch, addr), 840 (msym.minsym == NULL ? "???" 841 : msym.minsym->print_name ())); 842 843 } 844 845 /* Intersect RESULTP with CHAIN to keep RESULTP unambiguous, keep in RESULTP 846 only top callers and bottom callees which are present in both. GDBARCH is 847 used only for ENTRY_VALUES_DEBUG. RESULTP is NULL after return if there are 848 no remaining possibilities to provide unambiguous non-trivial result. 849 RESULTP should point to NULL on the first (initialization) call. Caller is 850 responsible for xfree of any RESULTP data. */ 851 852 static void 853 chain_candidate (struct gdbarch *gdbarch, 854 gdb::unique_xmalloc_ptr<struct call_site_chain> *resultp, 855 const std::vector<struct call_site *> &chain) 856 { 857 long length = chain.size (); 858 int callers, callees, idx; 859 860 if (*resultp == NULL) 861 { 862 /* Create the initial chain containing all the passed PCs. */ 863 864 struct call_site_chain *result 865 = ((struct call_site_chain *) 866 xmalloc (sizeof (*result) 867 + sizeof (*result->call_site) * (length - 1))); 868 result->length = length; 869 result->callers = result->callees = length; 870 if (!chain.empty ()) 871 memcpy (result->call_site, chain.data (), 872 sizeof (*result->call_site) * length); 873 resultp->reset (result); 874 875 if (entry_values_debug) 876 { 877 gdb_printf (gdb_stdlog, "tailcall: initial:"); 878 for (idx = 0; idx < length; idx++) 879 tailcall_dump (gdbarch, result->call_site[idx]); 880 gdb_putc ('\n', gdb_stdlog); 881 } 882 883 return; 884 } 885 886 if (entry_values_debug) 887 { 888 gdb_printf (gdb_stdlog, "tailcall: compare:"); 889 for (idx = 0; idx < length; idx++) 890 tailcall_dump (gdbarch, chain[idx]); 891 gdb_putc ('\n', gdb_stdlog); 892 } 893 894 /* Intersect callers. */ 895 896 callers = std::min ((long) (*resultp)->callers, length); 897 for (idx = 0; idx < callers; idx++) 898 if ((*resultp)->call_site[idx] != chain[idx]) 899 { 900 (*resultp)->callers = idx; 901 break; 902 } 903 904 /* Intersect callees. */ 905 906 callees = std::min ((long) (*resultp)->callees, length); 907 for (idx = 0; idx < callees; idx++) 908 if ((*resultp)->call_site[(*resultp)->length - 1 - idx] 909 != chain[length - 1 - idx]) 910 { 911 (*resultp)->callees = idx; 912 break; 913 } 914 915 if (entry_values_debug) 916 { 917 gdb_printf (gdb_stdlog, "tailcall: reduced:"); 918 for (idx = 0; idx < (*resultp)->callers; idx++) 919 tailcall_dump (gdbarch, (*resultp)->call_site[idx]); 920 gdb_puts (" |", gdb_stdlog); 921 for (idx = 0; idx < (*resultp)->callees; idx++) 922 tailcall_dump (gdbarch, 923 (*resultp)->call_site[(*resultp)->length 924 - (*resultp)->callees + idx]); 925 gdb_putc ('\n', gdb_stdlog); 926 } 927 928 if ((*resultp)->callers == 0 && (*resultp)->callees == 0) 929 { 930 /* There are no common callers or callees. It could be also a direct 931 call (which has length 0) with ambiguous possibility of an indirect 932 call - CALLERS == CALLEES == 0 is valid during the first allocation 933 but any subsequence processing of such entry means ambiguity. */ 934 resultp->reset (NULL); 935 return; 936 } 937 938 /* See call_site_find_chain_1 why there is no way to reach the bottom callee 939 PC again. In such case there must be two different code paths to reach 940 it. CALLERS + CALLEES equal to LENGTH in the case of self tail-call. */ 941 gdb_assert ((*resultp)->callers + (*resultp)->callees <= (*resultp)->length); 942 } 943 944 /* Recursively try to construct the call chain. GDBARCH, RESULTP, and 945 CHAIN are passed to chain_candidate. ADDR_HASH tracks which 946 addresses have already been seen along the current chain. 947 CALL_SITE is the call site to visit, and CALLEE_PC is the PC we're 948 trying to "reach". Returns false if an error has already been 949 detected and so an early return can be done. If it makes sense to 950 keep trying (even if no answer has yet been found), returns 951 true. */ 952 953 static bool 954 call_site_find_chain_2 955 (struct gdbarch *gdbarch, 956 gdb::unique_xmalloc_ptr<struct call_site_chain> *resultp, 957 std::vector<struct call_site *> &chain, 958 std::unordered_set<CORE_ADDR> &addr_hash, 959 struct call_site *call_site, 960 CORE_ADDR callee_pc) 961 { 962 std::vector<CORE_ADDR> addresses; 963 bool found_exact = false; 964 call_site->iterate_over_addresses (gdbarch, nullptr, 965 [&] (CORE_ADDR addr) 966 { 967 if (addr == callee_pc) 968 found_exact = true; 969 else 970 addresses.push_back (addr); 971 }); 972 973 if (found_exact) 974 { 975 chain_candidate (gdbarch, resultp, chain); 976 /* If RESULTP was reset, then chain_candidate failed, and so we 977 can tell our callers to early-return. */ 978 return *resultp != nullptr; 979 } 980 981 for (CORE_ADDR target_func_addr : addresses) 982 { 983 struct symbol *target_func 984 = func_addr_to_tail_call_list (gdbarch, target_func_addr); 985 for (struct call_site *target_call_site 986 = TYPE_TAIL_CALL_LIST (target_func->type ()); 987 target_call_site != nullptr; 988 target_call_site = target_call_site->tail_call_next) 989 { 990 if (addr_hash.insert (target_call_site->pc ()).second) 991 { 992 /* Successfully entered TARGET_CALL_SITE. */ 993 chain.push_back (target_call_site); 994 995 if (!call_site_find_chain_2 (gdbarch, resultp, chain, 996 addr_hash, target_call_site, 997 callee_pc)) 998 return false; 999 1000 size_t removed = addr_hash.erase (target_call_site->pc ()); 1001 gdb_assert (removed == 1); 1002 chain.pop_back (); 1003 } 1004 } 1005 } 1006 1007 return true; 1008 } 1009 1010 /* Create and return call_site_chain for CALLER_PC and CALLEE_PC. All 1011 the assumed frames between them use GDBARCH. Any unreliability 1012 results in thrown NO_ENTRY_VALUE_ERROR. */ 1013 1014 static gdb::unique_xmalloc_ptr<call_site_chain> 1015 call_site_find_chain_1 (struct gdbarch *gdbarch, CORE_ADDR caller_pc, 1016 CORE_ADDR callee_pc) 1017 { 1018 CORE_ADDR save_callee_pc = callee_pc; 1019 gdb::unique_xmalloc_ptr<struct call_site_chain> retval; 1020 struct call_site *call_site; 1021 1022 /* CHAIN contains only the intermediate CALL_SITEs. Neither CALLER_PC's 1023 call_site nor any possible call_site at CALLEE_PC's function is there. 1024 Any CALL_SITE in CHAIN will be iterated to its siblings - via 1025 TAIL_CALL_NEXT. This is inappropriate for CALLER_PC's call_site. */ 1026 std::vector<struct call_site *> chain; 1027 1028 /* A given call site may have multiple associated addresses. This 1029 can happen if, e.g., the caller is split by hot/cold 1030 partitioning. This vector tracks the ones we haven't visited 1031 yet. */ 1032 std::vector<std::vector<CORE_ADDR>> unvisited_addresses; 1033 1034 /* We are not interested in the specific PC inside the callee function. */ 1035 callee_pc = get_pc_function_start (callee_pc); 1036 if (callee_pc == 0) 1037 throw_error (NO_ENTRY_VALUE_ERROR, _("Unable to find function for PC %s"), 1038 paddress (gdbarch, save_callee_pc)); 1039 1040 /* Mark CALL_SITEs so we do not visit the same ones twice. */ 1041 std::unordered_set<CORE_ADDR> addr_hash; 1042 1043 /* Do not push CALL_SITE to CHAIN. Push there only the first tail call site 1044 at the target's function. All the possible tail call sites in the 1045 target's function will get iterated as already pushed into CHAIN via their 1046 TAIL_CALL_NEXT. */ 1047 call_site = call_site_for_pc (gdbarch, caller_pc); 1048 /* No need to check the return value here, because we no longer care 1049 about possible early returns. */ 1050 call_site_find_chain_2 (gdbarch, &retval, chain, addr_hash, call_site, 1051 callee_pc); 1052 1053 if (retval == NULL) 1054 { 1055 struct bound_minimal_symbol msym_caller, msym_callee; 1056 1057 msym_caller = lookup_minimal_symbol_by_pc (caller_pc); 1058 msym_callee = lookup_minimal_symbol_by_pc (callee_pc); 1059 throw_error (NO_ENTRY_VALUE_ERROR, 1060 _("There are no unambiguously determinable intermediate " 1061 "callers or callees between caller function \"%s\" at %s " 1062 "and callee function \"%s\" at %s"), 1063 (msym_caller.minsym == NULL 1064 ? "???" : msym_caller.minsym->print_name ()), 1065 paddress (gdbarch, caller_pc), 1066 (msym_callee.minsym == NULL 1067 ? "???" : msym_callee.minsym->print_name ()), 1068 paddress (gdbarch, callee_pc)); 1069 } 1070 1071 return retval; 1072 } 1073 1074 /* Create and return call_site_chain for CALLER_PC and CALLEE_PC. All the 1075 assumed frames between them use GDBARCH. If valid call_site_chain cannot be 1076 constructed return NULL. */ 1077 1078 gdb::unique_xmalloc_ptr<call_site_chain> 1079 call_site_find_chain (struct gdbarch *gdbarch, CORE_ADDR caller_pc, 1080 CORE_ADDR callee_pc) 1081 { 1082 gdb::unique_xmalloc_ptr<call_site_chain> retval; 1083 1084 try 1085 { 1086 retval = call_site_find_chain_1 (gdbarch, caller_pc, callee_pc); 1087 } 1088 catch (const gdb_exception_error &e) 1089 { 1090 if (e.error == NO_ENTRY_VALUE_ERROR) 1091 { 1092 if (entry_values_debug) 1093 exception_print (gdb_stdout, e); 1094 1095 return NULL; 1096 } 1097 else 1098 throw; 1099 } 1100 1101 return retval; 1102 } 1103 1104 /* Return 1 if KIND and KIND_U match PARAMETER. Return 0 otherwise. */ 1105 1106 static int 1107 call_site_parameter_matches (struct call_site_parameter *parameter, 1108 enum call_site_parameter_kind kind, 1109 union call_site_parameter_u kind_u) 1110 { 1111 if (kind == parameter->kind) 1112 switch (kind) 1113 { 1114 case CALL_SITE_PARAMETER_DWARF_REG: 1115 return kind_u.dwarf_reg == parameter->u.dwarf_reg; 1116 1117 case CALL_SITE_PARAMETER_FB_OFFSET: 1118 return kind_u.fb_offset == parameter->u.fb_offset; 1119 1120 case CALL_SITE_PARAMETER_PARAM_OFFSET: 1121 return kind_u.param_cu_off == parameter->u.param_cu_off; 1122 } 1123 return 0; 1124 } 1125 1126 /* See loc.h. */ 1127 1128 struct call_site_parameter * 1129 dwarf_expr_reg_to_entry_parameter (frame_info_ptr frame, 1130 enum call_site_parameter_kind kind, 1131 union call_site_parameter_u kind_u, 1132 dwarf2_per_cu_data **per_cu_return, 1133 dwarf2_per_objfile **per_objfile_return) 1134 { 1135 CORE_ADDR func_addr, caller_pc; 1136 struct gdbarch *gdbarch; 1137 frame_info_ptr caller_frame; 1138 struct call_site *call_site; 1139 int iparams; 1140 /* Initialize it just to avoid a GCC false warning. */ 1141 struct call_site_parameter *parameter = NULL; 1142 CORE_ADDR target_addr; 1143 1144 while (get_frame_type (frame) == INLINE_FRAME) 1145 { 1146 frame = get_prev_frame (frame); 1147 gdb_assert (frame != NULL); 1148 } 1149 1150 func_addr = get_frame_func (frame); 1151 gdbarch = get_frame_arch (frame); 1152 caller_frame = get_prev_frame (frame); 1153 if (gdbarch != frame_unwind_arch (frame)) 1154 { 1155 struct bound_minimal_symbol msym 1156 = lookup_minimal_symbol_by_pc (func_addr); 1157 struct gdbarch *caller_gdbarch = frame_unwind_arch (frame); 1158 1159 throw_error (NO_ENTRY_VALUE_ERROR, 1160 _("DW_OP_entry_value resolving callee gdbarch %s " 1161 "(of %s (%s)) does not match caller gdbarch %s"), 1162 gdbarch_bfd_arch_info (gdbarch)->printable_name, 1163 paddress (gdbarch, func_addr), 1164 (msym.minsym == NULL ? "???" 1165 : msym.minsym->print_name ()), 1166 gdbarch_bfd_arch_info (caller_gdbarch)->printable_name); 1167 } 1168 1169 if (caller_frame == NULL) 1170 { 1171 struct bound_minimal_symbol msym 1172 = lookup_minimal_symbol_by_pc (func_addr); 1173 1174 throw_error (NO_ENTRY_VALUE_ERROR, _("DW_OP_entry_value resolving " 1175 "requires caller of %s (%s)"), 1176 paddress (gdbarch, func_addr), 1177 (msym.minsym == NULL ? "???" 1178 : msym.minsym->print_name ())); 1179 } 1180 caller_pc = get_frame_pc (caller_frame); 1181 call_site = call_site_for_pc (gdbarch, caller_pc); 1182 1183 bool found = false; 1184 unsigned count = 0; 1185 call_site->iterate_over_addresses (gdbarch, caller_frame, 1186 [&] (CORE_ADDR addr) 1187 { 1188 /* Preserve any address. */ 1189 target_addr = addr; 1190 ++count; 1191 if (addr == func_addr) 1192 found = true; 1193 }); 1194 if (!found) 1195 { 1196 struct minimal_symbol *target_msym, *func_msym; 1197 1198 target_msym = lookup_minimal_symbol_by_pc (target_addr).minsym; 1199 func_msym = lookup_minimal_symbol_by_pc (func_addr).minsym; 1200 throw_error (NO_ENTRY_VALUE_ERROR, 1201 _("DW_OP_entry_value resolving expects callee %s at %s %s" 1202 "but the called frame is for %s at %s"), 1203 (target_msym == NULL ? "???" 1204 : target_msym->print_name ()), 1205 paddress (gdbarch, target_addr), 1206 (count > 0 1207 ? _("(but note there are multiple addresses not listed)") 1208 : ""), 1209 func_msym == NULL ? "???" : func_msym->print_name (), 1210 paddress (gdbarch, func_addr)); 1211 } 1212 1213 /* No entry value based parameters would be reliable if this function can 1214 call itself via tail calls. */ 1215 func_verify_no_selftailcall (gdbarch, func_addr); 1216 1217 for (iparams = 0; iparams < call_site->parameter_count; iparams++) 1218 { 1219 parameter = &call_site->parameter[iparams]; 1220 if (call_site_parameter_matches (parameter, kind, kind_u)) 1221 break; 1222 } 1223 if (iparams == call_site->parameter_count) 1224 { 1225 struct minimal_symbol *msym 1226 = lookup_minimal_symbol_by_pc (caller_pc).minsym; 1227 1228 /* DW_TAG_call_site_parameter will be missing just if GCC could not 1229 determine its value. */ 1230 throw_error (NO_ENTRY_VALUE_ERROR, _("Cannot find matching parameter " 1231 "at DW_TAG_call_site %s at %s"), 1232 paddress (gdbarch, caller_pc), 1233 msym == NULL ? "???" : msym->print_name ()); 1234 } 1235 1236 *per_cu_return = call_site->per_cu; 1237 *per_objfile_return = call_site->per_objfile; 1238 return parameter; 1239 } 1240 1241 /* Return value for PARAMETER matching DEREF_SIZE. If DEREF_SIZE is -1, return 1242 the normal DW_AT_call_value block. Otherwise return the 1243 DW_AT_call_data_value (dereferenced) block. 1244 1245 TYPE and CALLER_FRAME specify how to evaluate the DWARF block into returned 1246 struct value. 1247 1248 Function always returns non-NULL, non-optimized out value. It throws 1249 NO_ENTRY_VALUE_ERROR if it cannot resolve the value for any reason. */ 1250 1251 static struct value * 1252 dwarf_entry_parameter_to_value (struct call_site_parameter *parameter, 1253 CORE_ADDR deref_size, struct type *type, 1254 frame_info_ptr caller_frame, 1255 dwarf2_per_cu_data *per_cu, 1256 dwarf2_per_objfile *per_objfile) 1257 { 1258 const gdb_byte *data_src; 1259 size_t size; 1260 1261 data_src = deref_size == -1 ? parameter->value : parameter->data_value; 1262 size = deref_size == -1 ? parameter->value_size : parameter->data_value_size; 1263 1264 /* DEREF_SIZE size is not verified here. */ 1265 if (data_src == NULL) 1266 throw_error (NO_ENTRY_VALUE_ERROR, 1267 _("Cannot resolve DW_AT_call_data_value")); 1268 1269 return dwarf2_evaluate_loc_desc (type, caller_frame, data_src, size, per_cu, 1270 per_objfile, false); 1271 } 1272 1273 /* VALUE must be of type lval_computed with entry_data_value_funcs. Perform 1274 the indirect method on it, that is use its stored target value, the sole 1275 purpose of entry_data_value_funcs.. */ 1276 1277 static struct value * 1278 entry_data_value_coerce_ref (const struct value *value) 1279 { 1280 struct type *checked_type = check_typedef (value_type (value)); 1281 struct value *target_val; 1282 1283 if (!TYPE_IS_REFERENCE (checked_type)) 1284 return NULL; 1285 1286 target_val = (struct value *) value_computed_closure (value); 1287 value_incref (target_val); 1288 return target_val; 1289 } 1290 1291 /* Implement copy_closure. */ 1292 1293 static void * 1294 entry_data_value_copy_closure (const struct value *v) 1295 { 1296 struct value *target_val = (struct value *) value_computed_closure (v); 1297 1298 value_incref (target_val); 1299 return target_val; 1300 } 1301 1302 /* Implement free_closure. */ 1303 1304 static void 1305 entry_data_value_free_closure (struct value *v) 1306 { 1307 struct value *target_val = (struct value *) value_computed_closure (v); 1308 1309 value_decref (target_val); 1310 } 1311 1312 /* Vector for methods for an entry value reference where the referenced value 1313 is stored in the caller. On the first dereference use 1314 DW_AT_call_data_value in the caller. */ 1315 1316 static const struct lval_funcs entry_data_value_funcs = 1317 { 1318 NULL, /* read */ 1319 NULL, /* write */ 1320 nullptr, 1321 NULL, /* indirect */ 1322 entry_data_value_coerce_ref, 1323 NULL, /* check_synthetic_pointer */ 1324 entry_data_value_copy_closure, 1325 entry_data_value_free_closure 1326 }; 1327 1328 /* See dwarf2/loc.h. */ 1329 struct value * 1330 value_of_dwarf_reg_entry (struct type *type, frame_info_ptr frame, 1331 enum call_site_parameter_kind kind, 1332 union call_site_parameter_u kind_u) 1333 { 1334 struct type *checked_type = check_typedef (type); 1335 struct type *target_type = checked_type->target_type (); 1336 frame_info_ptr caller_frame = get_prev_frame (frame); 1337 struct value *outer_val, *target_val, *val; 1338 struct call_site_parameter *parameter; 1339 dwarf2_per_cu_data *caller_per_cu; 1340 dwarf2_per_objfile *caller_per_objfile; 1341 1342 parameter = dwarf_expr_reg_to_entry_parameter (frame, kind, kind_u, 1343 &caller_per_cu, 1344 &caller_per_objfile); 1345 1346 outer_val = dwarf_entry_parameter_to_value (parameter, -1 /* deref_size */, 1347 type, caller_frame, 1348 caller_per_cu, 1349 caller_per_objfile); 1350 1351 /* Check if DW_AT_call_data_value cannot be used. If it should be 1352 used and it is not available do not fall back to OUTER_VAL - dereferencing 1353 TYPE_CODE_REF with non-entry data value would give current value - not the 1354 entry value. */ 1355 1356 if (!TYPE_IS_REFERENCE (checked_type) 1357 || checked_type->target_type () == NULL) 1358 return outer_val; 1359 1360 target_val = dwarf_entry_parameter_to_value (parameter, 1361 target_type->length (), 1362 target_type, caller_frame, 1363 caller_per_cu, 1364 caller_per_objfile); 1365 1366 val = allocate_computed_value (type, &entry_data_value_funcs, 1367 release_value (target_val).release ()); 1368 1369 /* Copy the referencing pointer to the new computed value. */ 1370 memcpy (value_contents_raw (val).data (), 1371 value_contents_raw (outer_val).data (), 1372 checked_type->length ()); 1373 set_value_lazy (val, 0); 1374 1375 return val; 1376 } 1377 1378 /* Read parameter of TYPE at (callee) FRAME's function entry. DATA and 1379 SIZE are DWARF block used to match DW_AT_location at the caller's 1380 DW_TAG_call_site_parameter. 1381 1382 Function always returns non-NULL value. It throws NO_ENTRY_VALUE_ERROR if it 1383 cannot resolve the parameter for any reason. */ 1384 1385 static struct value * 1386 value_of_dwarf_block_entry (struct type *type, frame_info_ptr frame, 1387 const gdb_byte *block, size_t block_len) 1388 { 1389 union call_site_parameter_u kind_u; 1390 1391 kind_u.dwarf_reg = dwarf_block_to_dwarf_reg (block, block + block_len); 1392 if (kind_u.dwarf_reg != -1) 1393 return value_of_dwarf_reg_entry (type, frame, CALL_SITE_PARAMETER_DWARF_REG, 1394 kind_u); 1395 1396 if (dwarf_block_to_fb_offset (block, block + block_len, &kind_u.fb_offset)) 1397 return value_of_dwarf_reg_entry (type, frame, CALL_SITE_PARAMETER_FB_OFFSET, 1398 kind_u); 1399 1400 /* This can normally happen - throw NO_ENTRY_VALUE_ERROR to get the message 1401 suppressed during normal operation. The expression can be arbitrary if 1402 there is no caller-callee entry value binding expected. */ 1403 throw_error (NO_ENTRY_VALUE_ERROR, 1404 _("DWARF-2 expression error: DW_OP_entry_value is supported " 1405 "only for single DW_OP_reg* or for DW_OP_fbreg(*)")); 1406 } 1407 1408 /* Fetch a DW_AT_const_value through a synthetic pointer. */ 1409 1410 static struct value * 1411 fetch_const_value_from_synthetic_pointer (sect_offset die, LONGEST byte_offset, 1412 dwarf2_per_cu_data *per_cu, 1413 dwarf2_per_objfile *per_objfile, 1414 struct type *type) 1415 { 1416 struct value *result = NULL; 1417 const gdb_byte *bytes; 1418 LONGEST len; 1419 1420 auto_obstack temp_obstack; 1421 bytes = dwarf2_fetch_constant_bytes (die, per_cu, per_objfile, 1422 &temp_obstack, &len); 1423 1424 if (bytes != NULL) 1425 { 1426 if (byte_offset >= 0 1427 && byte_offset + type->target_type ()->length () <= len) 1428 { 1429 bytes += byte_offset; 1430 result = value_from_contents (type->target_type (), bytes); 1431 } 1432 else 1433 invalid_synthetic_pointer (); 1434 } 1435 else 1436 result = allocate_optimized_out_value (type->target_type ()); 1437 1438 return result; 1439 } 1440 1441 /* See loc.h. */ 1442 1443 struct value * 1444 indirect_synthetic_pointer (sect_offset die, LONGEST byte_offset, 1445 dwarf2_per_cu_data *per_cu, 1446 dwarf2_per_objfile *per_objfile, 1447 frame_info_ptr frame, struct type *type, 1448 bool resolve_abstract_p) 1449 { 1450 /* Fetch the location expression of the DIE we're pointing to. */ 1451 auto get_frame_address_in_block_wrapper = [frame] () 1452 { 1453 return get_frame_address_in_block (frame); 1454 }; 1455 struct dwarf2_locexpr_baton baton 1456 = dwarf2_fetch_die_loc_sect_off (die, per_cu, per_objfile, 1457 get_frame_address_in_block_wrapper, 1458 resolve_abstract_p); 1459 1460 /* Get type of pointed-to DIE. */ 1461 struct type *orig_type = dwarf2_fetch_die_type_sect_off (die, per_cu, 1462 per_objfile); 1463 if (orig_type == NULL) 1464 invalid_synthetic_pointer (); 1465 1466 /* If pointed-to DIE has a DW_AT_location, evaluate it and return the 1467 resulting value. Otherwise, it may have a DW_AT_const_value instead, 1468 or it may've been optimized out. */ 1469 if (baton.data != NULL) 1470 return dwarf2_evaluate_loc_desc_full (orig_type, frame, baton.data, 1471 baton.size, baton.per_cu, 1472 baton.per_objfile, 1473 type->target_type (), 1474 byte_offset); 1475 else 1476 return fetch_const_value_from_synthetic_pointer (die, byte_offset, per_cu, 1477 per_objfile, type); 1478 } 1479 1480 /* Evaluate a location description, starting at DATA and with length 1481 SIZE, to find the current location of variable of TYPE in the 1482 context of FRAME. If SUBOBJ_TYPE is non-NULL, return instead the 1483 location of the subobject of type SUBOBJ_TYPE at byte offset 1484 SUBOBJ_BYTE_OFFSET within the variable of type TYPE. */ 1485 1486 static struct value * 1487 dwarf2_evaluate_loc_desc_full (struct type *type, frame_info_ptr frame, 1488 const gdb_byte *data, size_t size, 1489 dwarf2_per_cu_data *per_cu, 1490 dwarf2_per_objfile *per_objfile, 1491 struct type *subobj_type, 1492 LONGEST subobj_byte_offset, 1493 bool as_lval) 1494 { 1495 if (subobj_type == NULL) 1496 { 1497 subobj_type = type; 1498 subobj_byte_offset = 0; 1499 } 1500 else if (subobj_byte_offset < 0) 1501 invalid_synthetic_pointer (); 1502 1503 if (size == 0) 1504 return allocate_optimized_out_value (subobj_type); 1505 1506 dwarf_expr_context ctx (per_objfile, per_cu->addr_size ()); 1507 1508 value *retval; 1509 scoped_value_mark free_values; 1510 1511 try 1512 { 1513 retval = ctx.evaluate (data, size, as_lval, per_cu, frame, nullptr, 1514 type, subobj_type, subobj_byte_offset); 1515 } 1516 catch (const gdb_exception_error &ex) 1517 { 1518 if (ex.error == NOT_AVAILABLE_ERROR) 1519 { 1520 free_values.free_to_mark (); 1521 retval = allocate_value (subobj_type); 1522 mark_value_bytes_unavailable (retval, 0, 1523 subobj_type->length ()); 1524 return retval; 1525 } 1526 else if (ex.error == NO_ENTRY_VALUE_ERROR) 1527 { 1528 if (entry_values_debug) 1529 exception_print (gdb_stdout, ex); 1530 free_values.free_to_mark (); 1531 return allocate_optimized_out_value (subobj_type); 1532 } 1533 else 1534 throw; 1535 } 1536 1537 /* We need to clean up all the values that are not needed any more. 1538 The problem with a value_ref_ptr class is that it disconnects the 1539 RETVAL from the value garbage collection, so we need to make 1540 a copy of that value on the stack to keep everything consistent. 1541 The value_ref_ptr will clean up after itself at the end of this block. */ 1542 value_ref_ptr value_holder = value_ref_ptr::new_reference (retval); 1543 free_values.free_to_mark (); 1544 1545 return value_copy (retval); 1546 } 1547 1548 /* The exported interface to dwarf2_evaluate_loc_desc_full; it always 1549 passes 0 as the byte_offset. */ 1550 1551 struct value * 1552 dwarf2_evaluate_loc_desc (struct type *type, frame_info_ptr frame, 1553 const gdb_byte *data, size_t size, 1554 dwarf2_per_cu_data *per_cu, 1555 dwarf2_per_objfile *per_objfile, bool as_lval) 1556 { 1557 return dwarf2_evaluate_loc_desc_full (type, frame, data, size, per_cu, 1558 per_objfile, NULL, 0, as_lval); 1559 } 1560 1561 /* Evaluates a dwarf expression and stores the result in VAL, 1562 expecting that the dwarf expression only produces a single 1563 CORE_ADDR. FRAME is the frame in which the expression is 1564 evaluated. ADDR_STACK is a context (location of a variable) and 1565 might be needed to evaluate the location expression. 1566 1567 PUSH_VALUES is an array of values to be pushed to the expression stack 1568 before evaluation starts. PUSH_VALUES[0] is pushed first, then 1569 PUSH_VALUES[1], and so on. 1570 1571 Returns 1 on success, 0 otherwise. */ 1572 1573 static int 1574 dwarf2_locexpr_baton_eval (const struct dwarf2_locexpr_baton *dlbaton, 1575 frame_info_ptr frame, 1576 const struct property_addr_info *addr_stack, 1577 CORE_ADDR *valp, 1578 gdb::array_view<CORE_ADDR> push_values, 1579 bool *is_reference) 1580 { 1581 if (dlbaton == NULL || dlbaton->size == 0) 1582 return 0; 1583 1584 dwarf2_per_objfile *per_objfile = dlbaton->per_objfile; 1585 dwarf2_per_cu_data *per_cu = dlbaton->per_cu; 1586 dwarf_expr_context ctx (per_objfile, per_cu->addr_size ()); 1587 1588 value *result; 1589 scoped_value_mark free_values; 1590 1591 /* Place any initial values onto the expression stack. */ 1592 for (const auto &val : push_values) 1593 ctx.push_address (val, false); 1594 1595 try 1596 { 1597 result = ctx.evaluate (dlbaton->data, dlbaton->size, 1598 true, per_cu, frame, addr_stack); 1599 } 1600 catch (const gdb_exception_error &ex) 1601 { 1602 if (ex.error == NOT_AVAILABLE_ERROR) 1603 { 1604 return 0; 1605 } 1606 else if (ex.error == NO_ENTRY_VALUE_ERROR) 1607 { 1608 if (entry_values_debug) 1609 exception_print (gdb_stdout, ex); 1610 return 0; 1611 } 1612 else 1613 throw; 1614 } 1615 1616 if (value_optimized_out (result)) 1617 return 0; 1618 1619 if (VALUE_LVAL (result) == lval_memory) 1620 *valp = value_address (result); 1621 else 1622 { 1623 if (VALUE_LVAL (result) == not_lval) 1624 *is_reference = false; 1625 1626 *valp = value_as_address (result); 1627 } 1628 1629 return 1; 1630 } 1631 1632 /* See dwarf2/loc.h. */ 1633 1634 bool 1635 dwarf2_evaluate_property (const struct dynamic_prop *prop, 1636 frame_info_ptr frame, 1637 const struct property_addr_info *addr_stack, 1638 CORE_ADDR *value, 1639 gdb::array_view<CORE_ADDR> push_values) 1640 { 1641 if (prop == NULL) 1642 return false; 1643 1644 if (frame == NULL && has_stack_frames ()) 1645 frame = get_selected_frame (NULL); 1646 1647 switch (prop->kind ()) 1648 { 1649 case PROP_LOCEXPR: 1650 { 1651 const struct dwarf2_property_baton *baton 1652 = (const struct dwarf2_property_baton *) prop->baton (); 1653 gdb_assert (baton->property_type != NULL); 1654 1655 bool is_reference = baton->locexpr.is_reference; 1656 if (dwarf2_locexpr_baton_eval (&baton->locexpr, frame, addr_stack, 1657 value, push_values, &is_reference)) 1658 { 1659 if (is_reference) 1660 { 1661 struct value *val = value_at (baton->property_type, *value); 1662 *value = value_as_address (val); 1663 } 1664 else 1665 { 1666 gdb_assert (baton->property_type != NULL); 1667 1668 struct type *type = check_typedef (baton->property_type); 1669 if (type->length () < sizeof (CORE_ADDR) 1670 && !type->is_unsigned ()) 1671 { 1672 /* If we have a valid return candidate and it's value 1673 is signed, we have to sign-extend the value because 1674 CORE_ADDR on 64bit machine has 8 bytes but address 1675 size of an 32bit application is bytes. */ 1676 const int addr_size 1677 = (baton->locexpr.per_cu->addr_size () 1678 * TARGET_CHAR_BIT); 1679 const CORE_ADDR neg_mask 1680 = (~((CORE_ADDR) 0) << (addr_size - 1)); 1681 1682 /* Check if signed bit is set and sign-extend values. */ 1683 if (*value & neg_mask) 1684 *value |= neg_mask; 1685 } 1686 } 1687 return true; 1688 } 1689 } 1690 break; 1691 1692 case PROP_LOCLIST: 1693 { 1694 struct dwarf2_property_baton *baton 1695 = (struct dwarf2_property_baton *) prop->baton (); 1696 CORE_ADDR pc; 1697 const gdb_byte *data; 1698 struct value *val; 1699 size_t size; 1700 1701 if (frame == NULL 1702 || !get_frame_address_in_block_if_available (frame, &pc)) 1703 return false; 1704 1705 data = dwarf2_find_location_expression (&baton->loclist, &size, pc); 1706 if (data != NULL) 1707 { 1708 val = dwarf2_evaluate_loc_desc (baton->property_type, frame, data, 1709 size, baton->loclist.per_cu, 1710 baton->loclist.per_objfile); 1711 if (!value_optimized_out (val)) 1712 { 1713 *value = value_as_address (val); 1714 return true; 1715 } 1716 } 1717 } 1718 break; 1719 1720 case PROP_CONST: 1721 *value = prop->const_val (); 1722 return true; 1723 1724 case PROP_ADDR_OFFSET: 1725 { 1726 struct dwarf2_property_baton *baton 1727 = (struct dwarf2_property_baton *) prop->baton (); 1728 const struct property_addr_info *pinfo; 1729 struct value *val; 1730 1731 for (pinfo = addr_stack; pinfo != NULL; pinfo = pinfo->next) 1732 { 1733 /* This approach lets us avoid checking the qualifiers. */ 1734 if (TYPE_MAIN_TYPE (pinfo->type) 1735 == TYPE_MAIN_TYPE (baton->property_type)) 1736 break; 1737 } 1738 if (pinfo == NULL) 1739 error (_("cannot find reference address for offset property")); 1740 if (pinfo->valaddr.data () != NULL) 1741 val = value_from_contents 1742 (baton->offset_info.type, 1743 pinfo->valaddr.data () + baton->offset_info.offset); 1744 else 1745 val = value_at (baton->offset_info.type, 1746 pinfo->addr + baton->offset_info.offset); 1747 *value = value_as_address (val); 1748 return true; 1749 } 1750 1751 case PROP_VARIABLE_NAME: 1752 { 1753 struct value *val = compute_var_value (prop->variable_name ()); 1754 if (val != nullptr) 1755 { 1756 *value = value_as_long (val); 1757 return true; 1758 } 1759 } 1760 break; 1761 } 1762 1763 return false; 1764 } 1765 1766 /* See dwarf2/loc.h. */ 1767 1768 void 1769 dwarf2_compile_property_to_c (string_file *stream, 1770 const char *result_name, 1771 struct gdbarch *gdbarch, 1772 std::vector<bool> ®isters_used, 1773 const struct dynamic_prop *prop, 1774 CORE_ADDR pc, 1775 struct symbol *sym) 1776 { 1777 struct dwarf2_property_baton *baton 1778 = (struct dwarf2_property_baton *) prop->baton (); 1779 const gdb_byte *data; 1780 size_t size; 1781 dwarf2_per_cu_data *per_cu; 1782 dwarf2_per_objfile *per_objfile; 1783 1784 if (prop->kind () == PROP_LOCEXPR) 1785 { 1786 data = baton->locexpr.data; 1787 size = baton->locexpr.size; 1788 per_cu = baton->locexpr.per_cu; 1789 per_objfile = baton->locexpr.per_objfile; 1790 } 1791 else 1792 { 1793 gdb_assert (prop->kind () == PROP_LOCLIST); 1794 1795 data = dwarf2_find_location_expression (&baton->loclist, &size, pc); 1796 per_cu = baton->loclist.per_cu; 1797 per_objfile = baton->loclist.per_objfile; 1798 } 1799 1800 compile_dwarf_bounds_to_c (stream, result_name, prop, sym, pc, 1801 gdbarch, registers_used, 1802 per_cu->addr_size (), 1803 data, data + size, per_cu, per_objfile); 1804 } 1805 1806 /* Compute the correct symbol_needs_kind value for the location 1807 expression in EXPR. 1808 1809 Implemented by traversing the logical control flow graph of the 1810 expression. */ 1811 1812 static enum symbol_needs_kind 1813 dwarf2_get_symbol_read_needs (gdb::array_view<const gdb_byte> expr, 1814 dwarf2_per_cu_data *per_cu, 1815 dwarf2_per_objfile *per_objfile, 1816 bfd_endian byte_order, 1817 int addr_size, 1818 int ref_addr_size, 1819 int depth = 0) 1820 { 1821 enum symbol_needs_kind symbol_needs = SYMBOL_NEEDS_NONE; 1822 1823 /* If the expression is empty, we have nothing to do. */ 1824 if (expr.empty ()) 1825 return symbol_needs; 1826 1827 const gdb_byte *expr_end = expr.data () + expr.size (); 1828 1829 /* List of operations to visit. Operations in this list are not visited yet, 1830 so are not in VISITED_OPS (and vice-versa). */ 1831 std::vector<const gdb_byte *> ops_to_visit; 1832 1833 /* Operations already visited. */ 1834 std::unordered_set<const gdb_byte *> visited_ops; 1835 1836 /* Insert OP in OPS_TO_VISIT if it is within the expression's range and 1837 hasn't been visited yet. */ 1838 auto insert_in_ops_to_visit 1839 = [expr_end, &visited_ops, &ops_to_visit] (const gdb_byte *op_ptr) 1840 { 1841 if (op_ptr >= expr_end) 1842 return; 1843 1844 if (visited_ops.find (op_ptr) != visited_ops.end ()) 1845 return; 1846 1847 ops_to_visit.push_back (op_ptr); 1848 }; 1849 1850 /* Expressions can invoke other expressions with DW_OP_call*. Protect against 1851 a loop of calls. */ 1852 const int max_depth = 256; 1853 1854 if (depth > max_depth) 1855 error (_("DWARF-2 expression error: Loop detected.")); 1856 1857 depth++; 1858 1859 /* Initialize the to-visit list with the first operation. */ 1860 insert_in_ops_to_visit (&expr[0]); 1861 1862 while (!ops_to_visit.empty ()) 1863 { 1864 /* Pop one op to visit, mark it as visited. */ 1865 const gdb_byte *op_ptr = ops_to_visit.back (); 1866 ops_to_visit.pop_back (); 1867 gdb_assert (visited_ops.find (op_ptr) == visited_ops.end ()); 1868 visited_ops.insert (op_ptr); 1869 1870 dwarf_location_atom op = (dwarf_location_atom) *op_ptr; 1871 1872 /* Most operations have a single possible following operation 1873 (they are not conditional branches). The code below updates 1874 OP_PTR to point to that following operation, which is pushed 1875 back to OPS_TO_VISIT, if needed, at the bottom. Here, leave 1876 OP_PTR pointing just after the operand. */ 1877 op_ptr++; 1878 1879 /* The DWARF expression might have a bug causing an infinite 1880 loop. In that case, quitting is the only way out. */ 1881 QUIT; 1882 1883 switch (op) 1884 { 1885 case DW_OP_lit0: 1886 case DW_OP_lit1: 1887 case DW_OP_lit2: 1888 case DW_OP_lit3: 1889 case DW_OP_lit4: 1890 case DW_OP_lit5: 1891 case DW_OP_lit6: 1892 case DW_OP_lit7: 1893 case DW_OP_lit8: 1894 case DW_OP_lit9: 1895 case DW_OP_lit10: 1896 case DW_OP_lit11: 1897 case DW_OP_lit12: 1898 case DW_OP_lit13: 1899 case DW_OP_lit14: 1900 case DW_OP_lit15: 1901 case DW_OP_lit16: 1902 case DW_OP_lit17: 1903 case DW_OP_lit18: 1904 case DW_OP_lit19: 1905 case DW_OP_lit20: 1906 case DW_OP_lit21: 1907 case DW_OP_lit22: 1908 case DW_OP_lit23: 1909 case DW_OP_lit24: 1910 case DW_OP_lit25: 1911 case DW_OP_lit26: 1912 case DW_OP_lit27: 1913 case DW_OP_lit28: 1914 case DW_OP_lit29: 1915 case DW_OP_lit30: 1916 case DW_OP_lit31: 1917 case DW_OP_stack_value: 1918 case DW_OP_dup: 1919 case DW_OP_drop: 1920 case DW_OP_swap: 1921 case DW_OP_over: 1922 case DW_OP_rot: 1923 case DW_OP_deref: 1924 case DW_OP_abs: 1925 case DW_OP_neg: 1926 case DW_OP_not: 1927 case DW_OP_and: 1928 case DW_OP_div: 1929 case DW_OP_minus: 1930 case DW_OP_mod: 1931 case DW_OP_mul: 1932 case DW_OP_or: 1933 case DW_OP_plus: 1934 case DW_OP_shl: 1935 case DW_OP_shr: 1936 case DW_OP_shra: 1937 case DW_OP_xor: 1938 case DW_OP_le: 1939 case DW_OP_ge: 1940 case DW_OP_eq: 1941 case DW_OP_lt: 1942 case DW_OP_gt: 1943 case DW_OP_ne: 1944 case DW_OP_GNU_push_tls_address: 1945 case DW_OP_nop: 1946 case DW_OP_GNU_uninit: 1947 case DW_OP_push_object_address: 1948 break; 1949 1950 case DW_OP_form_tls_address: 1951 if (symbol_needs <= SYMBOL_NEEDS_REGISTERS) 1952 symbol_needs = SYMBOL_NEEDS_REGISTERS; 1953 break; 1954 1955 case DW_OP_convert: 1956 case DW_OP_GNU_convert: 1957 case DW_OP_reinterpret: 1958 case DW_OP_GNU_reinterpret: 1959 case DW_OP_addrx: 1960 case DW_OP_GNU_addr_index: 1961 case DW_OP_GNU_const_index: 1962 case DW_OP_constu: 1963 case DW_OP_plus_uconst: 1964 case DW_OP_piece: 1965 op_ptr = safe_skip_leb128 (op_ptr, expr_end); 1966 break; 1967 1968 case DW_OP_consts: 1969 op_ptr = safe_skip_leb128 (op_ptr, expr_end); 1970 break; 1971 1972 case DW_OP_bit_piece: 1973 op_ptr = safe_skip_leb128 (op_ptr, expr_end); 1974 op_ptr = safe_skip_leb128 (op_ptr, expr_end); 1975 break; 1976 1977 case DW_OP_deref_type: 1978 case DW_OP_GNU_deref_type: 1979 op_ptr++; 1980 op_ptr = safe_skip_leb128 (op_ptr, expr_end); 1981 break; 1982 1983 case DW_OP_addr: 1984 op_ptr += addr_size; 1985 break; 1986 1987 case DW_OP_const1u: 1988 case DW_OP_const1s: 1989 op_ptr += 1; 1990 break; 1991 1992 case DW_OP_const2u: 1993 case DW_OP_const2s: 1994 op_ptr += 2; 1995 break; 1996 1997 case DW_OP_const4s: 1998 case DW_OP_const4u: 1999 op_ptr += 4; 2000 break; 2001 2002 case DW_OP_const8s: 2003 case DW_OP_const8u: 2004 op_ptr += 8; 2005 break; 2006 2007 case DW_OP_reg0: 2008 case DW_OP_reg1: 2009 case DW_OP_reg2: 2010 case DW_OP_reg3: 2011 case DW_OP_reg4: 2012 case DW_OP_reg5: 2013 case DW_OP_reg6: 2014 case DW_OP_reg7: 2015 case DW_OP_reg8: 2016 case DW_OP_reg9: 2017 case DW_OP_reg10: 2018 case DW_OP_reg11: 2019 case DW_OP_reg12: 2020 case DW_OP_reg13: 2021 case DW_OP_reg14: 2022 case DW_OP_reg15: 2023 case DW_OP_reg16: 2024 case DW_OP_reg17: 2025 case DW_OP_reg18: 2026 case DW_OP_reg19: 2027 case DW_OP_reg20: 2028 case DW_OP_reg21: 2029 case DW_OP_reg22: 2030 case DW_OP_reg23: 2031 case DW_OP_reg24: 2032 case DW_OP_reg25: 2033 case DW_OP_reg26: 2034 case DW_OP_reg27: 2035 case DW_OP_reg28: 2036 case DW_OP_reg29: 2037 case DW_OP_reg30: 2038 case DW_OP_reg31: 2039 case DW_OP_regx: 2040 case DW_OP_breg0: 2041 case DW_OP_breg1: 2042 case DW_OP_breg2: 2043 case DW_OP_breg3: 2044 case DW_OP_breg4: 2045 case DW_OP_breg5: 2046 case DW_OP_breg6: 2047 case DW_OP_breg7: 2048 case DW_OP_breg8: 2049 case DW_OP_breg9: 2050 case DW_OP_breg10: 2051 case DW_OP_breg11: 2052 case DW_OP_breg12: 2053 case DW_OP_breg13: 2054 case DW_OP_breg14: 2055 case DW_OP_breg15: 2056 case DW_OP_breg16: 2057 case DW_OP_breg17: 2058 case DW_OP_breg18: 2059 case DW_OP_breg19: 2060 case DW_OP_breg20: 2061 case DW_OP_breg21: 2062 case DW_OP_breg22: 2063 case DW_OP_breg23: 2064 case DW_OP_breg24: 2065 case DW_OP_breg25: 2066 case DW_OP_breg26: 2067 case DW_OP_breg27: 2068 case DW_OP_breg28: 2069 case DW_OP_breg29: 2070 case DW_OP_breg30: 2071 case DW_OP_breg31: 2072 case DW_OP_bregx: 2073 case DW_OP_fbreg: 2074 case DW_OP_call_frame_cfa: 2075 case DW_OP_entry_value: 2076 case DW_OP_GNU_entry_value: 2077 case DW_OP_GNU_parameter_ref: 2078 case DW_OP_regval_type: 2079 case DW_OP_GNU_regval_type: 2080 symbol_needs = SYMBOL_NEEDS_FRAME; 2081 break; 2082 2083 case DW_OP_implicit_value: 2084 { 2085 uint64_t uoffset; 2086 op_ptr = safe_read_uleb128 (op_ptr, expr_end, &uoffset); 2087 op_ptr += uoffset; 2088 break; 2089 } 2090 2091 case DW_OP_implicit_pointer: 2092 case DW_OP_GNU_implicit_pointer: 2093 op_ptr += ref_addr_size; 2094 op_ptr = safe_skip_leb128 (op_ptr, expr_end); 2095 break; 2096 2097 case DW_OP_deref_size: 2098 case DW_OP_pick: 2099 op_ptr++; 2100 break; 2101 2102 case DW_OP_skip: 2103 { 2104 int64_t offset = extract_signed_integer (op_ptr, 2, byte_order); 2105 op_ptr += 2; 2106 op_ptr += offset; 2107 break; 2108 } 2109 2110 case DW_OP_bra: 2111 { 2112 /* This is the only operation that pushes two operations in 2113 the to-visit list, so handle it all here. */ 2114 LONGEST offset = extract_signed_integer (op_ptr, 2, byte_order); 2115 op_ptr += 2; 2116 2117 insert_in_ops_to_visit (op_ptr + offset); 2118 insert_in_ops_to_visit (op_ptr); 2119 continue; 2120 } 2121 2122 case DW_OP_call2: 2123 case DW_OP_call4: 2124 { 2125 unsigned int len = op == DW_OP_call2 ? 2 : 4; 2126 cu_offset cu_off 2127 = (cu_offset) extract_unsigned_integer (op_ptr, len, byte_order); 2128 op_ptr += len; 2129 2130 auto get_frame_pc = [&symbol_needs] () 2131 { 2132 symbol_needs = SYMBOL_NEEDS_FRAME; 2133 return 0; 2134 }; 2135 2136 struct dwarf2_locexpr_baton baton 2137 = dwarf2_fetch_die_loc_cu_off (cu_off, per_cu, 2138 per_objfile, 2139 get_frame_pc); 2140 2141 /* If SYMBOL_NEEDS_FRAME is returned from the previous call, 2142 we dont have to check the baton content. */ 2143 if (symbol_needs != SYMBOL_NEEDS_FRAME) 2144 { 2145 gdbarch *arch = baton.per_objfile->objfile->arch (); 2146 gdb::array_view<const gdb_byte> sub_expr (baton.data, 2147 baton.size); 2148 symbol_needs 2149 = dwarf2_get_symbol_read_needs (sub_expr, 2150 baton.per_cu, 2151 baton.per_objfile, 2152 gdbarch_byte_order (arch), 2153 baton.per_cu->addr_size (), 2154 baton.per_cu->ref_addr_size (), 2155 depth); 2156 } 2157 break; 2158 } 2159 2160 case DW_OP_GNU_variable_value: 2161 { 2162 sect_offset sect_off 2163 = (sect_offset) extract_unsigned_integer (op_ptr, 2164 ref_addr_size, 2165 byte_order); 2166 op_ptr += ref_addr_size; 2167 2168 struct type *die_type 2169 = dwarf2_fetch_die_type_sect_off (sect_off, per_cu, 2170 per_objfile); 2171 2172 if (die_type == NULL) 2173 error (_("Bad DW_OP_GNU_variable_value DIE.")); 2174 2175 /* Note: Things still work when the following test is 2176 removed. This test and error is here to conform to the 2177 proposed specification. */ 2178 if (die_type->code () != TYPE_CODE_INT 2179 && die_type->code () != TYPE_CODE_PTR) 2180 error (_("Type of DW_OP_GNU_variable_value DIE must be " 2181 "an integer or pointer.")); 2182 2183 auto get_frame_pc = [&symbol_needs] () 2184 { 2185 symbol_needs = SYMBOL_NEEDS_FRAME; 2186 return 0; 2187 }; 2188 2189 struct dwarf2_locexpr_baton baton 2190 = dwarf2_fetch_die_loc_sect_off (sect_off, per_cu, 2191 per_objfile, 2192 get_frame_pc, true); 2193 2194 /* If SYMBOL_NEEDS_FRAME is returned from the previous call, 2195 we dont have to check the baton content. */ 2196 if (symbol_needs != SYMBOL_NEEDS_FRAME) 2197 { 2198 gdbarch *arch = baton.per_objfile->objfile->arch (); 2199 gdb::array_view<const gdb_byte> sub_expr (baton.data, 2200 baton.size); 2201 symbol_needs 2202 = dwarf2_get_symbol_read_needs (sub_expr, 2203 baton.per_cu, 2204 baton.per_objfile, 2205 gdbarch_byte_order (arch), 2206 baton.per_cu->addr_size (), 2207 baton.per_cu->ref_addr_size (), 2208 depth); 2209 } 2210 break; 2211 } 2212 2213 case DW_OP_const_type: 2214 case DW_OP_GNU_const_type: 2215 { 2216 uint64_t uoffset; 2217 op_ptr = safe_read_uleb128 (op_ptr, expr_end, &uoffset); 2218 gdb_byte offset = *op_ptr++; 2219 op_ptr += offset; 2220 break; 2221 } 2222 2223 default: 2224 error (_("Unhandled DWARF expression opcode 0x%x"), op); 2225 } 2226 2227 /* If it is known that a frame information is 2228 needed we can stop parsing the expression. */ 2229 if (symbol_needs == SYMBOL_NEEDS_FRAME) 2230 break; 2231 2232 insert_in_ops_to_visit (op_ptr); 2233 } 2234 2235 return symbol_needs; 2236 } 2237 2238 /* A helper function that throws an unimplemented error mentioning a 2239 given DWARF operator. */ 2240 2241 static void ATTRIBUTE_NORETURN 2242 unimplemented (unsigned int op) 2243 { 2244 const char *name = get_DW_OP_name (op); 2245 2246 if (name) 2247 error (_("DWARF operator %s cannot be translated to an agent expression"), 2248 name); 2249 else 2250 error (_("Unknown DWARF operator 0x%02x cannot be translated " 2251 "to an agent expression"), 2252 op); 2253 } 2254 2255 /* See dwarf2/loc.h. 2256 2257 This is basically a wrapper on gdbarch_dwarf2_reg_to_regnum so that we 2258 can issue a complaint, which is better than having every target's 2259 implementation of dwarf2_reg_to_regnum do it. */ 2260 2261 int 2262 dwarf_reg_to_regnum (struct gdbarch *arch, int dwarf_reg) 2263 { 2264 int reg = gdbarch_dwarf2_reg_to_regnum (arch, dwarf_reg); 2265 2266 if (reg == -1) 2267 { 2268 complaint (_("bad DWARF register number %d"), dwarf_reg); 2269 } 2270 return reg; 2271 } 2272 2273 /* Subroutine of dwarf_reg_to_regnum_or_error to simplify it. 2274 Throw an error because DWARF_REG is bad. */ 2275 2276 static void 2277 throw_bad_regnum_error (ULONGEST dwarf_reg) 2278 { 2279 /* Still want to print -1 as "-1". 2280 We *could* have int and ULONGEST versions of dwarf2_reg_to_regnum_or_error 2281 but that's overkill for now. */ 2282 if ((int) dwarf_reg == dwarf_reg) 2283 error (_("Unable to access DWARF register number %d"), (int) dwarf_reg); 2284 error (_("Unable to access DWARF register number %s"), 2285 pulongest (dwarf_reg)); 2286 } 2287 2288 /* See dwarf2/loc.h. */ 2289 2290 int 2291 dwarf_reg_to_regnum_or_error (struct gdbarch *arch, ULONGEST dwarf_reg) 2292 { 2293 int reg; 2294 2295 if (dwarf_reg > INT_MAX) 2296 throw_bad_regnum_error (dwarf_reg); 2297 /* Yes, we will end up issuing a complaint and an error if DWARF_REG is 2298 bad, but that's ok. */ 2299 reg = dwarf_reg_to_regnum (arch, (int) dwarf_reg); 2300 if (reg == -1) 2301 throw_bad_regnum_error (dwarf_reg); 2302 return reg; 2303 } 2304 2305 /* A helper function that emits an access to memory. ARCH is the 2306 target architecture. EXPR is the expression which we are building. 2307 NBITS is the number of bits we want to read. This emits the 2308 opcodes needed to read the memory and then extract the desired 2309 bits. */ 2310 2311 static void 2312 access_memory (struct gdbarch *arch, struct agent_expr *expr, ULONGEST nbits) 2313 { 2314 ULONGEST nbytes = (nbits + 7) / 8; 2315 2316 gdb_assert (nbytes > 0 && nbytes <= sizeof (LONGEST)); 2317 2318 if (expr->tracing) 2319 ax_trace_quick (expr, nbytes); 2320 2321 if (nbits <= 8) 2322 ax_simple (expr, aop_ref8); 2323 else if (nbits <= 16) 2324 ax_simple (expr, aop_ref16); 2325 else if (nbits <= 32) 2326 ax_simple (expr, aop_ref32); 2327 else 2328 ax_simple (expr, aop_ref64); 2329 2330 /* If we read exactly the number of bytes we wanted, we're done. */ 2331 if (8 * nbytes == nbits) 2332 return; 2333 2334 if (gdbarch_byte_order (arch) == BFD_ENDIAN_BIG) 2335 { 2336 /* On a bits-big-endian machine, we want the high-order 2337 NBITS. */ 2338 ax_const_l (expr, 8 * nbytes - nbits); 2339 ax_simple (expr, aop_rsh_unsigned); 2340 } 2341 else 2342 { 2343 /* On a bits-little-endian box, we want the low-order NBITS. */ 2344 ax_zero_ext (expr, nbits); 2345 } 2346 } 2347 2348 /* Compile a DWARF location expression to an agent expression. 2349 2350 EXPR is the agent expression we are building. 2351 LOC is the agent value we modify. 2352 ARCH is the architecture. 2353 ADDR_SIZE is the size of addresses, in bytes. 2354 OP_PTR is the start of the location expression. 2355 OP_END is one past the last byte of the location expression. 2356 2357 This will throw an exception for various kinds of errors -- for 2358 example, if the expression cannot be compiled, or if the expression 2359 is invalid. */ 2360 2361 static void 2362 dwarf2_compile_expr_to_ax (struct agent_expr *expr, struct axs_value *loc, 2363 unsigned int addr_size, const gdb_byte *op_ptr, 2364 const gdb_byte *op_end, 2365 dwarf2_per_cu_data *per_cu, 2366 dwarf2_per_objfile *per_objfile) 2367 { 2368 gdbarch *arch = expr->gdbarch; 2369 std::vector<int> dw_labels, patches; 2370 const gdb_byte * const base = op_ptr; 2371 const gdb_byte *previous_piece = op_ptr; 2372 enum bfd_endian byte_order = gdbarch_byte_order (arch); 2373 ULONGEST bits_collected = 0; 2374 unsigned int addr_size_bits = 8 * addr_size; 2375 bool bits_big_endian = byte_order == BFD_ENDIAN_BIG; 2376 2377 std::vector<int> offsets (op_end - op_ptr, -1); 2378 2379 /* By default we are making an address. */ 2380 loc->kind = axs_lvalue_memory; 2381 2382 while (op_ptr < op_end) 2383 { 2384 enum dwarf_location_atom op = (enum dwarf_location_atom) *op_ptr; 2385 uint64_t uoffset, reg; 2386 int64_t offset; 2387 int i; 2388 2389 offsets[op_ptr - base] = expr->len; 2390 ++op_ptr; 2391 2392 /* Our basic approach to code generation is to map DWARF 2393 operations directly to AX operations. However, there are 2394 some differences. 2395 2396 First, DWARF works on address-sized units, but AX always uses 2397 LONGEST. For most operations we simply ignore this 2398 difference; instead we generate sign extensions as needed 2399 before division and comparison operations. It would be nice 2400 to omit the sign extensions, but there is no way to determine 2401 the size of the target's LONGEST. (This code uses the size 2402 of the host LONGEST in some cases -- that is a bug but it is 2403 difficult to fix.) 2404 2405 Second, some DWARF operations cannot be translated to AX. 2406 For these we simply fail. See 2407 http://sourceware.org/bugzilla/show_bug.cgi?id=11662. */ 2408 switch (op) 2409 { 2410 case DW_OP_lit0: 2411 case DW_OP_lit1: 2412 case DW_OP_lit2: 2413 case DW_OP_lit3: 2414 case DW_OP_lit4: 2415 case DW_OP_lit5: 2416 case DW_OP_lit6: 2417 case DW_OP_lit7: 2418 case DW_OP_lit8: 2419 case DW_OP_lit9: 2420 case DW_OP_lit10: 2421 case DW_OP_lit11: 2422 case DW_OP_lit12: 2423 case DW_OP_lit13: 2424 case DW_OP_lit14: 2425 case DW_OP_lit15: 2426 case DW_OP_lit16: 2427 case DW_OP_lit17: 2428 case DW_OP_lit18: 2429 case DW_OP_lit19: 2430 case DW_OP_lit20: 2431 case DW_OP_lit21: 2432 case DW_OP_lit22: 2433 case DW_OP_lit23: 2434 case DW_OP_lit24: 2435 case DW_OP_lit25: 2436 case DW_OP_lit26: 2437 case DW_OP_lit27: 2438 case DW_OP_lit28: 2439 case DW_OP_lit29: 2440 case DW_OP_lit30: 2441 case DW_OP_lit31: 2442 ax_const_l (expr, op - DW_OP_lit0); 2443 break; 2444 2445 case DW_OP_addr: 2446 uoffset = extract_unsigned_integer (op_ptr, addr_size, byte_order); 2447 op_ptr += addr_size; 2448 /* Some versions of GCC emit DW_OP_addr before 2449 DW_OP_GNU_push_tls_address. In this case the value is an 2450 index, not an address. We don't support things like 2451 branching between the address and the TLS op. */ 2452 if (op_ptr >= op_end || *op_ptr != DW_OP_GNU_push_tls_address) 2453 uoffset += per_objfile->objfile->text_section_offset (); 2454 ax_const_l (expr, uoffset); 2455 break; 2456 2457 case DW_OP_const1u: 2458 ax_const_l (expr, extract_unsigned_integer (op_ptr, 1, byte_order)); 2459 op_ptr += 1; 2460 break; 2461 2462 case DW_OP_const1s: 2463 ax_const_l (expr, extract_signed_integer (op_ptr, 1, byte_order)); 2464 op_ptr += 1; 2465 break; 2466 2467 case DW_OP_const2u: 2468 ax_const_l (expr, extract_unsigned_integer (op_ptr, 2, byte_order)); 2469 op_ptr += 2; 2470 break; 2471 2472 case DW_OP_const2s: 2473 ax_const_l (expr, extract_signed_integer (op_ptr, 2, byte_order)); 2474 op_ptr += 2; 2475 break; 2476 2477 case DW_OP_const4u: 2478 ax_const_l (expr, extract_unsigned_integer (op_ptr, 4, byte_order)); 2479 op_ptr += 4; 2480 break; 2481 2482 case DW_OP_const4s: 2483 ax_const_l (expr, extract_signed_integer (op_ptr, 4, byte_order)); 2484 op_ptr += 4; 2485 break; 2486 2487 case DW_OP_const8u: 2488 ax_const_l (expr, extract_unsigned_integer (op_ptr, 8, byte_order)); 2489 op_ptr += 8; 2490 break; 2491 2492 case DW_OP_const8s: 2493 ax_const_l (expr, extract_signed_integer (op_ptr, 8, byte_order)); 2494 op_ptr += 8; 2495 break; 2496 2497 case DW_OP_constu: 2498 op_ptr = safe_read_uleb128 (op_ptr, op_end, &uoffset); 2499 ax_const_l (expr, uoffset); 2500 break; 2501 2502 case DW_OP_consts: 2503 op_ptr = safe_read_sleb128 (op_ptr, op_end, &offset); 2504 ax_const_l (expr, offset); 2505 break; 2506 2507 case DW_OP_reg0: 2508 case DW_OP_reg1: 2509 case DW_OP_reg2: 2510 case DW_OP_reg3: 2511 case DW_OP_reg4: 2512 case DW_OP_reg5: 2513 case DW_OP_reg6: 2514 case DW_OP_reg7: 2515 case DW_OP_reg8: 2516 case DW_OP_reg9: 2517 case DW_OP_reg10: 2518 case DW_OP_reg11: 2519 case DW_OP_reg12: 2520 case DW_OP_reg13: 2521 case DW_OP_reg14: 2522 case DW_OP_reg15: 2523 case DW_OP_reg16: 2524 case DW_OP_reg17: 2525 case DW_OP_reg18: 2526 case DW_OP_reg19: 2527 case DW_OP_reg20: 2528 case DW_OP_reg21: 2529 case DW_OP_reg22: 2530 case DW_OP_reg23: 2531 case DW_OP_reg24: 2532 case DW_OP_reg25: 2533 case DW_OP_reg26: 2534 case DW_OP_reg27: 2535 case DW_OP_reg28: 2536 case DW_OP_reg29: 2537 case DW_OP_reg30: 2538 case DW_OP_reg31: 2539 dwarf_expr_require_composition (op_ptr, op_end, "DW_OP_regx"); 2540 loc->u.reg = dwarf_reg_to_regnum_or_error (arch, op - DW_OP_reg0); 2541 loc->kind = axs_lvalue_register; 2542 break; 2543 2544 case DW_OP_regx: 2545 op_ptr = safe_read_uleb128 (op_ptr, op_end, ®); 2546 dwarf_expr_require_composition (op_ptr, op_end, "DW_OP_regx"); 2547 loc->u.reg = dwarf_reg_to_regnum_or_error (arch, reg); 2548 loc->kind = axs_lvalue_register; 2549 break; 2550 2551 case DW_OP_implicit_value: 2552 { 2553 uint64_t len; 2554 2555 op_ptr = safe_read_uleb128 (op_ptr, op_end, &len); 2556 if (op_ptr + len > op_end) 2557 error (_("DW_OP_implicit_value: too few bytes available.")); 2558 if (len > sizeof (ULONGEST)) 2559 error (_("Cannot translate DW_OP_implicit_value of %d bytes"), 2560 (int) len); 2561 2562 ax_const_l (expr, extract_unsigned_integer (op_ptr, len, 2563 byte_order)); 2564 op_ptr += len; 2565 dwarf_expr_require_composition (op_ptr, op_end, 2566 "DW_OP_implicit_value"); 2567 2568 loc->kind = axs_rvalue; 2569 } 2570 break; 2571 2572 case DW_OP_stack_value: 2573 dwarf_expr_require_composition (op_ptr, op_end, "DW_OP_stack_value"); 2574 loc->kind = axs_rvalue; 2575 break; 2576 2577 case DW_OP_breg0: 2578 case DW_OP_breg1: 2579 case DW_OP_breg2: 2580 case DW_OP_breg3: 2581 case DW_OP_breg4: 2582 case DW_OP_breg5: 2583 case DW_OP_breg6: 2584 case DW_OP_breg7: 2585 case DW_OP_breg8: 2586 case DW_OP_breg9: 2587 case DW_OP_breg10: 2588 case DW_OP_breg11: 2589 case DW_OP_breg12: 2590 case DW_OP_breg13: 2591 case DW_OP_breg14: 2592 case DW_OP_breg15: 2593 case DW_OP_breg16: 2594 case DW_OP_breg17: 2595 case DW_OP_breg18: 2596 case DW_OP_breg19: 2597 case DW_OP_breg20: 2598 case DW_OP_breg21: 2599 case DW_OP_breg22: 2600 case DW_OP_breg23: 2601 case DW_OP_breg24: 2602 case DW_OP_breg25: 2603 case DW_OP_breg26: 2604 case DW_OP_breg27: 2605 case DW_OP_breg28: 2606 case DW_OP_breg29: 2607 case DW_OP_breg30: 2608 case DW_OP_breg31: 2609 op_ptr = safe_read_sleb128 (op_ptr, op_end, &offset); 2610 i = dwarf_reg_to_regnum_or_error (arch, op - DW_OP_breg0); 2611 ax_reg (expr, i); 2612 if (offset != 0) 2613 { 2614 ax_const_l (expr, offset); 2615 ax_simple (expr, aop_add); 2616 } 2617 break; 2618 2619 case DW_OP_bregx: 2620 { 2621 op_ptr = safe_read_uleb128 (op_ptr, op_end, ®); 2622 op_ptr = safe_read_sleb128 (op_ptr, op_end, &offset); 2623 i = dwarf_reg_to_regnum_or_error (arch, reg); 2624 ax_reg (expr, i); 2625 if (offset != 0) 2626 { 2627 ax_const_l (expr, offset); 2628 ax_simple (expr, aop_add); 2629 } 2630 } 2631 break; 2632 2633 case DW_OP_fbreg: 2634 { 2635 const gdb_byte *datastart; 2636 size_t datalen; 2637 const struct block *b; 2638 struct symbol *framefunc; 2639 2640 b = block_for_pc (expr->scope); 2641 2642 if (!b) 2643 error (_("No block found for address")); 2644 2645 framefunc = block_linkage_function (b); 2646 2647 if (!framefunc) 2648 error (_("No function found for block")); 2649 2650 func_get_frame_base_dwarf_block (framefunc, expr->scope, 2651 &datastart, &datalen); 2652 2653 op_ptr = safe_read_sleb128 (op_ptr, op_end, &offset); 2654 dwarf2_compile_expr_to_ax (expr, loc, addr_size, datastart, 2655 datastart + datalen, per_cu, 2656 per_objfile); 2657 if (loc->kind == axs_lvalue_register) 2658 require_rvalue (expr, loc); 2659 2660 if (offset != 0) 2661 { 2662 ax_const_l (expr, offset); 2663 ax_simple (expr, aop_add); 2664 } 2665 2666 loc->kind = axs_lvalue_memory; 2667 } 2668 break; 2669 2670 case DW_OP_dup: 2671 ax_simple (expr, aop_dup); 2672 break; 2673 2674 case DW_OP_drop: 2675 ax_simple (expr, aop_pop); 2676 break; 2677 2678 case DW_OP_pick: 2679 offset = *op_ptr++; 2680 ax_pick (expr, offset); 2681 break; 2682 2683 case DW_OP_swap: 2684 ax_simple (expr, aop_swap); 2685 break; 2686 2687 case DW_OP_over: 2688 ax_pick (expr, 1); 2689 break; 2690 2691 case DW_OP_rot: 2692 ax_simple (expr, aop_rot); 2693 break; 2694 2695 case DW_OP_deref: 2696 case DW_OP_deref_size: 2697 { 2698 int size; 2699 2700 if (op == DW_OP_deref_size) 2701 size = *op_ptr++; 2702 else 2703 size = addr_size; 2704 2705 if (size != 1 && size != 2 && size != 4 && size != 8) 2706 error (_("Unsupported size %d in %s"), 2707 size, get_DW_OP_name (op)); 2708 access_memory (arch, expr, size * TARGET_CHAR_BIT); 2709 } 2710 break; 2711 2712 case DW_OP_abs: 2713 /* Sign extend the operand. */ 2714 ax_ext (expr, addr_size_bits); 2715 ax_simple (expr, aop_dup); 2716 ax_const_l (expr, 0); 2717 ax_simple (expr, aop_less_signed); 2718 ax_simple (expr, aop_log_not); 2719 i = ax_goto (expr, aop_if_goto); 2720 /* We have to emit 0 - X. */ 2721 ax_const_l (expr, 0); 2722 ax_simple (expr, aop_swap); 2723 ax_simple (expr, aop_sub); 2724 ax_label (expr, i, expr->len); 2725 break; 2726 2727 case DW_OP_neg: 2728 /* No need to sign extend here. */ 2729 ax_const_l (expr, 0); 2730 ax_simple (expr, aop_swap); 2731 ax_simple (expr, aop_sub); 2732 break; 2733 2734 case DW_OP_not: 2735 /* Sign extend the operand. */ 2736 ax_ext (expr, addr_size_bits); 2737 ax_simple (expr, aop_bit_not); 2738 break; 2739 2740 case DW_OP_plus_uconst: 2741 op_ptr = safe_read_uleb128 (op_ptr, op_end, ®); 2742 /* It would be really weird to emit `DW_OP_plus_uconst 0', 2743 but we micro-optimize anyhow. */ 2744 if (reg != 0) 2745 { 2746 ax_const_l (expr, reg); 2747 ax_simple (expr, aop_add); 2748 } 2749 break; 2750 2751 case DW_OP_and: 2752 ax_simple (expr, aop_bit_and); 2753 break; 2754 2755 case DW_OP_div: 2756 /* Sign extend the operands. */ 2757 ax_ext (expr, addr_size_bits); 2758 ax_simple (expr, aop_swap); 2759 ax_ext (expr, addr_size_bits); 2760 ax_simple (expr, aop_swap); 2761 ax_simple (expr, aop_div_signed); 2762 break; 2763 2764 case DW_OP_minus: 2765 ax_simple (expr, aop_sub); 2766 break; 2767 2768 case DW_OP_mod: 2769 ax_simple (expr, aop_rem_unsigned); 2770 break; 2771 2772 case DW_OP_mul: 2773 ax_simple (expr, aop_mul); 2774 break; 2775 2776 case DW_OP_or: 2777 ax_simple (expr, aop_bit_or); 2778 break; 2779 2780 case DW_OP_plus: 2781 ax_simple (expr, aop_add); 2782 break; 2783 2784 case DW_OP_shl: 2785 ax_simple (expr, aop_lsh); 2786 break; 2787 2788 case DW_OP_shr: 2789 ax_simple (expr, aop_rsh_unsigned); 2790 break; 2791 2792 case DW_OP_shra: 2793 ax_simple (expr, aop_rsh_signed); 2794 break; 2795 2796 case DW_OP_xor: 2797 ax_simple (expr, aop_bit_xor); 2798 break; 2799 2800 case DW_OP_le: 2801 /* Sign extend the operands. */ 2802 ax_ext (expr, addr_size_bits); 2803 ax_simple (expr, aop_swap); 2804 ax_ext (expr, addr_size_bits); 2805 /* Note no swap here: A <= B is !(B < A). */ 2806 ax_simple (expr, aop_less_signed); 2807 ax_simple (expr, aop_log_not); 2808 break; 2809 2810 case DW_OP_ge: 2811 /* Sign extend the operands. */ 2812 ax_ext (expr, addr_size_bits); 2813 ax_simple (expr, aop_swap); 2814 ax_ext (expr, addr_size_bits); 2815 ax_simple (expr, aop_swap); 2816 /* A >= B is !(A < B). */ 2817 ax_simple (expr, aop_less_signed); 2818 ax_simple (expr, aop_log_not); 2819 break; 2820 2821 case DW_OP_eq: 2822 /* Sign extend the operands. */ 2823 ax_ext (expr, addr_size_bits); 2824 ax_simple (expr, aop_swap); 2825 ax_ext (expr, addr_size_bits); 2826 /* No need for a second swap here. */ 2827 ax_simple (expr, aop_equal); 2828 break; 2829 2830 case DW_OP_lt: 2831 /* Sign extend the operands. */ 2832 ax_ext (expr, addr_size_bits); 2833 ax_simple (expr, aop_swap); 2834 ax_ext (expr, addr_size_bits); 2835 ax_simple (expr, aop_swap); 2836 ax_simple (expr, aop_less_signed); 2837 break; 2838 2839 case DW_OP_gt: 2840 /* Sign extend the operands. */ 2841 ax_ext (expr, addr_size_bits); 2842 ax_simple (expr, aop_swap); 2843 ax_ext (expr, addr_size_bits); 2844 /* Note no swap here: A > B is B < A. */ 2845 ax_simple (expr, aop_less_signed); 2846 break; 2847 2848 case DW_OP_ne: 2849 /* Sign extend the operands. */ 2850 ax_ext (expr, addr_size_bits); 2851 ax_simple (expr, aop_swap); 2852 ax_ext (expr, addr_size_bits); 2853 /* No need for a swap here. */ 2854 ax_simple (expr, aop_equal); 2855 ax_simple (expr, aop_log_not); 2856 break; 2857 2858 case DW_OP_call_frame_cfa: 2859 { 2860 int regnum; 2861 CORE_ADDR text_offset; 2862 LONGEST off; 2863 const gdb_byte *cfa_start, *cfa_end; 2864 2865 if (dwarf2_fetch_cfa_info (arch, expr->scope, per_cu, 2866 ®num, &off, 2867 &text_offset, &cfa_start, &cfa_end)) 2868 { 2869 /* Register. */ 2870 ax_reg (expr, regnum); 2871 if (off != 0) 2872 { 2873 ax_const_l (expr, off); 2874 ax_simple (expr, aop_add); 2875 } 2876 } 2877 else 2878 { 2879 /* Another expression. */ 2880 ax_const_l (expr, text_offset); 2881 dwarf2_compile_expr_to_ax (expr, loc, addr_size, cfa_start, 2882 cfa_end, per_cu, per_objfile); 2883 } 2884 2885 loc->kind = axs_lvalue_memory; 2886 } 2887 break; 2888 2889 case DW_OP_GNU_push_tls_address: 2890 case DW_OP_form_tls_address: 2891 unimplemented (op); 2892 break; 2893 2894 case DW_OP_push_object_address: 2895 unimplemented (op); 2896 break; 2897 2898 case DW_OP_skip: 2899 offset = extract_signed_integer (op_ptr, 2, byte_order); 2900 op_ptr += 2; 2901 i = ax_goto (expr, aop_goto); 2902 dw_labels.push_back (op_ptr + offset - base); 2903 patches.push_back (i); 2904 break; 2905 2906 case DW_OP_bra: 2907 offset = extract_signed_integer (op_ptr, 2, byte_order); 2908 op_ptr += 2; 2909 /* Zero extend the operand. */ 2910 ax_zero_ext (expr, addr_size_bits); 2911 i = ax_goto (expr, aop_if_goto); 2912 dw_labels.push_back (op_ptr + offset - base); 2913 patches.push_back (i); 2914 break; 2915 2916 case DW_OP_nop: 2917 break; 2918 2919 case DW_OP_piece: 2920 case DW_OP_bit_piece: 2921 { 2922 uint64_t size; 2923 2924 if (op_ptr - 1 == previous_piece) 2925 error (_("Cannot translate empty pieces to agent expressions")); 2926 previous_piece = op_ptr - 1; 2927 2928 op_ptr = safe_read_uleb128 (op_ptr, op_end, &size); 2929 if (op == DW_OP_piece) 2930 { 2931 size *= 8; 2932 uoffset = 0; 2933 } 2934 else 2935 op_ptr = safe_read_uleb128 (op_ptr, op_end, &uoffset); 2936 2937 if (bits_collected + size > 8 * sizeof (LONGEST)) 2938 error (_("Expression pieces exceed word size")); 2939 2940 /* Access the bits. */ 2941 switch (loc->kind) 2942 { 2943 case axs_lvalue_register: 2944 ax_reg (expr, loc->u.reg); 2945 break; 2946 2947 case axs_lvalue_memory: 2948 /* Offset the pointer, if needed. */ 2949 if (uoffset > 8) 2950 { 2951 ax_const_l (expr, uoffset / 8); 2952 ax_simple (expr, aop_add); 2953 uoffset %= 8; 2954 } 2955 access_memory (arch, expr, size); 2956 break; 2957 } 2958 2959 /* For a bits-big-endian target, shift up what we already 2960 have. For a bits-little-endian target, shift up the 2961 new data. Note that there is a potential bug here if 2962 the DWARF expression leaves multiple values on the 2963 stack. */ 2964 if (bits_collected > 0) 2965 { 2966 if (bits_big_endian) 2967 { 2968 ax_simple (expr, aop_swap); 2969 ax_const_l (expr, size); 2970 ax_simple (expr, aop_lsh); 2971 /* We don't need a second swap here, because 2972 aop_bit_or is symmetric. */ 2973 } 2974 else 2975 { 2976 ax_const_l (expr, size); 2977 ax_simple (expr, aop_lsh); 2978 } 2979 ax_simple (expr, aop_bit_or); 2980 } 2981 2982 bits_collected += size; 2983 loc->kind = axs_rvalue; 2984 } 2985 break; 2986 2987 case DW_OP_GNU_uninit: 2988 unimplemented (op); 2989 2990 case DW_OP_call2: 2991 case DW_OP_call4: 2992 { 2993 struct dwarf2_locexpr_baton block; 2994 int size = (op == DW_OP_call2 ? 2 : 4); 2995 2996 uoffset = extract_unsigned_integer (op_ptr, size, byte_order); 2997 op_ptr += size; 2998 2999 auto get_frame_pc_from_expr = [expr] () 3000 { 3001 return expr->scope; 3002 }; 3003 cu_offset cuoffset = (cu_offset) uoffset; 3004 block = dwarf2_fetch_die_loc_cu_off (cuoffset, per_cu, per_objfile, 3005 get_frame_pc_from_expr); 3006 3007 /* DW_OP_call_ref is currently not supported. */ 3008 gdb_assert (block.per_cu == per_cu); 3009 3010 dwarf2_compile_expr_to_ax (expr, loc, addr_size, block.data, 3011 block.data + block.size, per_cu, 3012 per_objfile); 3013 } 3014 break; 3015 3016 case DW_OP_call_ref: 3017 unimplemented (op); 3018 3019 case DW_OP_GNU_variable_value: 3020 unimplemented (op); 3021 3022 default: 3023 unimplemented (op); 3024 } 3025 } 3026 3027 /* Patch all the branches we emitted. */ 3028 for (int i = 0; i < patches.size (); ++i) 3029 { 3030 int targ = offsets[dw_labels[i]]; 3031 if (targ == -1) 3032 internal_error (_("invalid label")); 3033 ax_label (expr, patches[i], targ); 3034 } 3035 } 3036 3037 3038 /* Return the value of SYMBOL in FRAME using the DWARF-2 expression 3040 evaluator to calculate the location. */ 3041 static struct value * 3042 locexpr_read_variable (struct symbol *symbol, frame_info_ptr frame) 3043 { 3044 struct dwarf2_locexpr_baton *dlbaton 3045 = (struct dwarf2_locexpr_baton *) SYMBOL_LOCATION_BATON (symbol); 3046 struct value *val; 3047 3048 val = dwarf2_evaluate_loc_desc (symbol->type (), frame, dlbaton->data, 3049 dlbaton->size, dlbaton->per_cu, 3050 dlbaton->per_objfile); 3051 3052 return val; 3053 } 3054 3055 /* Return the value of SYMBOL in FRAME at (callee) FRAME's function 3056 entry. SYMBOL should be a function parameter, otherwise NO_ENTRY_VALUE_ERROR 3057 will be thrown. */ 3058 3059 static struct value * 3060 locexpr_read_variable_at_entry (struct symbol *symbol, frame_info_ptr frame) 3061 { 3062 struct dwarf2_locexpr_baton *dlbaton 3063 = (struct dwarf2_locexpr_baton *) SYMBOL_LOCATION_BATON (symbol); 3064 3065 return value_of_dwarf_block_entry (symbol->type (), frame, dlbaton->data, 3066 dlbaton->size); 3067 } 3068 3069 /* Implementation of get_symbol_read_needs from 3070 symbol_computed_ops. */ 3071 3072 static enum symbol_needs_kind 3073 locexpr_get_symbol_read_needs (struct symbol *symbol) 3074 { 3075 struct dwarf2_locexpr_baton *dlbaton 3076 = (struct dwarf2_locexpr_baton *) SYMBOL_LOCATION_BATON (symbol); 3077 3078 gdbarch *arch = dlbaton->per_objfile->objfile->arch (); 3079 gdb::array_view<const gdb_byte> expr (dlbaton->data, dlbaton->size); 3080 3081 return dwarf2_get_symbol_read_needs (expr, 3082 dlbaton->per_cu, 3083 dlbaton->per_objfile, 3084 gdbarch_byte_order (arch), 3085 dlbaton->per_cu->addr_size (), 3086 dlbaton->per_cu->ref_addr_size ()); 3087 } 3088 3089 /* Return true if DATA points to the end of a piece. END is one past 3090 the last byte in the expression. */ 3091 3092 static int 3093 piece_end_p (const gdb_byte *data, const gdb_byte *end) 3094 { 3095 return data == end || data[0] == DW_OP_piece || data[0] == DW_OP_bit_piece; 3096 } 3097 3098 /* Helper for locexpr_describe_location_piece that finds the name of a 3099 DWARF register. */ 3100 3101 static const char * 3102 locexpr_regname (struct gdbarch *gdbarch, int dwarf_regnum) 3103 { 3104 int regnum; 3105 3106 /* This doesn't use dwarf_reg_to_regnum_or_error on purpose. 3107 We'd rather print *something* here than throw an error. */ 3108 regnum = dwarf_reg_to_regnum (gdbarch, dwarf_regnum); 3109 /* gdbarch_register_name may just return "", return something more 3110 descriptive for bad register numbers. */ 3111 if (regnum == -1) 3112 { 3113 /* The text is output as "$bad_register_number". 3114 That is why we use the underscores. */ 3115 return _("bad_register_number"); 3116 } 3117 return gdbarch_register_name (gdbarch, regnum); 3118 } 3119 3120 /* Nicely describe a single piece of a location, returning an updated 3121 position in the bytecode sequence. This function cannot recognize 3122 all locations; if a location is not recognized, it simply returns 3123 DATA. If there is an error during reading, e.g. we run off the end 3124 of the buffer, an error is thrown. */ 3125 3126 static const gdb_byte * 3127 locexpr_describe_location_piece (struct symbol *symbol, struct ui_file *stream, 3128 CORE_ADDR addr, dwarf2_per_cu_data *per_cu, 3129 dwarf2_per_objfile *per_objfile, 3130 const gdb_byte *data, const gdb_byte *end, 3131 unsigned int addr_size) 3132 { 3133 objfile *objfile = per_objfile->objfile; 3134 struct gdbarch *gdbarch = objfile->arch (); 3135 size_t leb128_size; 3136 3137 if (data[0] >= DW_OP_reg0 && data[0] <= DW_OP_reg31) 3138 { 3139 gdb_printf (stream, _("a variable in $%s"), 3140 locexpr_regname (gdbarch, data[0] - DW_OP_reg0)); 3141 data += 1; 3142 } 3143 else if (data[0] == DW_OP_regx) 3144 { 3145 uint64_t reg; 3146 3147 data = safe_read_uleb128 (data + 1, end, ®); 3148 gdb_printf (stream, _("a variable in $%s"), 3149 locexpr_regname (gdbarch, reg)); 3150 } 3151 else if (data[0] == DW_OP_fbreg) 3152 { 3153 const struct block *b; 3154 struct symbol *framefunc; 3155 int frame_reg = 0; 3156 int64_t frame_offset; 3157 const gdb_byte *base_data, *new_data, *save_data = data; 3158 size_t base_size; 3159 int64_t base_offset = 0; 3160 3161 new_data = safe_read_sleb128 (data + 1, end, &frame_offset); 3162 if (!piece_end_p (new_data, end)) 3163 return data; 3164 data = new_data; 3165 3166 b = block_for_pc (addr); 3167 3168 if (!b) 3169 error (_("No block found for address for symbol \"%s\"."), 3170 symbol->print_name ()); 3171 3172 framefunc = block_linkage_function (b); 3173 3174 if (!framefunc) 3175 error (_("No function found for block for symbol \"%s\"."), 3176 symbol->print_name ()); 3177 3178 func_get_frame_base_dwarf_block (framefunc, addr, &base_data, &base_size); 3179 3180 if (base_data[0] >= DW_OP_breg0 && base_data[0] <= DW_OP_breg31) 3181 { 3182 const gdb_byte *buf_end; 3183 3184 frame_reg = base_data[0] - DW_OP_breg0; 3185 buf_end = safe_read_sleb128 (base_data + 1, base_data + base_size, 3186 &base_offset); 3187 if (buf_end != base_data + base_size) 3188 error (_("Unexpected opcode after " 3189 "DW_OP_breg%u for symbol \"%s\"."), 3190 frame_reg, symbol->print_name ()); 3191 } 3192 else if (base_data[0] >= DW_OP_reg0 && base_data[0] <= DW_OP_reg31) 3193 { 3194 /* The frame base is just the register, with no offset. */ 3195 frame_reg = base_data[0] - DW_OP_reg0; 3196 base_offset = 0; 3197 } 3198 else 3199 { 3200 /* We don't know what to do with the frame base expression, 3201 so we can't trace this variable; give up. */ 3202 return save_data; 3203 } 3204 3205 gdb_printf (stream, 3206 _("a variable at frame base reg $%s offset %s+%s"), 3207 locexpr_regname (gdbarch, frame_reg), 3208 plongest (base_offset), plongest (frame_offset)); 3209 } 3210 else if (data[0] >= DW_OP_breg0 && data[0] <= DW_OP_breg31 3211 && piece_end_p (data, end)) 3212 { 3213 int64_t offset; 3214 3215 data = safe_read_sleb128 (data + 1, end, &offset); 3216 3217 gdb_printf (stream, 3218 _("a variable at offset %s from base reg $%s"), 3219 plongest (offset), 3220 locexpr_regname (gdbarch, data[0] - DW_OP_breg0)); 3221 } 3222 3223 /* The location expression for a TLS variable looks like this (on a 3224 64-bit LE machine): 3225 3226 DW_AT_location : 10 byte block: 3 4 0 0 0 0 0 0 0 e0 3227 (DW_OP_addr: 4; DW_OP_GNU_push_tls_address) 3228 3229 0x3 is the encoding for DW_OP_addr, which has an operand as long 3230 as the size of an address on the target machine (here is 8 3231 bytes). Note that more recent version of GCC emit DW_OP_const4u 3232 or DW_OP_const8u, depending on address size, rather than 3233 DW_OP_addr. 0xe0 is the encoding for DW_OP_GNU_push_tls_address. 3234 The operand represents the offset at which the variable is within 3235 the thread local storage. */ 3236 3237 else if (data + 1 + addr_size < end 3238 && (data[0] == DW_OP_addr 3239 || (addr_size == 4 && data[0] == DW_OP_const4u) 3240 || (addr_size == 8 && data[0] == DW_OP_const8u)) 3241 && (data[1 + addr_size] == DW_OP_GNU_push_tls_address 3242 || data[1 + addr_size] == DW_OP_form_tls_address) 3243 && piece_end_p (data + 2 + addr_size, end)) 3244 { 3245 ULONGEST offset; 3246 offset = extract_unsigned_integer (data + 1, addr_size, 3247 gdbarch_byte_order (gdbarch)); 3248 3249 gdb_printf (stream, 3250 _("a thread-local variable at offset 0x%s " 3251 "in the thread-local storage for `%s'"), 3252 phex_nz (offset, addr_size), objfile_name (objfile)); 3253 3254 data += 1 + addr_size + 1; 3255 } 3256 3257 /* With -gsplit-dwarf a TLS variable can also look like this: 3258 DW_AT_location : 3 byte block: fc 4 e0 3259 (DW_OP_GNU_const_index: 4; 3260 DW_OP_GNU_push_tls_address) */ 3261 else if (data + 3 <= end 3262 && data + 1 + (leb128_size = skip_leb128 (data + 1, end)) < end 3263 && data[0] == DW_OP_GNU_const_index 3264 && leb128_size > 0 3265 && (data[1 + leb128_size] == DW_OP_GNU_push_tls_address 3266 || data[1 + leb128_size] == DW_OP_form_tls_address) 3267 && piece_end_p (data + 2 + leb128_size, end)) 3268 { 3269 uint64_t offset; 3270 3271 data = safe_read_uleb128 (data + 1, end, &offset); 3272 offset = dwarf2_read_addr_index (per_cu, per_objfile, offset); 3273 gdb_printf (stream, 3274 _("a thread-local variable at offset 0x%s " 3275 "in the thread-local storage for `%s'"), 3276 phex_nz (offset, addr_size), objfile_name (objfile)); 3277 ++data; 3278 } 3279 3280 else if (data[0] >= DW_OP_lit0 3281 && data[0] <= DW_OP_lit31 3282 && data + 1 < end 3283 && data[1] == DW_OP_stack_value) 3284 { 3285 gdb_printf (stream, _("the constant %d"), data[0] - DW_OP_lit0); 3286 data += 2; 3287 } 3288 3289 return data; 3290 } 3291 3292 /* Disassemble an expression, stopping at the end of a piece or at the 3293 end of the expression. Returns a pointer to the next unread byte 3294 in the input expression. If ALL is nonzero, then this function 3295 will keep going until it reaches the end of the expression. 3296 If there is an error during reading, e.g. we run off the end 3297 of the buffer, an error is thrown. */ 3298 3299 static const gdb_byte * 3300 disassemble_dwarf_expression (struct ui_file *stream, 3301 struct gdbarch *arch, unsigned int addr_size, 3302 int offset_size, const gdb_byte *start, 3303 const gdb_byte *data, const gdb_byte *end, 3304 int indent, int all, 3305 dwarf2_per_cu_data *per_cu, 3306 dwarf2_per_objfile *per_objfile) 3307 { 3308 while (data < end 3309 && (all 3310 || (data[0] != DW_OP_piece && data[0] != DW_OP_bit_piece))) 3311 { 3312 enum dwarf_location_atom op = (enum dwarf_location_atom) *data++; 3313 uint64_t ul; 3314 int64_t l; 3315 const char *name; 3316 3317 name = get_DW_OP_name (op); 3318 3319 if (!name) 3320 error (_("Unrecognized DWARF opcode 0x%02x at %ld"), 3321 op, (long) (data - 1 - start)); 3322 gdb_printf (stream, " %*ld: %s", indent + 4, 3323 (long) (data - 1 - start), name); 3324 3325 switch (op) 3326 { 3327 case DW_OP_addr: 3328 ul = extract_unsigned_integer (data, addr_size, 3329 gdbarch_byte_order (arch)); 3330 data += addr_size; 3331 gdb_printf (stream, " 0x%s", phex_nz (ul, addr_size)); 3332 break; 3333 3334 case DW_OP_const1u: 3335 ul = extract_unsigned_integer (data, 1, gdbarch_byte_order (arch)); 3336 data += 1; 3337 gdb_printf (stream, " %s", pulongest (ul)); 3338 break; 3339 3340 case DW_OP_const1s: 3341 l = extract_signed_integer (data, 1, gdbarch_byte_order (arch)); 3342 data += 1; 3343 gdb_printf (stream, " %s", plongest (l)); 3344 break; 3345 3346 case DW_OP_const2u: 3347 ul = extract_unsigned_integer (data, 2, gdbarch_byte_order (arch)); 3348 data += 2; 3349 gdb_printf (stream, " %s", pulongest (ul)); 3350 break; 3351 3352 case DW_OP_const2s: 3353 l = extract_signed_integer (data, 2, gdbarch_byte_order (arch)); 3354 data += 2; 3355 gdb_printf (stream, " %s", plongest (l)); 3356 break; 3357 3358 case DW_OP_const4u: 3359 ul = extract_unsigned_integer (data, 4, gdbarch_byte_order (arch)); 3360 data += 4; 3361 gdb_printf (stream, " %s", pulongest (ul)); 3362 break; 3363 3364 case DW_OP_const4s: 3365 l = extract_signed_integer (data, 4, gdbarch_byte_order (arch)); 3366 data += 4; 3367 gdb_printf (stream, " %s", plongest (l)); 3368 break; 3369 3370 case DW_OP_const8u: 3371 ul = extract_unsigned_integer (data, 8, gdbarch_byte_order (arch)); 3372 data += 8; 3373 gdb_printf (stream, " %s", pulongest (ul)); 3374 break; 3375 3376 case DW_OP_const8s: 3377 l = extract_signed_integer (data, 8, gdbarch_byte_order (arch)); 3378 data += 8; 3379 gdb_printf (stream, " %s", plongest (l)); 3380 break; 3381 3382 case DW_OP_constu: 3383 data = safe_read_uleb128 (data, end, &ul); 3384 gdb_printf (stream, " %s", pulongest (ul)); 3385 break; 3386 3387 case DW_OP_consts: 3388 data = safe_read_sleb128 (data, end, &l); 3389 gdb_printf (stream, " %s", plongest (l)); 3390 break; 3391 3392 case DW_OP_reg0: 3393 case DW_OP_reg1: 3394 case DW_OP_reg2: 3395 case DW_OP_reg3: 3396 case DW_OP_reg4: 3397 case DW_OP_reg5: 3398 case DW_OP_reg6: 3399 case DW_OP_reg7: 3400 case DW_OP_reg8: 3401 case DW_OP_reg9: 3402 case DW_OP_reg10: 3403 case DW_OP_reg11: 3404 case DW_OP_reg12: 3405 case DW_OP_reg13: 3406 case DW_OP_reg14: 3407 case DW_OP_reg15: 3408 case DW_OP_reg16: 3409 case DW_OP_reg17: 3410 case DW_OP_reg18: 3411 case DW_OP_reg19: 3412 case DW_OP_reg20: 3413 case DW_OP_reg21: 3414 case DW_OP_reg22: 3415 case DW_OP_reg23: 3416 case DW_OP_reg24: 3417 case DW_OP_reg25: 3418 case DW_OP_reg26: 3419 case DW_OP_reg27: 3420 case DW_OP_reg28: 3421 case DW_OP_reg29: 3422 case DW_OP_reg30: 3423 case DW_OP_reg31: 3424 gdb_printf (stream, " [$%s]", 3425 locexpr_regname (arch, op - DW_OP_reg0)); 3426 break; 3427 3428 case DW_OP_regx: 3429 data = safe_read_uleb128 (data, end, &ul); 3430 gdb_printf (stream, " %s [$%s]", pulongest (ul), 3431 locexpr_regname (arch, (int) ul)); 3432 break; 3433 3434 case DW_OP_implicit_value: 3435 data = safe_read_uleb128 (data, end, &ul); 3436 data += ul; 3437 gdb_printf (stream, " %s", pulongest (ul)); 3438 break; 3439 3440 case DW_OP_breg0: 3441 case DW_OP_breg1: 3442 case DW_OP_breg2: 3443 case DW_OP_breg3: 3444 case DW_OP_breg4: 3445 case DW_OP_breg5: 3446 case DW_OP_breg6: 3447 case DW_OP_breg7: 3448 case DW_OP_breg8: 3449 case DW_OP_breg9: 3450 case DW_OP_breg10: 3451 case DW_OP_breg11: 3452 case DW_OP_breg12: 3453 case DW_OP_breg13: 3454 case DW_OP_breg14: 3455 case DW_OP_breg15: 3456 case DW_OP_breg16: 3457 case DW_OP_breg17: 3458 case DW_OP_breg18: 3459 case DW_OP_breg19: 3460 case DW_OP_breg20: 3461 case DW_OP_breg21: 3462 case DW_OP_breg22: 3463 case DW_OP_breg23: 3464 case DW_OP_breg24: 3465 case DW_OP_breg25: 3466 case DW_OP_breg26: 3467 case DW_OP_breg27: 3468 case DW_OP_breg28: 3469 case DW_OP_breg29: 3470 case DW_OP_breg30: 3471 case DW_OP_breg31: 3472 data = safe_read_sleb128 (data, end, &l); 3473 gdb_printf (stream, " %s [$%s]", plongest (l), 3474 locexpr_regname (arch, op - DW_OP_breg0)); 3475 break; 3476 3477 case DW_OP_bregx: 3478 data = safe_read_uleb128 (data, end, &ul); 3479 data = safe_read_sleb128 (data, end, &l); 3480 gdb_printf (stream, " register %s [$%s] offset %s", 3481 pulongest (ul), 3482 locexpr_regname (arch, (int) ul), 3483 plongest (l)); 3484 break; 3485 3486 case DW_OP_fbreg: 3487 data = safe_read_sleb128 (data, end, &l); 3488 gdb_printf (stream, " %s", plongest (l)); 3489 break; 3490 3491 case DW_OP_xderef_size: 3492 case DW_OP_deref_size: 3493 case DW_OP_pick: 3494 gdb_printf (stream, " %d", *data); 3495 ++data; 3496 break; 3497 3498 case DW_OP_plus_uconst: 3499 data = safe_read_uleb128 (data, end, &ul); 3500 gdb_printf (stream, " %s", pulongest (ul)); 3501 break; 3502 3503 case DW_OP_skip: 3504 l = extract_signed_integer (data, 2, gdbarch_byte_order (arch)); 3505 data += 2; 3506 gdb_printf (stream, " to %ld", 3507 (long) (data + l - start)); 3508 break; 3509 3510 case DW_OP_bra: 3511 l = extract_signed_integer (data, 2, gdbarch_byte_order (arch)); 3512 data += 2; 3513 gdb_printf (stream, " %ld", 3514 (long) (data + l - start)); 3515 break; 3516 3517 case DW_OP_call2: 3518 ul = extract_unsigned_integer (data, 2, gdbarch_byte_order (arch)); 3519 data += 2; 3520 gdb_printf (stream, " offset %s", phex_nz (ul, 2)); 3521 break; 3522 3523 case DW_OP_call4: 3524 ul = extract_unsigned_integer (data, 4, gdbarch_byte_order (arch)); 3525 data += 4; 3526 gdb_printf (stream, " offset %s", phex_nz (ul, 4)); 3527 break; 3528 3529 case DW_OP_call_ref: 3530 ul = extract_unsigned_integer (data, offset_size, 3531 gdbarch_byte_order (arch)); 3532 data += offset_size; 3533 gdb_printf (stream, " offset %s", phex_nz (ul, offset_size)); 3534 break; 3535 3536 case DW_OP_piece: 3537 data = safe_read_uleb128 (data, end, &ul); 3538 gdb_printf (stream, " %s (bytes)", pulongest (ul)); 3539 break; 3540 3541 case DW_OP_bit_piece: 3542 { 3543 uint64_t offset; 3544 3545 data = safe_read_uleb128 (data, end, &ul); 3546 data = safe_read_uleb128 (data, end, &offset); 3547 gdb_printf (stream, " size %s offset %s (bits)", 3548 pulongest (ul), pulongest (offset)); 3549 } 3550 break; 3551 3552 case DW_OP_implicit_pointer: 3553 case DW_OP_GNU_implicit_pointer: 3554 { 3555 ul = extract_unsigned_integer (data, offset_size, 3556 gdbarch_byte_order (arch)); 3557 data += offset_size; 3558 3559 data = safe_read_sleb128 (data, end, &l); 3560 3561 gdb_printf (stream, " DIE %s offset %s", 3562 phex_nz (ul, offset_size), 3563 plongest (l)); 3564 } 3565 break; 3566 3567 case DW_OP_deref_type: 3568 case DW_OP_GNU_deref_type: 3569 { 3570 int deref_addr_size = *data++; 3571 struct type *type; 3572 3573 data = safe_read_uleb128 (data, end, &ul); 3574 cu_offset offset = (cu_offset) ul; 3575 type = dwarf2_get_die_type (offset, per_cu, per_objfile); 3576 gdb_printf (stream, "<"); 3577 type_print (type, "", stream, -1); 3578 gdb_printf (stream, " [0x%s]> %d", 3579 phex_nz (to_underlying (offset), 0), 3580 deref_addr_size); 3581 } 3582 break; 3583 3584 case DW_OP_const_type: 3585 case DW_OP_GNU_const_type: 3586 { 3587 struct type *type; 3588 3589 data = safe_read_uleb128 (data, end, &ul); 3590 cu_offset type_die = (cu_offset) ul; 3591 type = dwarf2_get_die_type (type_die, per_cu, per_objfile); 3592 gdb_printf (stream, "<"); 3593 type_print (type, "", stream, -1); 3594 gdb_printf (stream, " [0x%s]>", 3595 phex_nz (to_underlying (type_die), 0)); 3596 3597 int n = *data++; 3598 gdb_printf (stream, " %d byte block:", n); 3599 for (int i = 0; i < n; ++i) 3600 gdb_printf (stream, " %02x", data[i]); 3601 data += n; 3602 } 3603 break; 3604 3605 case DW_OP_regval_type: 3606 case DW_OP_GNU_regval_type: 3607 { 3608 uint64_t reg; 3609 struct type *type; 3610 3611 data = safe_read_uleb128 (data, end, ®); 3612 data = safe_read_uleb128 (data, end, &ul); 3613 cu_offset type_die = (cu_offset) ul; 3614 3615 type = dwarf2_get_die_type (type_die, per_cu, per_objfile); 3616 gdb_printf (stream, "<"); 3617 type_print (type, "", stream, -1); 3618 gdb_printf (stream, " [0x%s]> [$%s]", 3619 phex_nz (to_underlying (type_die), 0), 3620 locexpr_regname (arch, reg)); 3621 } 3622 break; 3623 3624 case DW_OP_convert: 3625 case DW_OP_GNU_convert: 3626 case DW_OP_reinterpret: 3627 case DW_OP_GNU_reinterpret: 3628 { 3629 data = safe_read_uleb128 (data, end, &ul); 3630 cu_offset type_die = (cu_offset) ul; 3631 3632 if (to_underlying (type_die) == 0) 3633 gdb_printf (stream, "<0>"); 3634 else 3635 { 3636 struct type *type; 3637 3638 type = dwarf2_get_die_type (type_die, per_cu, per_objfile); 3639 gdb_printf (stream, "<"); 3640 type_print (type, "", stream, -1); 3641 gdb_printf (stream, " [0x%s]>", 3642 phex_nz (to_underlying (type_die), 0)); 3643 } 3644 } 3645 break; 3646 3647 case DW_OP_entry_value: 3648 case DW_OP_GNU_entry_value: 3649 data = safe_read_uleb128 (data, end, &ul); 3650 gdb_putc ('\n', stream); 3651 disassemble_dwarf_expression (stream, arch, addr_size, offset_size, 3652 start, data, data + ul, indent + 2, 3653 all, per_cu, per_objfile); 3654 data += ul; 3655 continue; 3656 3657 case DW_OP_GNU_parameter_ref: 3658 ul = extract_unsigned_integer (data, 4, gdbarch_byte_order (arch)); 3659 data += 4; 3660 gdb_printf (stream, " offset %s", phex_nz (ul, 4)); 3661 break; 3662 3663 case DW_OP_addrx: 3664 case DW_OP_GNU_addr_index: 3665 data = safe_read_uleb128 (data, end, &ul); 3666 ul = dwarf2_read_addr_index (per_cu, per_objfile, ul); 3667 gdb_printf (stream, " 0x%s", phex_nz (ul, addr_size)); 3668 break; 3669 3670 case DW_OP_GNU_const_index: 3671 data = safe_read_uleb128 (data, end, &ul); 3672 ul = dwarf2_read_addr_index (per_cu, per_objfile, ul); 3673 gdb_printf (stream, " %s", pulongest (ul)); 3674 break; 3675 3676 case DW_OP_GNU_variable_value: 3677 ul = extract_unsigned_integer (data, offset_size, 3678 gdbarch_byte_order (arch)); 3679 data += offset_size; 3680 gdb_printf (stream, " offset %s", phex_nz (ul, offset_size)); 3681 break; 3682 } 3683 3684 gdb_printf (stream, "\n"); 3685 } 3686 3687 return data; 3688 } 3689 3690 static bool dwarf_always_disassemble; 3691 3692 static void 3693 show_dwarf_always_disassemble (struct ui_file *file, int from_tty, 3694 struct cmd_list_element *c, const char *value) 3695 { 3696 gdb_printf (file, 3697 _("Whether to always disassemble " 3698 "DWARF expressions is %s.\n"), 3699 value); 3700 } 3701 3702 /* Describe a single location, which may in turn consist of multiple 3703 pieces. */ 3704 3705 static void 3706 locexpr_describe_location_1 (struct symbol *symbol, CORE_ADDR addr, 3707 struct ui_file *stream, 3708 const gdb_byte *data, size_t size, 3709 unsigned int addr_size, 3710 int offset_size, dwarf2_per_cu_data *per_cu, 3711 dwarf2_per_objfile *per_objfile) 3712 { 3713 const gdb_byte *end = data + size; 3714 int first_piece = 1, bad = 0; 3715 objfile *objfile = per_objfile->objfile; 3716 3717 while (data < end) 3718 { 3719 const gdb_byte *here = data; 3720 int disassemble = 1; 3721 3722 if (first_piece) 3723 first_piece = 0; 3724 else 3725 gdb_printf (stream, _(", and ")); 3726 3727 if (!dwarf_always_disassemble) 3728 { 3729 data = locexpr_describe_location_piece (symbol, stream, 3730 addr, per_cu, per_objfile, 3731 data, end, addr_size); 3732 /* If we printed anything, or if we have an empty piece, 3733 then don't disassemble. */ 3734 if (data != here 3735 || data[0] == DW_OP_piece 3736 || data[0] == DW_OP_bit_piece) 3737 disassemble = 0; 3738 } 3739 if (disassemble) 3740 { 3741 gdb_printf (stream, _("a complex DWARF expression:\n")); 3742 data = disassemble_dwarf_expression (stream, 3743 objfile->arch (), 3744 addr_size, offset_size, data, 3745 data, end, 0, 3746 dwarf_always_disassemble, 3747 per_cu, per_objfile); 3748 } 3749 3750 if (data < end) 3751 { 3752 int empty = data == here; 3753 3754 if (disassemble) 3755 gdb_printf (stream, " "); 3756 if (data[0] == DW_OP_piece) 3757 { 3758 uint64_t bytes; 3759 3760 data = safe_read_uleb128 (data + 1, end, &bytes); 3761 3762 if (empty) 3763 gdb_printf (stream, _("an empty %s-byte piece"), 3764 pulongest (bytes)); 3765 else 3766 gdb_printf (stream, _(" [%s-byte piece]"), 3767 pulongest (bytes)); 3768 } 3769 else if (data[0] == DW_OP_bit_piece) 3770 { 3771 uint64_t bits, offset; 3772 3773 data = safe_read_uleb128 (data + 1, end, &bits); 3774 data = safe_read_uleb128 (data, end, &offset); 3775 3776 if (empty) 3777 gdb_printf (stream, 3778 _("an empty %s-bit piece"), 3779 pulongest (bits)); 3780 else 3781 gdb_printf (stream, 3782 _(" [%s-bit piece, offset %s bits]"), 3783 pulongest (bits), pulongest (offset)); 3784 } 3785 else 3786 { 3787 bad = 1; 3788 break; 3789 } 3790 } 3791 } 3792 3793 if (bad || data > end) 3794 error (_("Corrupted DWARF2 expression for \"%s\"."), 3795 symbol->print_name ()); 3796 } 3797 3798 /* Print a natural-language description of SYMBOL to STREAM. This 3799 version is for a symbol with a single location. */ 3800 3801 static void 3802 locexpr_describe_location (struct symbol *symbol, CORE_ADDR addr, 3803 struct ui_file *stream) 3804 { 3805 struct dwarf2_locexpr_baton *dlbaton 3806 = (struct dwarf2_locexpr_baton *) SYMBOL_LOCATION_BATON (symbol); 3807 unsigned int addr_size = dlbaton->per_cu->addr_size (); 3808 int offset_size = dlbaton->per_cu->offset_size (); 3809 3810 locexpr_describe_location_1 (symbol, addr, stream, 3811 dlbaton->data, dlbaton->size, 3812 addr_size, offset_size, 3813 dlbaton->per_cu, dlbaton->per_objfile); 3814 } 3815 3816 /* Describe the location of SYMBOL as an agent value in VALUE, generating 3817 any necessary bytecode in AX. */ 3818 3819 static void 3820 locexpr_tracepoint_var_ref (struct symbol *symbol, struct agent_expr *ax, 3821 struct axs_value *value) 3822 { 3823 struct dwarf2_locexpr_baton *dlbaton 3824 = (struct dwarf2_locexpr_baton *) SYMBOL_LOCATION_BATON (symbol); 3825 unsigned int addr_size = dlbaton->per_cu->addr_size (); 3826 3827 if (dlbaton->size == 0) 3828 value->optimized_out = 1; 3829 else 3830 dwarf2_compile_expr_to_ax (ax, value, addr_size, dlbaton->data, 3831 dlbaton->data + dlbaton->size, dlbaton->per_cu, 3832 dlbaton->per_objfile); 3833 } 3834 3835 /* symbol_computed_ops 'generate_c_location' method. */ 3836 3837 static void 3838 locexpr_generate_c_location (struct symbol *sym, string_file *stream, 3839 struct gdbarch *gdbarch, 3840 std::vector<bool> ®isters_used, 3841 CORE_ADDR pc, const char *result_name) 3842 { 3843 struct dwarf2_locexpr_baton *dlbaton 3844 = (struct dwarf2_locexpr_baton *) SYMBOL_LOCATION_BATON (sym); 3845 unsigned int addr_size = dlbaton->per_cu->addr_size (); 3846 3847 if (dlbaton->size == 0) 3848 error (_("symbol \"%s\" is optimized out"), sym->natural_name ()); 3849 3850 compile_dwarf_expr_to_c (stream, result_name, 3851 sym, pc, gdbarch, registers_used, addr_size, 3852 dlbaton->data, dlbaton->data + dlbaton->size, 3853 dlbaton->per_cu, dlbaton->per_objfile); 3854 } 3855 3856 /* The set of location functions used with the DWARF-2 expression 3857 evaluator. */ 3858 const struct symbol_computed_ops dwarf2_locexpr_funcs = { 3859 locexpr_read_variable, 3860 locexpr_read_variable_at_entry, 3861 locexpr_get_symbol_read_needs, 3862 locexpr_describe_location, 3863 0, /* location_has_loclist */ 3864 locexpr_tracepoint_var_ref, 3865 locexpr_generate_c_location 3866 }; 3867 3868 3869 /* Wrapper functions for location lists. These generally find 3870 the appropriate location expression and call something above. */ 3871 3872 /* Return the value of SYMBOL in FRAME using the DWARF-2 expression 3873 evaluator to calculate the location. */ 3874 static struct value * 3875 loclist_read_variable (struct symbol *symbol, frame_info_ptr frame) 3876 { 3877 struct dwarf2_loclist_baton *dlbaton 3878 = (struct dwarf2_loclist_baton *) SYMBOL_LOCATION_BATON (symbol); 3879 struct value *val; 3880 const gdb_byte *data; 3881 size_t size; 3882 CORE_ADDR pc = frame ? get_frame_address_in_block (frame) : 0; 3883 3884 data = dwarf2_find_location_expression (dlbaton, &size, pc); 3885 val = dwarf2_evaluate_loc_desc (symbol->type (), frame, data, size, 3886 dlbaton->per_cu, dlbaton->per_objfile); 3887 3888 return val; 3889 } 3890 3891 /* Read variable SYMBOL like loclist_read_variable at (callee) FRAME's function 3892 entry. SYMBOL should be a function parameter, otherwise NO_ENTRY_VALUE_ERROR 3893 will be thrown. 3894 3895 Function always returns non-NULL value, it may be marked optimized out if 3896 inferior frame information is not available. It throws NO_ENTRY_VALUE_ERROR 3897 if it cannot resolve the parameter for any reason. */ 3898 3899 static struct value * 3900 loclist_read_variable_at_entry (struct symbol *symbol, frame_info_ptr frame) 3901 { 3902 struct dwarf2_loclist_baton *dlbaton 3903 = (struct dwarf2_loclist_baton *) SYMBOL_LOCATION_BATON (symbol); 3904 const gdb_byte *data; 3905 size_t size; 3906 CORE_ADDR pc; 3907 3908 if (frame == NULL || !get_frame_func_if_available (frame, &pc)) 3909 return allocate_optimized_out_value (symbol->type ()); 3910 3911 data = dwarf2_find_location_expression (dlbaton, &size, pc); 3912 if (data == NULL) 3913 return allocate_optimized_out_value (symbol->type ()); 3914 3915 return value_of_dwarf_block_entry (symbol->type (), frame, data, size); 3916 } 3917 3918 /* Implementation of get_symbol_read_needs from 3919 symbol_computed_ops. */ 3920 3921 static enum symbol_needs_kind 3922 loclist_symbol_needs (struct symbol *symbol) 3923 { 3924 /* If there's a location list, then assume we need to have a frame 3925 to choose the appropriate location expression. With tracking of 3926 global variables this is not necessarily true, but such tracking 3927 is disabled in GCC at the moment until we figure out how to 3928 represent it. */ 3929 3930 return SYMBOL_NEEDS_FRAME; 3931 } 3932 3933 /* Print a natural-language description of SYMBOL to STREAM. This 3934 version applies when there is a list of different locations, each 3935 with a specified address range. */ 3936 3937 static void 3938 loclist_describe_location (struct symbol *symbol, CORE_ADDR addr, 3939 struct ui_file *stream) 3940 { 3941 struct dwarf2_loclist_baton *dlbaton 3942 = (struct dwarf2_loclist_baton *) SYMBOL_LOCATION_BATON (symbol); 3943 const gdb_byte *loc_ptr, *buf_end; 3944 dwarf2_per_objfile *per_objfile = dlbaton->per_objfile; 3945 struct objfile *objfile = per_objfile->objfile; 3946 struct gdbarch *gdbarch = objfile->arch (); 3947 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); 3948 unsigned int addr_size = dlbaton->per_cu->addr_size (); 3949 int offset_size = dlbaton->per_cu->offset_size (); 3950 int signed_addr_p = bfd_get_sign_extend_vma (objfile->obfd.get ()); 3951 /* Adjustment for relocatable objects. */ 3952 CORE_ADDR text_offset = objfile->text_section_offset (); 3953 CORE_ADDR base_address = dlbaton->base_address; 3954 int done = 0; 3955 3956 loc_ptr = dlbaton->data; 3957 buf_end = dlbaton->data + dlbaton->size; 3958 3959 gdb_printf (stream, _("multi-location:\n")); 3960 3961 /* Iterate through locations until we run out. */ 3962 while (!done) 3963 { 3964 CORE_ADDR low = 0, high = 0; /* init for gcc -Wall */ 3965 int length; 3966 enum debug_loc_kind kind; 3967 const gdb_byte *new_ptr = NULL; /* init for gcc -Wall */ 3968 3969 if (dlbaton->per_cu->version () < 5 && dlbaton->from_dwo) 3970 kind = decode_debug_loc_dwo_addresses (dlbaton->per_cu, 3971 dlbaton->per_objfile, 3972 loc_ptr, buf_end, &new_ptr, 3973 &low, &high, byte_order); 3974 else if (dlbaton->per_cu->version () < 5) 3975 kind = decode_debug_loc_addresses (loc_ptr, buf_end, &new_ptr, 3976 &low, &high, 3977 byte_order, addr_size, 3978 signed_addr_p); 3979 else 3980 kind = decode_debug_loclists_addresses (dlbaton->per_cu, 3981 dlbaton->per_objfile, 3982 loc_ptr, buf_end, &new_ptr, 3983 &low, &high, byte_order, 3984 addr_size, signed_addr_p); 3985 loc_ptr = new_ptr; 3986 switch (kind) 3987 { 3988 case DEBUG_LOC_END_OF_LIST: 3989 done = 1; 3990 continue; 3991 3992 case DEBUG_LOC_BASE_ADDRESS: 3993 base_address = high; 3994 gdb_printf (stream, _(" Base address %s"), 3995 paddress (gdbarch, base_address)); 3996 continue; 3997 3998 case DEBUG_LOC_START_END: 3999 case DEBUG_LOC_START_LENGTH: 4000 case DEBUG_LOC_OFFSET_PAIR: 4001 break; 4002 4003 case DEBUG_LOC_BUFFER_OVERFLOW: 4004 case DEBUG_LOC_INVALID_ENTRY: 4005 error (_("Corrupted DWARF expression for symbol \"%s\"."), 4006 symbol->print_name ()); 4007 4008 default: 4009 gdb_assert_not_reached ("bad debug_loc_kind"); 4010 } 4011 4012 /* Otherwise, a location expression entry. */ 4013 low += text_offset; 4014 high += text_offset; 4015 if (!dlbaton->from_dwo && kind == DEBUG_LOC_OFFSET_PAIR) 4016 { 4017 low += base_address; 4018 high += base_address; 4019 } 4020 4021 low = gdbarch_adjust_dwarf2_addr (gdbarch, low); 4022 high = gdbarch_adjust_dwarf2_addr (gdbarch, high); 4023 4024 if (dlbaton->per_cu->version () < 5) 4025 { 4026 length = extract_unsigned_integer (loc_ptr, 2, byte_order); 4027 loc_ptr += 2; 4028 } 4029 else 4030 { 4031 unsigned int bytes_read; 4032 length = read_unsigned_leb128 (NULL, loc_ptr, &bytes_read); 4033 loc_ptr += bytes_read; 4034 } 4035 4036 /* (It would improve readability to print only the minimum 4037 necessary digits of the second number of the range.) */ 4038 gdb_printf (stream, _(" Range %s-%s: "), 4039 paddress (gdbarch, low), paddress (gdbarch, high)); 4040 4041 /* Now describe this particular location. */ 4042 locexpr_describe_location_1 (symbol, low, stream, loc_ptr, length, 4043 addr_size, offset_size, 4044 dlbaton->per_cu, dlbaton->per_objfile); 4045 4046 gdb_printf (stream, "\n"); 4047 4048 loc_ptr += length; 4049 } 4050 } 4051 4052 /* Describe the location of SYMBOL as an agent value in VALUE, generating 4053 any necessary bytecode in AX. */ 4054 static void 4055 loclist_tracepoint_var_ref (struct symbol *symbol, struct agent_expr *ax, 4056 struct axs_value *value) 4057 { 4058 struct dwarf2_loclist_baton *dlbaton 4059 = (struct dwarf2_loclist_baton *) SYMBOL_LOCATION_BATON (symbol); 4060 const gdb_byte *data; 4061 size_t size; 4062 unsigned int addr_size = dlbaton->per_cu->addr_size (); 4063 4064 data = dwarf2_find_location_expression (dlbaton, &size, ax->scope); 4065 if (size == 0) 4066 value->optimized_out = 1; 4067 else 4068 dwarf2_compile_expr_to_ax (ax, value, addr_size, data, data + size, 4069 dlbaton->per_cu, dlbaton->per_objfile); 4070 } 4071 4072 /* symbol_computed_ops 'generate_c_location' method. */ 4073 4074 static void 4075 loclist_generate_c_location (struct symbol *sym, string_file *stream, 4076 struct gdbarch *gdbarch, 4077 std::vector<bool> ®isters_used, 4078 CORE_ADDR pc, const char *result_name) 4079 { 4080 struct dwarf2_loclist_baton *dlbaton 4081 = (struct dwarf2_loclist_baton *) SYMBOL_LOCATION_BATON (sym); 4082 unsigned int addr_size = dlbaton->per_cu->addr_size (); 4083 const gdb_byte *data; 4084 size_t size; 4085 4086 data = dwarf2_find_location_expression (dlbaton, &size, pc); 4087 if (size == 0) 4088 error (_("symbol \"%s\" is optimized out"), sym->natural_name ()); 4089 4090 compile_dwarf_expr_to_c (stream, result_name, 4091 sym, pc, gdbarch, registers_used, addr_size, 4092 data, data + size, 4093 dlbaton->per_cu, 4094 dlbaton->per_objfile); 4095 } 4096 4097 /* The set of location functions used with the DWARF-2 expression 4098 evaluator and location lists. */ 4099 const struct symbol_computed_ops dwarf2_loclist_funcs = { 4100 loclist_read_variable, 4101 loclist_read_variable_at_entry, 4102 loclist_symbol_needs, 4103 loclist_describe_location, 4104 1, /* location_has_loclist */ 4105 loclist_tracepoint_var_ref, 4106 loclist_generate_c_location 4107 }; 4108 4109 void _initialize_dwarf2loc (); 4110 void 4111 _initialize_dwarf2loc () 4112 { 4113 add_setshow_zuinteger_cmd ("entry-values", class_maintenance, 4114 &entry_values_debug, 4115 _("Set entry values and tail call frames " 4116 "debugging."), 4117 _("Show entry values and tail call frames " 4118 "debugging."), 4119 _("When non-zero, the process of determining " 4120 "parameter values from function entry point " 4121 "and tail call frames will be printed."), 4122 NULL, 4123 show_entry_values_debug, 4124 &setdebuglist, &showdebuglist); 4125 4126 add_setshow_boolean_cmd ("always-disassemble", class_obscure, 4127 &dwarf_always_disassemble, _("\ 4128 Set whether `info address' always disassembles DWARF expressions."), _("\ 4129 Show whether `info address' always disassembles DWARF expressions."), _("\ 4130 When enabled, DWARF expressions are always printed in an assembly-like\n\ 4131 syntax. When disabled, expressions will be printed in a more\n\ 4132 conversational style, when possible."), 4133 NULL, 4134 show_dwarf_always_disassemble, 4135 &set_dwarf_cmdlist, 4136 &show_dwarf_cmdlist); 4137 } 4138
Indexes created Sat Jul 25 00:23:55 UTC 2026