1/* DWARF 2 location expression support for GDB. 2 3 Copyright (C) 2003, 2005, 2007 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 "exceptions.h" 34 35#include "elf/dwarf2.h" 36#include "dwarf2expr.h" 37#include "dwarf2loc.h" 38 39#include "gdb_string.h" 40 41/* A helper function for dealing with location lists. Given a 42 symbol baton (BATON) and a pc value (PC), find the appropriate 43 location expression, set *LOCEXPR_LENGTH, and return a pointer 44 to the beginning of the expression. Returns NULL on failure. 45 46 For now, only return the first matching location expression; there 47 can be more than one in the list. */ 48 49static gdb_byte * 50find_location_expression (struct dwarf2_loclist_baton *baton, 51 size_t *locexpr_length, CORE_ADDR pc) 52{ 53 CORE_ADDR low, high; 54 gdb_byte *loc_ptr, *buf_end; 55 int length; 56 unsigned int addr_size = gdbarch_addr_bit (current_gdbarch) / TARGET_CHAR_BIT; 57 CORE_ADDR base_mask = ~(~(CORE_ADDR)1 << (addr_size * 8 - 1)); 58 /* Adjust base_address for relocatable objects. */ 59 CORE_ADDR base_offset = ANOFFSET (baton->objfile->section_offsets, 60 SECT_OFF_TEXT (baton->objfile)); 61 CORE_ADDR base_address = baton->base_address + base_offset; 62 63 loc_ptr = baton->data; 64 buf_end = baton->data + baton->size; 65 66 while (1) 67 { 68 low = dwarf2_read_address (loc_ptr, buf_end, &length); 69 loc_ptr += length; 70 high = dwarf2_read_address (loc_ptr, buf_end, &length); 71 loc_ptr += length; 72 73 /* An end-of-list entry. */ 74 if (low == 0 && high == 0) 75 return NULL; 76 77 /* A base-address-selection entry. */ 78 if ((low & base_mask) == base_mask) 79 { 80 base_address = high; 81 continue; 82 } 83 84 /* Otherwise, a location expression entry. */ 85 low += base_address; 86 high += base_address; 87 88 length = extract_unsigned_integer (loc_ptr, 2); 89 loc_ptr += 2; 90 91 if (pc >= low && pc < high) 92 { 93 *locexpr_length = length; 94 return loc_ptr; 95 } 96 97 loc_ptr += length; 98 } 99} 100 101/* This is the baton used when performing dwarf2 expression 102 evaluation. */ 103struct dwarf_expr_baton 104{ 105 struct frame_info *frame; 106 struct objfile *objfile; 107}; 108 109/* Helper functions for dwarf2_evaluate_loc_desc. */ 110 111/* Using the frame specified in BATON, return the value of register 112 REGNUM, treated as a pointer. */ 113static CORE_ADDR 114dwarf_expr_read_reg (void *baton, int dwarf_regnum) 115{ 116 struct dwarf_expr_baton *debaton = (struct dwarf_expr_baton *) baton; 117 CORE_ADDR result; 118 int regnum; 119 120 regnum = gdbarch_dwarf2_reg_to_regnum (current_gdbarch, dwarf_regnum); 121 result = address_from_register (builtin_type_void_data_ptr, 122 regnum, debaton->frame); 123 return result; 124} 125 126/* Read memory at ADDR (length LEN) into BUF. */ 127 128static void 129dwarf_expr_read_mem (void *baton, gdb_byte *buf, CORE_ADDR addr, size_t len) 130{ 131 read_memory (addr, buf, len); 132} 133 134/* Using the frame specified in BATON, find the location expression 135 describing the frame base. Return a pointer to it in START and 136 its length in LENGTH. */ 137static void 138dwarf_expr_frame_base (void *baton, gdb_byte **start, size_t * length) 139{ 140 /* FIXME: cagney/2003-03-26: This code should be using 141 get_frame_base_address(), and then implement a dwarf2 specific 142 this_base method. */ 143 struct symbol *framefunc; 144 struct dwarf_expr_baton *debaton = (struct dwarf_expr_baton *) baton; 145 146 framefunc = get_frame_function (debaton->frame); 147 148 if (SYMBOL_OPS (framefunc) == &dwarf2_loclist_funcs) 149 { 150 struct dwarf2_loclist_baton *symbaton; 151 struct frame_info *frame = debaton->frame; 152 153 symbaton = SYMBOL_LOCATION_BATON (framefunc); 154 *start = find_location_expression (symbaton, length, 155 get_frame_address_in_block (frame)); 156 } 157 else 158 { 159 struct dwarf2_locexpr_baton *symbaton; 160 symbaton = SYMBOL_LOCATION_BATON (framefunc); 161 *length = symbaton->size; 162 *start = symbaton->data; 163 } 164 165 if (*start == NULL) 166 error (_("Could not find the frame base for \"%s\"."), 167 SYMBOL_NATURAL_NAME (framefunc)); 168} 169 170/* Using the objfile specified in BATON, find the address for the 171 current thread's thread-local storage with offset OFFSET. */ 172static CORE_ADDR 173dwarf_expr_tls_address (void *baton, CORE_ADDR offset) 174{ 175 struct dwarf_expr_baton *debaton = (struct dwarf_expr_baton *) baton; 176 177 return target_translate_tls_address (debaton->objfile, offset); 178} 179 180/* Evaluate a location description, starting at DATA and with length 181 SIZE, to find the current location of variable VAR in the context 182 of FRAME. */ 183static struct value * 184dwarf2_evaluate_loc_desc (struct symbol *var, struct frame_info *frame, 185 gdb_byte *data, unsigned short size, 186 struct objfile *objfile) 187{ 188 struct gdbarch *arch = get_frame_arch (frame); 189 struct value *retval; 190 struct dwarf_expr_baton baton; 191 struct dwarf_expr_context *ctx; 192 193 if (size == 0) 194 { 195 retval = allocate_value (SYMBOL_TYPE (var)); 196 VALUE_LVAL (retval) = not_lval; 197 set_value_optimized_out (retval, 1); 198 return retval; 199 } 200 201 baton.frame = frame; 202 baton.objfile = objfile; 203 204 ctx = new_dwarf_expr_context (); 205 ctx->baton = &baton; 206 ctx->read_reg = dwarf_expr_read_reg; 207 ctx->read_mem = dwarf_expr_read_mem; 208 ctx->get_frame_base = dwarf_expr_frame_base; 209 ctx->get_tls_address = dwarf_expr_tls_address; 210 211 dwarf_expr_eval (ctx, data, size); 212 if (ctx->num_pieces > 0) 213 { 214 int i; 215 long offset = 0; 216 bfd_byte *contents; 217 218 retval = allocate_value (SYMBOL_TYPE (var)); 219 contents = value_contents_raw (retval); 220 for (i = 0; i < ctx->num_pieces; i++) 221 { 222 struct dwarf_expr_piece *p = &ctx->pieces[i]; 223 if (p->in_reg) 224 { 225 bfd_byte regval[MAX_REGISTER_SIZE]; 226 int gdb_regnum = gdbarch_dwarf2_reg_to_regnum 227 (current_gdbarch, p->value); 228 get_frame_register (frame, gdb_regnum, regval); 229 memcpy (contents + offset, regval, p->size); 230 } 231 else /* In memory? */ 232 { 233 read_memory (p->value, contents + offset, p->size); 234 } 235 offset += p->size; 236 } 237 } 238 else if (ctx->in_reg) 239 { 240 CORE_ADDR dwarf_regnum = dwarf_expr_fetch (ctx, 0); 241 int gdb_regnum = gdbarch_dwarf2_reg_to_regnum 242 (current_gdbarch, dwarf_regnum); 243 retval = value_from_register (SYMBOL_TYPE (var), gdb_regnum, frame); 244 } 245 else 246 { 247 CORE_ADDR address = dwarf_expr_fetch (ctx, 0); 248 249 retval = allocate_value (SYMBOL_TYPE (var)); 250 VALUE_LVAL (retval) = lval_memory; 251 set_value_lazy (retval, 1); 252 VALUE_ADDRESS (retval) = address; 253 } 254 255 set_value_initialized (retval, ctx->initialized); 256 257 free_dwarf_expr_context (ctx); 258 259 return retval; 260} 261 262 263 264 265 266/* Helper functions and baton for dwarf2_loc_desc_needs_frame. */ 267 268struct needs_frame_baton 269{ 270 int needs_frame; 271}; 272 273/* Reads from registers do require a frame. */ 274static CORE_ADDR 275needs_frame_read_reg (void *baton, int regnum) 276{ 277 struct needs_frame_baton *nf_baton = baton; 278 nf_baton->needs_frame = 1; 279 return 1; 280} 281 282/* Reads from memory do not require a frame. */ 283static void 284needs_frame_read_mem (void *baton, gdb_byte *buf, CORE_ADDR addr, size_t len) 285{ 286 memset (buf, 0, len); 287} 288 289/* Frame-relative accesses do require a frame. */ 290static void 291needs_frame_frame_base (void *baton, gdb_byte **start, size_t * length) 292{ 293 static gdb_byte lit0 = DW_OP_lit0; 294 struct needs_frame_baton *nf_baton = baton; 295 296 *start = &lit0; 297 *length = 1; 298 299 nf_baton->needs_frame = 1; 300} 301 302/* Thread-local accesses do require a frame. */ 303static CORE_ADDR 304needs_frame_tls_address (void *baton, CORE_ADDR offset) 305{ 306 struct needs_frame_baton *nf_baton = baton; 307 nf_baton->needs_frame = 1; 308 return 1; 309} 310 311/* Return non-zero iff the location expression at DATA (length SIZE) 312 requires a frame to evaluate. */ 313 314static int 315dwarf2_loc_desc_needs_frame (gdb_byte *data, unsigned short size) 316{ 317 struct needs_frame_baton baton; 318 struct dwarf_expr_context *ctx; 319 int in_reg; 320 321 baton.needs_frame = 0; 322 323 ctx = new_dwarf_expr_context (); 324 ctx->baton = &baton; 325 ctx->read_reg = needs_frame_read_reg; 326 ctx->read_mem = needs_frame_read_mem; 327 ctx->get_frame_base = needs_frame_frame_base; 328 ctx->get_tls_address = needs_frame_tls_address; 329 330 dwarf_expr_eval (ctx, data, size); 331 332 in_reg = ctx->in_reg; 333 334 if (ctx->num_pieces > 0) 335 { 336 int i; 337 338 /* If the location has several pieces, and any of them are in 339 registers, then we will need a frame to fetch them from. */ 340 for (i = 0; i < ctx->num_pieces; i++) 341 if (ctx->pieces[i].in_reg) 342 in_reg = 1; 343 } 344 345 free_dwarf_expr_context (ctx); 346 347 return baton.needs_frame || in_reg; 348} 349 350static void 351dwarf2_tracepoint_var_ref (struct symbol *symbol, struct agent_expr *ax, 352 struct axs_value *value, gdb_byte *data, 353 int size) 354{ 355 if (size == 0) 356 error (_("Symbol \"%s\" has been optimized out."), 357 SYMBOL_PRINT_NAME (symbol)); 358 359 if (size == 1 360 && data[0] >= DW_OP_reg0 361 && data[0] <= DW_OP_reg31) 362 { 363 value->kind = axs_lvalue_register; 364 value->u.reg = data[0] - DW_OP_reg0; 365 } 366 else if (data[0] == DW_OP_regx) 367 { 368 ULONGEST reg; 369 read_uleb128 (data + 1, data + size, ®); 370 value->kind = axs_lvalue_register; 371 value->u.reg = reg; 372 } 373 else if (data[0] == DW_OP_fbreg) 374 { 375 /* And this is worse than just minimal; we should honor the frame base 376 as above. */ 377 int frame_reg; 378 LONGEST frame_offset; 379 gdb_byte *buf_end; 380 381 buf_end = read_sleb128 (data + 1, data + size, &frame_offset); 382 if (buf_end != data + size) 383 error (_("Unexpected opcode after DW_OP_fbreg for symbol \"%s\"."), 384 SYMBOL_PRINT_NAME (symbol)); 385 386 gdbarch_virtual_frame_pointer (current_gdbarch, 387 ax->scope, &frame_reg, &frame_offset); 388 ax_reg (ax, frame_reg); 389 ax_const_l (ax, frame_offset); 390 ax_simple (ax, aop_add); 391 392 value->kind = axs_lvalue_memory; 393 } 394 else if (data[0] >= DW_OP_breg0 395 && data[0] <= DW_OP_breg31) 396 { 397 unsigned int reg; 398 LONGEST offset; 399 gdb_byte *buf_end; 400 401 reg = data[0] - DW_OP_breg0; 402 buf_end = read_sleb128 (data + 1, data + size, &offset); 403 if (buf_end != data + size) 404 error (_("Unexpected opcode after DW_OP_breg%u for symbol \"%s\"."), 405 reg, SYMBOL_PRINT_NAME (symbol)); 406 407 ax_reg (ax, reg); 408 ax_const_l (ax, offset); 409 ax_simple (ax, aop_add); 410 411 value->kind = axs_lvalue_memory; 412 } 413 else 414 error (_("Unsupported DWARF opcode 0x%x in the location of \"%s\"."), 415 data[0], SYMBOL_PRINT_NAME (symbol)); 416} 417 418/* Return the value of SYMBOL in FRAME using the DWARF-2 expression 419 evaluator to calculate the location. */ 420static struct value * 421locexpr_read_variable (struct symbol *symbol, struct frame_info *frame) 422{ 423 struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol); 424 struct value *val; 425 val = dwarf2_evaluate_loc_desc (symbol, frame, dlbaton->data, dlbaton->size, 426 dlbaton->objfile); 427 428 return val; 429} 430 431/* Return non-zero iff we need a frame to evaluate SYMBOL. */ 432static int 433locexpr_read_needs_frame (struct symbol *symbol) 434{ 435 struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol); 436 return dwarf2_loc_desc_needs_frame (dlbaton->data, dlbaton->size); 437} 438 439/* Print a natural-language description of SYMBOL to STREAM. */ 440static int 441locexpr_describe_location (struct symbol *symbol, struct ui_file *stream) 442{ 443 /* FIXME: be more extensive. */ 444 struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol); 445 446 if (dlbaton->size == 1 447 && dlbaton->data[0] >= DW_OP_reg0 448 && dlbaton->data[0] <= DW_OP_reg31) 449 { 450 int regno = gdbarch_dwarf2_reg_to_regnum 451 (current_gdbarch, dlbaton->data[0] - DW_OP_reg0); 452 fprintf_filtered (stream, 453 "a variable in register %s", 454 gdbarch_register_name (current_gdbarch, regno)); 455 return 1; 456 } 457 458 /* The location expression for a TLS variable looks like this (on a 459 64-bit LE machine): 460 461 DW_AT_location : 10 byte block: 3 4 0 0 0 0 0 0 0 e0 462 (DW_OP_addr: 4; DW_OP_GNU_push_tls_address) 463 464 0x3 is the encoding for DW_OP_addr, which has an operand as long 465 as the size of an address on the target machine (here is 8 466 bytes). 0xe0 is the encoding for DW_OP_GNU_push_tls_address. 467 The operand represents the offset at which the variable is within 468 the thread local storage. */ 469 470 if (dlbaton->size > 1 471 && dlbaton->data[dlbaton->size - 1] == DW_OP_GNU_push_tls_address) 472 if (dlbaton->data[0] == DW_OP_addr) 473 { 474 int bytes_read; 475 CORE_ADDR offset = dwarf2_read_address (&dlbaton->data[1], 476 &dlbaton->data[dlbaton->size - 1], 477 &bytes_read); 478 fprintf_filtered (stream, 479 "a thread-local variable at offset %s in the " 480 "thread-local storage for `%s'", 481 paddr_nz (offset), dlbaton->objfile->name); 482 return 1; 483 } 484 485 486 fprintf_filtered (stream, 487 "a variable with complex or multiple locations (DWARF2)"); 488 return 1; 489} 490 491 492/* Describe the location of SYMBOL as an agent value in VALUE, generating 493 any necessary bytecode in AX. 494 495 NOTE drow/2003-02-26: This function is extremely minimal, because 496 doing it correctly is extremely complicated and there is no 497 publicly available stub with tracepoint support for me to test 498 against. When there is one this function should be revisited. */ 499 500static void 501locexpr_tracepoint_var_ref (struct symbol * symbol, struct agent_expr * ax, 502 struct axs_value * value) 503{ 504 struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol); 505 506 dwarf2_tracepoint_var_ref (symbol, ax, value, dlbaton->data, dlbaton->size); 507} 508 509/* The set of location functions used with the DWARF-2 expression 510 evaluator. */ 511const struct symbol_ops dwarf2_locexpr_funcs = { 512 locexpr_read_variable, 513 locexpr_read_needs_frame, 514 locexpr_describe_location, 515 locexpr_tracepoint_var_ref 516}; 517 518 519/* Wrapper functions for location lists. These generally find 520 the appropriate location expression and call something above. */ 521 522/* Return the value of SYMBOL in FRAME using the DWARF-2 expression 523 evaluator to calculate the location. */ 524static struct value * 525loclist_read_variable (struct symbol *symbol, struct frame_info *frame) 526{ 527 struct dwarf2_loclist_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol); 528 struct value *val; 529 gdb_byte *data; 530 size_t size; 531 532 data = find_location_expression (dlbaton, &size, 533 frame ? get_frame_address_in_block (frame) 534 : 0); 535 if (data == NULL) 536 { 537 val = allocate_value (SYMBOL_TYPE (symbol)); 538 VALUE_LVAL (val) = not_lval; 539 set_value_optimized_out (val, 1); 540 } 541 else 542 val = dwarf2_evaluate_loc_desc (symbol, frame, data, size, 543 dlbaton->objfile); 544 545 return val; 546} 547 548/* Return non-zero iff we need a frame to evaluate SYMBOL. */ 549static int 550loclist_read_needs_frame (struct symbol *symbol) 551{ 552 /* If there's a location list, then assume we need to have a frame 553 to choose the appropriate location expression. With tracking of 554 global variables this is not necessarily true, but such tracking 555 is disabled in GCC at the moment until we figure out how to 556 represent it. */ 557 558 return 1; 559} 560 561/* Print a natural-language description of SYMBOL to STREAM. */ 562static int 563loclist_describe_location (struct symbol *symbol, struct ui_file *stream) 564{ 565 /* FIXME: Could print the entire list of locations. */ 566 fprintf_filtered (stream, "a variable with multiple locations"); 567 return 1; 568} 569 570/* Describe the location of SYMBOL as an agent value in VALUE, generating 571 any necessary bytecode in AX. */ 572static void 573loclist_tracepoint_var_ref (struct symbol * symbol, struct agent_expr * ax, 574 struct axs_value * value) 575{ 576 struct dwarf2_loclist_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol); 577 gdb_byte *data; 578 size_t size; 579 580 data = find_location_expression (dlbaton, &size, ax->scope); 581 if (data == NULL) 582 error (_("Variable \"%s\" is not available."), SYMBOL_NATURAL_NAME (symbol)); 583 584 dwarf2_tracepoint_var_ref (symbol, ax, value, data, size); 585} 586 587/* The set of location functions used with the DWARF-2 expression 588 evaluator and location lists. */ 589const struct symbol_ops dwarf2_loclist_funcs = { 590 loclist_read_variable, 591 loclist_read_needs_frame, 592 loclist_describe_location, 593 loclist_tracepoint_var_ref 594}; 595