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