gdb/dwarf2loc.c

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