gdb/dwarf2loc.c

   1 /* DWARF 2 location expression support for GDB.
   2
   3    Copyright (C) 2003, 2005, 2007, 2008, 2009, 2010, 2011
   4    Free Software Foundation, Inc.
   5
   6    Contributed by Daniel Jacobowitz, MontaVista Software, Inc.
   7
   8    This file is part of GDB.
   9
  10    This program is free software; you can redistribute it and/or modify
  11    it under the terms of the GNU General Public License as published by
  12    the Free Software Foundation; either version 3 of the License, or
  13    (at your option) any later version.
  14
  15    This program is distributed in the hope that it will be useful,
  16    but WITHOUT ANY WARRANTY; without even the implied warranty of
  17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18    GNU General Public License for more details.
  19
  20    You should have received a copy of the GNU General Public License
  21    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  22
  23 #include "defs.h"
  24 #include "ui-out.h"
  25 #include "value.h"
  26 #include "frame.h"
  27 #include "gdbcore.h"
  28 #include "target.h"
  29 #include "inferior.h"
  30 #include "ax.h"
  31 #include "ax-gdb.h"
  32 #include "regcache.h"
  33 #include "objfiles.h"
  34 #include "exceptions.h"
  35 #include "block.h"
  36
  37 #include "dwarf2.h"
  38 #include "dwarf2expr.h"
  39 #include "dwarf2loc.h"
  40 #include "dwarf2-frame.h"
  41
  42 #include "gdb_string.h"
  43 #include "gdb_assert.h"
  44
  45 extern int dwarf2_always_disassemble;
  46
  47 static void
  48 dwarf_expr_frame_base_1 (struct symbol *framefunc, CORE_ADDR pc,
  49                          const gdb_byte **start, size_t *length);
  50
  51 static struct value *
  52 dwarf2_evaluate_loc_desc_full (struct type *type, struct frame_info *frame,
  53                                const gdb_byte *data, unsigned short size,
  54                                struct dwarf2_per_cu_data *per_cu,
  55                                LONGEST byte_offset);
  56
  57 /* A function for dealing with location lists.  Given a
  58    symbol baton (BATON) and a pc value (PC), find the appropriate
  59    location expression, set *LOCEXPR_LENGTH, and return a pointer
  60    to the beginning of the expression.  Returns NULL on failure.
  61
  62    For now, only return the first matching location expression; there
  63    can be more than one in the list.  */
  64
  65 const gdb_byte *
  66 dwarf2_find_location_expression (struct dwarf2_loclist_baton *baton,
  67                                  size_t *locexpr_length, CORE_ADDR pc)
  68 {
  69   CORE_ADDR low, high;
  70   const gdb_byte *loc_ptr, *buf_end;
  71   int length;
  72   struct objfile *objfile = dwarf2_per_cu_objfile (baton->per_cu);
  73   struct gdbarch *gdbarch = get_objfile_arch (objfile);
  74   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
  75   unsigned int addr_size = dwarf2_per_cu_addr_size (baton->per_cu);
  76   int signed_addr_p = bfd_get_sign_extend_vma (objfile->obfd);
  77   CORE_ADDR base_mask = ~(~(CORE_ADDR)1 << (addr_size * 8 - 1));
  78   /* Adjust base_address for relocatable objects.  */
  79   CORE_ADDR base_offset = dwarf2_per_cu_text_offset (baton->per_cu);
  80   CORE_ADDR base_address = baton->base_address + base_offset;
  81
  82   loc_ptr = baton->data;
  83   buf_end = baton->data + baton->size;
  84
  85   while (1)
  86     {
  87       if (buf_end - loc_ptr < 2 * addr_size)
  88         error (_("dwarf2_find_location_expression: "
  89                  "Corrupted DWARF expression."));
  90
  91       if (signed_addr_p)
  92         low = extract_signed_integer (loc_ptr, addr_size, byte_order);
  93       else
  94         low = extract_unsigned_integer (loc_ptr, addr_size, byte_order);
  95       loc_ptr += addr_size;
  96
  97       if (signed_addr_p)
  98         high = extract_signed_integer (loc_ptr, addr_size, byte_order);
  99       else
 100         high = extract_unsigned_integer (loc_ptr, addr_size, byte_order);
 101       loc_ptr += addr_size;
 102
 103       /* A base-address-selection entry.  */
 104       if ((low & base_mask) == base_mask)
 105         {
 106           base_address = high + base_offset;
 107           continue;
 108         }
 109
 110       /* An end-of-list entry.  */
 111       if (low == 0 && high == 0)
 112         return NULL;
 113
 114       /* Otherwise, a location expression entry.  */
 115       low += base_address;
 116       high += base_address;
 117
 118       length = extract_unsigned_integer (loc_ptr, 2, byte_order);
 119       loc_ptr += 2;
 120
 121       if (pc >= low && pc < high)
 122         {
 123           *locexpr_length = length;
 124           return loc_ptr;
 125         }
 126
 127       loc_ptr += length;
 128     }
 129 }
 130
 131 /* This is the baton used when performing dwarf2 expression
 132    evaluation.  */
 133 struct dwarf_expr_baton
 134 {
 135   struct frame_info *frame;
 136   struct dwarf2_per_cu_data *per_cu;
 137 };
 138
 139 /* Helper functions for dwarf2_evaluate_loc_desc.  */
 140
 141 /* Using the frame specified in BATON, return the value of register
 142    REGNUM, treated as a pointer.  */
 143 static CORE_ADDR
 144 dwarf_expr_read_reg (void *baton, int dwarf_regnum)
 145 {
 146   struct dwarf_expr_baton *debaton = (struct dwarf_expr_baton *) baton;
 147   struct gdbarch *gdbarch = get_frame_arch (debaton->frame);
 148   CORE_ADDR result;
 149   int regnum;
 150
 151   regnum = gdbarch_dwarf2_reg_to_regnum (gdbarch, dwarf_regnum);
 152   result = address_from_register (builtin_type (gdbarch)->builtin_data_ptr,
 153                                   regnum, debaton->frame);
 154   return result;
 155 }
 156
 157 /* Read memory at ADDR (length LEN) into BUF.  */
 158
 159 static void
 160 dwarf_expr_read_mem (void *baton, gdb_byte *buf, CORE_ADDR addr, size_t len)
 161 {
 162   read_memory (addr, buf, len);
 163 }
 164
 165 /* Using the frame specified in BATON, find the location expression
 166    describing the frame base.  Return a pointer to it in START and
 167    its length in LENGTH.  */
 168 static void
 169 dwarf_expr_frame_base (void *baton, const gdb_byte **start, size_t * length)
 170 {
 171   /* FIXME: cagney/2003-03-26: This code should be using
 172      get_frame_base_address(), and then implement a dwarf2 specific
 173      this_base method.  */
 174   struct symbol *framefunc;
 175   struct dwarf_expr_baton *debaton = (struct dwarf_expr_baton *) baton;
 176
 177   /* Use block_linkage_function, which returns a real (not inlined)
 178      function, instead of get_frame_function, which may return an
 179      inlined function.  */
 180   framefunc = block_linkage_function (get_frame_block (debaton->frame, NULL));
 181
 182   /* If we found a frame-relative symbol then it was certainly within
 183      some function associated with a frame. If we can't find the frame,
 184      something has gone wrong.  */
 185   gdb_assert (framefunc != NULL);
 186
 187   dwarf_expr_frame_base_1 (framefunc,
 188                            get_frame_address_in_block (debaton->frame),
 189                            start, length);
 190 }
 191
 192 static void
 193 dwarf_expr_frame_base_1 (struct symbol *framefunc, CORE_ADDR pc,
 194                          const gdb_byte **start, size_t *length)
 195 {
 196   if (SYMBOL_LOCATION_BATON (framefunc) == NULL)
 197     *start = NULL;
 198   else if (SYMBOL_COMPUTED_OPS (framefunc) == &dwarf2_loclist_funcs)
 199     {
 200       struct dwarf2_loclist_baton *symbaton;
 201
 202       symbaton = SYMBOL_LOCATION_BATON (framefunc);
 203       *start = dwarf2_find_location_expression (symbaton, length, pc);
 204     }
 205   else
 206     {
 207       struct dwarf2_locexpr_baton *symbaton;
 208
 209       symbaton = SYMBOL_LOCATION_BATON (framefunc);
 210       if (symbaton != NULL)
 211         {
 212           *length = symbaton->size;
 213           *start = symbaton->data;
 214         }
 215       else
 216         *start = NULL;
 217     }
 218
 219   if (*start == NULL)
 220     error (_("Could not find the frame base for \"%s\"."),
 221            SYMBOL_NATURAL_NAME (framefunc));
 222 }
 223
 224 /* Helper function for dwarf2_evaluate_loc_desc.  Computes the CFA for
 225    the frame in BATON.  */
 226
 227 static CORE_ADDR
 228 dwarf_expr_frame_cfa (void *baton)
 229 {
 230   struct dwarf_expr_baton *debaton = (struct dwarf_expr_baton *) baton;
 231
 232   return dwarf2_frame_cfa (debaton->frame);
 233 }
 234
 235 /* Helper function for dwarf2_evaluate_loc_desc.  Computes the PC for
 236    the frame in BATON.  */
 237
 238 static CORE_ADDR
 239 dwarf_expr_frame_pc (void *baton)
 240 {
 241   struct dwarf_expr_baton *debaton = (struct dwarf_expr_baton *) baton;
 242
 243   return get_frame_address_in_block (debaton->frame);
 244 }
 245
 246 /* Using the objfile specified in BATON, find the address for the
 247    current thread's thread-local storage with offset OFFSET.  */
 248 static CORE_ADDR
 249 dwarf_expr_tls_address (void *baton, CORE_ADDR offset)
 250 {
 251   struct dwarf_expr_baton *debaton = (struct dwarf_expr_baton *) baton;
 252   struct objfile *objfile = dwarf2_per_cu_objfile (debaton->per_cu);
 253
 254   return target_translate_tls_address (objfile, offset);
 255 }
 256
 257 /* Call DWARF subroutine from DW_AT_location of DIE at DIE_OFFSET in
 258    current CU (as is PER_CU).  State of the CTX is not affected by the
 259    call and return.  */
 260
 261 static void
 262 per_cu_dwarf_call (struct dwarf_expr_context *ctx, size_t die_offset,
 263                    struct dwarf2_per_cu_data *per_cu,
 264                    CORE_ADDR (*get_frame_pc) (void *baton),
 265                    void *baton)
 266 {
 267   struct dwarf2_locexpr_baton block;
 268
 269   block = dwarf2_fetch_die_location_block (die_offset, per_cu,
 270                                            get_frame_pc, baton);
 271
 272   /* DW_OP_call_ref is currently not supported.  */
 273   gdb_assert (block.per_cu == per_cu);
 274
 275   dwarf_expr_eval (ctx, block.data, block.size);
 276 }
 277
 278 /* Helper interface of per_cu_dwarf_call for dwarf2_evaluate_loc_desc.  */
 279
 280 static void
 281 dwarf_expr_dwarf_call (struct dwarf_expr_context *ctx, size_t die_offset)
 282 {
 283   struct dwarf_expr_baton *debaton = ctx->baton;
 284
 285   return per_cu_dwarf_call (ctx, die_offset, debaton->per_cu,
 286                             ctx->get_frame_pc, ctx->baton);
 287 }
 288
 289 struct piece_closure
 290 {
 291   /* Reference count.  */
 292   int refc;
 293
 294   /* The CU from which this closure's expression came.  */
 295   struct dwarf2_per_cu_data *per_cu;
 296
 297   /* The number of pieces used to describe this variable.  */
 298   int n_pieces;
 299
 300   /* The target address size, used only for DWARF_VALUE_STACK.  */
 301   int addr_size;
 302
 303   /* The pieces themselves.  */
 304   struct dwarf_expr_piece *pieces;
 305 };
 306
 307 /* Allocate a closure for a value formed from separately-described
 308    PIECES.  */
 309
 310 static struct piece_closure *
 311 allocate_piece_closure (struct dwarf2_per_cu_data *per_cu,
 312                         int n_pieces, struct dwarf_expr_piece *pieces,
 313                         int addr_size)
 314 {
 315   struct piece_closure *c = XZALLOC (struct piece_closure);
 316
 317   c->refc = 1;
 318   c->per_cu = per_cu;
 319   c->n_pieces = n_pieces;
 320   c->addr_size = addr_size;
 321   c->pieces = XCALLOC (n_pieces, struct dwarf_expr_piece);
 322
 323   memcpy (c->pieces, pieces, n_pieces * sizeof (struct dwarf_expr_piece));
 324
 325   return c;
 326 }
 327
 328 /* The lowest-level function to extract bits from a byte buffer.
 329    SOURCE is the buffer.  It is updated if we read to the end of a
 330    byte.
 331    SOURCE_OFFSET_BITS is the offset of the first bit to read.  It is
 332    updated to reflect the number of bits actually read.
 333    NBITS is the number of bits we want to read.  It is updated to
 334    reflect the number of bits actually read.  This function may read
 335    fewer bits.
 336    BITS_BIG_ENDIAN is taken directly from gdbarch.
 337    This function returns the extracted bits.  */
 338
 339 static unsigned int
 340 extract_bits_primitive (const gdb_byte **source,
 341                         unsigned int *source_offset_bits,
 342                         int *nbits, int bits_big_endian)
 343 {
 344   unsigned int avail, mask, datum;
 345
 346   gdb_assert (*source_offset_bits < 8);
 347
 348   avail = 8 - *source_offset_bits;
 349   if (avail > *nbits)
 350     avail = *nbits;
 351
 352   mask = (1 << avail) - 1;
 353   datum = **source;
 354   if (bits_big_endian)
 355     datum >>= 8 - (*source_offset_bits + *nbits);
 356   else
 357     datum >>= *source_offset_bits;
 358   datum &= mask;
 359
 360   *nbits -= avail;
 361   *source_offset_bits += avail;
 362   if (*source_offset_bits >= 8)
 363     {
 364       *source_offset_bits -= 8;
 365       ++*source;
 366     }
 367
 368   return datum;
 369 }
 370
 371 /* Extract some bits from a source buffer and move forward in the
 372    buffer.
 373
 374    SOURCE is the source buffer.  It is updated as bytes are read.
 375    SOURCE_OFFSET_BITS is the offset into SOURCE.  It is updated as
 376    bits are read.
 377    NBITS is the number of bits to read.
 378    BITS_BIG_ENDIAN is taken directly from gdbarch.
 379
 380    This function returns the bits that were read.  */
 381
 382 static unsigned int
 383 extract_bits (const gdb_byte **source, unsigned int *source_offset_bits,
 384               int nbits, int bits_big_endian)
 385 {
 386   unsigned int datum;
 387
 388   gdb_assert (nbits > 0 && nbits <= 8);
 389
 390   datum = extract_bits_primitive (source, source_offset_bits, &nbits,
 391                                   bits_big_endian);
 392   if (nbits > 0)
 393     {
 394       unsigned int more;
 395
 396       more = extract_bits_primitive (source, source_offset_bits, &nbits,
 397                                      bits_big_endian);
 398       if (bits_big_endian)
 399         datum <<= nbits;
 400       else
 401         more <<= nbits;
 402       datum |= more;
 403     }
 404
 405   return datum;
 406 }
 407
 408 /* Write some bits into a buffer and move forward in the buffer.
 409
 410    DATUM is the bits to write.  The low-order bits of DATUM are used.
 411    DEST is the destination buffer.  It is updated as bytes are
 412    written.
 413    DEST_OFFSET_BITS is the bit offset in DEST at which writing is
 414    done.
 415    NBITS is the number of valid bits in DATUM.
 416    BITS_BIG_ENDIAN is taken directly from gdbarch.  */
 417
 418 static void
 419 insert_bits (unsigned int datum,
 420              gdb_byte *dest, unsigned int dest_offset_bits,
 421              int nbits, int bits_big_endian)
 422 {
 423   unsigned int mask;
 424
 425   gdb_assert (dest_offset_bits >= 0 && dest_offset_bits + nbits <= 8);
 426
 427   mask = (1 << nbits) - 1;
 428   if (bits_big_endian)
 429     {
 430       datum <<= 8 - (dest_offset_bits + nbits);
 431       mask <<= 8 - (dest_offset_bits + nbits);
 432     }
 433   else
 434     {
 435       datum <<= dest_offset_bits;
 436       mask <<= dest_offset_bits;
 437     }
 438
 439   gdb_assert ((datum & ~mask) == 0);
 440
 441   *dest = (*dest & ~mask) | datum;
 442 }
 443
 444 /* Copy bits from a source to a destination.
 445
 446    DEST is where the bits should be written.
 447    DEST_OFFSET_BITS is the bit offset into DEST.
 448    SOURCE is the source of bits.
 449    SOURCE_OFFSET_BITS is the bit offset into SOURCE.
 450    BIT_COUNT is the number of bits to copy.
 451    BITS_BIG_ENDIAN is taken directly from gdbarch.  */
 452
 453 static void
 454 copy_bitwise (gdb_byte *dest, unsigned int dest_offset_bits,
 455               const gdb_byte *source, unsigned int source_offset_bits,
 456               unsigned int bit_count,
 457               int bits_big_endian)
 458 {
 459   unsigned int dest_avail;
 460   int datum;
 461
 462   /* Reduce everything to byte-size pieces.  */
 463   dest += dest_offset_bits / 8;
 464   dest_offset_bits %= 8;
 465   source += source_offset_bits / 8;
 466   source_offset_bits %= 8;
 467
 468   dest_avail = 8 - dest_offset_bits % 8;
 469
 470   /* See if we can fill the first destination byte.  */
 471   if (dest_avail < bit_count)
 472     {
 473       datum = extract_bits (&source, &source_offset_bits, dest_avail,
 474                             bits_big_endian);
 475       insert_bits (datum, dest, dest_offset_bits, dest_avail, bits_big_endian);
 476       ++dest;
 477       dest_offset_bits = 0;
 478       bit_count -= dest_avail;
 479     }
 480
 481   /* Now, either DEST_OFFSET_BITS is byte-aligned, or we have fewer
 482      than 8 bits remaining.  */
 483   gdb_assert (dest_offset_bits % 8 == 0 || bit_count < 8);
 484   for (; bit_count >= 8; bit_count -= 8)
 485     {
 486       datum = extract_bits (&source, &source_offset_bits, 8, bits_big_endian);
 487       *dest++ = (gdb_byte) datum;
 488     }
 489
 490   /* Finally, we may have a few leftover bits.  */
 491   gdb_assert (bit_count <= 8 - dest_offset_bits % 8);
 492   if (bit_count > 0)
 493     {
 494       datum = extract_bits (&source, &source_offset_bits, bit_count,
 495                             bits_big_endian);
 496       insert_bits (datum, dest, dest_offset_bits, bit_count, bits_big_endian);
 497     }
 498 }
 499
 500 static void
 501 read_pieced_value (struct value *v)
 502 {
 503   int i;
 504   long offset = 0;
 505   ULONGEST bits_to_skip;
 506   gdb_byte *contents;
 507   struct piece_closure *c
 508     = (struct piece_closure *) value_computed_closure (v);
 509   struct frame_info *frame = frame_find_by_id (VALUE_FRAME_ID (v));
 510   size_t type_len;
 511   size_t buffer_size = 0;
 512   char *buffer = NULL;
 513   struct cleanup *cleanup;
 514   int bits_big_endian
 515     = gdbarch_bits_big_endian (get_type_arch (value_type (v)));
 516
 517   if (value_type (v) != value_enclosing_type (v))
 518     internal_error (__FILE__, __LINE__,
 519                     _("Should not be able to create a lazy value with "
 520                       "an enclosing type"));
 521
 522   cleanup = make_cleanup (free_current_contents, &buffer);
 523
 524   contents = value_contents_raw (v);
 525   bits_to_skip = 8 * value_offset (v);
 526   if (value_bitsize (v))
 527     {
 528       bits_to_skip += value_bitpos (v);
 529       type_len = value_bitsize (v);
 530     }
 531   else
 532     type_len = 8 * TYPE_LENGTH (value_type (v));
 533
 534   for (i = 0; i < c->n_pieces && offset < type_len; i++)
 535     {
 536       struct dwarf_expr_piece *p = &c->pieces[i];
 537       size_t this_size, this_size_bits;
 538       long dest_offset_bits, source_offset_bits, source_offset;
 539       const gdb_byte *intermediate_buffer;
 540
 541       /* Compute size, source, and destination offsets for copying, in
 542          bits.  */
 543       this_size_bits = p->size;
 544       if (bits_to_skip > 0 && bits_to_skip >= this_size_bits)
 545         {
 546           bits_to_skip -= this_size_bits;
 547           continue;
 548         }
 549       if (this_size_bits > type_len - offset)
 550         this_size_bits = type_len - offset;
 551       if (bits_to_skip > 0)
 552         {
 553           dest_offset_bits = 0;
 554           source_offset_bits = bits_to_skip;
 555           this_size_bits -= bits_to_skip;
 556           bits_to_skip = 0;
 557         }
 558       else
 559         {
 560           dest_offset_bits = offset;
 561           source_offset_bits = 0;
 562         }
 563
 564       this_size = (this_size_bits + source_offset_bits % 8 + 7) / 8;
 565       source_offset = source_offset_bits / 8;
 566       if (buffer_size < this_size)
 567         {
 568           buffer_size = this_size;
 569           buffer = xrealloc (buffer, buffer_size);
 570         }
 571       intermediate_buffer = buffer;
 572
 573       /* Copy from the source to DEST_BUFFER.  */
 574       switch (p->location)
 575         {
 576         case DWARF_VALUE_REGISTER:
 577           {
 578             struct gdbarch *arch = get_frame_arch (frame);
 579             int gdb_regnum = gdbarch_dwarf2_reg_to_regnum (arch, p->v.value);
 580             int reg_offset = source_offset;
 581
 582             if (gdbarch_byte_order (arch) == BFD_ENDIAN_BIG
 583                 && this_size < register_size (arch, gdb_regnum))
 584               {
 585                 /* Big-endian, and we want less than full size.  */
 586                 reg_offset = register_size (arch, gdb_regnum) - this_size;
 587                 /* We want the lower-order THIS_SIZE_BITS of the bytes
 588                    we extract from the register.  */
 589                 source_offset_bits += 8 * this_size - this_size_bits;
 590               }
 591
 592             if (gdb_regnum != -1)
 593               {
 594                 get_frame_register_bytes (frame, gdb_regnum, reg_offset,
 595                                           this_size, buffer);
 596               }
 597             else
 598               {
 599                 error (_("Unable to access DWARF register number %s"),
 600                        paddress (arch, p->v.value));
 601               }
 602           }
 603           break;
 604
 605         case DWARF_VALUE_MEMORY:
 606           read_value_memory (v, offset,
 607                              p->v.mem.in_stack_memory,
 608                              p->v.mem.addr + source_offset,
 609                              buffer, this_size);
 610           break;
 611
 612         case DWARF_VALUE_STACK:
 613           {
 614             struct gdbarch *gdbarch = get_type_arch (value_type (v));
 615             size_t n = this_size;
 616
 617             if (n > c->addr_size - source_offset)
 618               n = (c->addr_size >= source_offset
 619                    ? c->addr_size - source_offset
 620                    : 0);
 621             if (n == 0)
 622               {
 623                 /* Nothing.  */
 624               }
 625             else if (source_offset == 0)
 626               store_unsigned_integer (buffer, n,
 627                                       gdbarch_byte_order (gdbarch),
 628                                       p->v.value);
 629             else
 630               {
 631                 gdb_byte bytes[sizeof (ULONGEST)];
 632
 633                 store_unsigned_integer (bytes, n + source_offset,
 634                                         gdbarch_byte_order (gdbarch),
 635                                         p->v.value);
 636                 memcpy (buffer, bytes + source_offset, n);
 637               }
 638           }
 639           break;
 640
 641         case DWARF_VALUE_LITERAL:
 642           {
 643             size_t n = this_size;
 644
 645             if (n > p->v.literal.length - source_offset)
 646               n = (p->v.literal.length >= source_offset
 647                    ? p->v.literal.length - source_offset
 648                    : 0);
 649             if (n != 0)
 650               intermediate_buffer = p->v.literal.data + source_offset;
 651           }
 652           break;
 653
 654           /* These bits show up as zeros -- but do not cause the value
 655              to be considered optimized-out.  */
 656         case DWARF_VALUE_IMPLICIT_POINTER:
 657           break;
 658
 659         case DWARF_VALUE_OPTIMIZED_OUT:
 660           set_value_optimized_out (v, 1);
 661           break;
 662
 663         default:
 664           internal_error (__FILE__, __LINE__, _("invalid location type"));
 665         }
 666
 667       if (p->location != DWARF_VALUE_OPTIMIZED_OUT
 668           && p->location != DWARF_VALUE_IMPLICIT_POINTER)
 669         copy_bitwise (contents, dest_offset_bits,
 670                       intermediate_buffer, source_offset_bits % 8,
 671                       this_size_bits, bits_big_endian);
 672
 673       offset += this_size_bits;
 674     }
 675
 676   do_cleanups (cleanup);
 677 }
 678
 679 static void
 680 write_pieced_value (struct value *to, struct value *from)
 681 {
 682   int i;
 683   long offset = 0;
 684   ULONGEST bits_to_skip;
 685   const gdb_byte *contents;
 686   struct piece_closure *c
 687     = (struct piece_closure *) value_computed_closure (to);
 688   struct frame_info *frame = frame_find_by_id (VALUE_FRAME_ID (to));
 689   size_t type_len;
 690   size_t buffer_size = 0;
 691   char *buffer = NULL;
 692   struct cleanup *cleanup;
 693   int bits_big_endian
 694     = gdbarch_bits_big_endian (get_type_arch (value_type (to)));
 695
 696   if (frame == NULL)
 697     {
 698       set_value_optimized_out (to, 1);
 699       return;
 700     }
 701
 702   cleanup = make_cleanup (free_current_contents, &buffer);
 703
 704   contents = value_contents (from);
 705   bits_to_skip = 8 * value_offset (to);
 706   if (value_bitsize (to))
 707     {
 708       bits_to_skip += value_bitpos (to);
 709       type_len = value_bitsize (to);
 710     }
 711   else
 712     type_len = 8 * TYPE_LENGTH (value_type (to));
 713
 714   for (i = 0; i < c->n_pieces && offset < type_len; i++)
 715     {
 716       struct dwarf_expr_piece *p = &c->pieces[i];
 717       size_t this_size_bits, this_size;
 718       long dest_offset_bits, source_offset_bits, dest_offset, source_offset;
 719       int need_bitwise;
 720       const gdb_byte *source_buffer;
 721
 722       this_size_bits = p->size;
 723       if (bits_to_skip > 0 && bits_to_skip >= this_size_bits)
 724         {
 725           bits_to_skip -= this_size_bits;
 726           continue;
 727         }
 728       if (this_size_bits > type_len - offset)
 729         this_size_bits = type_len - offset;
 730       if (bits_to_skip > 0)
 731         {
 732           dest_offset_bits = bits_to_skip;
 733           source_offset_bits = 0;
 734           this_size_bits -= bits_to_skip;
 735           bits_to_skip = 0;
 736         }
 737       else
 738         {
 739           dest_offset_bits = 0;
 740           source_offset_bits = offset;
 741         }
 742
 743       this_size = (this_size_bits + source_offset_bits % 8 + 7) / 8;
 744       source_offset = source_offset_bits / 8;
 745       dest_offset = dest_offset_bits / 8;
 746       if (dest_offset_bits % 8 == 0 && source_offset_bits % 8 == 0)
 747         {
 748           source_buffer = contents + source_offset;
 749           need_bitwise = 0;
 750         }
 751       else
 752         {
 753           if (buffer_size < this_size)
 754             {
 755               buffer_size = this_size;
 756               buffer = xrealloc (buffer, buffer_size);
 757             }
 758           source_buffer = buffer;
 759           need_bitwise = 1;
 760         }
 761
 762       switch (p->location)
 763         {
 764         case DWARF_VALUE_REGISTER:
 765           {
 766             struct gdbarch *arch = get_frame_arch (frame);
 767             int gdb_regnum = gdbarch_dwarf2_reg_to_regnum (arch, p->v.value);
 768             int reg_offset = dest_offset;
 769
 770             if (gdbarch_byte_order (arch) == BFD_ENDIAN_BIG
 771                 && this_size <= register_size (arch, gdb_regnum))
 772               /* Big-endian, and we want less than full size.  */
 773               reg_offset = register_size (arch, gdb_regnum) - this_size;
 774
 775             if (gdb_regnum != -1)
 776               {
 777                 if (need_bitwise)
 778                   {
 779                     get_frame_register_bytes (frame, gdb_regnum, reg_offset,
 780                                               this_size, buffer);
 781                     copy_bitwise (buffer, dest_offset_bits,
 782                                   contents, source_offset_bits,
 783                                   this_size_bits,
 784                                   bits_big_endian);
 785                   }
 786
 787                 put_frame_register_bytes (frame, gdb_regnum, reg_offset,
 788                                           this_size, source_buffer);
 789               }
 790             else
 791               {
 792                 error (_("Unable to write to DWARF register number %s"),
 793                        paddress (arch, p->v.value));
 794               }
 795           }
 796           break;
 797         case DWARF_VALUE_MEMORY:
 798           if (need_bitwise)
 799             {
 800               /* Only the first and last bytes can possibly have any
 801                  bits reused.  */
 802               read_memory (p->v.mem.addr + dest_offset, buffer, 1);
 803               read_memory (p->v.mem.addr + dest_offset + this_size - 1,
 804                            buffer + this_size - 1, 1);
 805               copy_bitwise (buffer, dest_offset_bits,
 806                             contents, source_offset_bits,
 807                             this_size_bits,
 808                             bits_big_endian);
 809             }
 810
 811           write_memory (p->v.mem.addr + dest_offset,
 812                         source_buffer, this_size);
 813           break;
 814         default:
 815           set_value_optimized_out (to, 1);
 816           break;
 817         }
 818       offset += this_size_bits;
 819     }
 820
 821   do_cleanups (cleanup);
 822 }
 823
 824 /* A helper function that checks bit validity in a pieced value.
 825    CHECK_FOR indicates the kind of validity checking.
 826    DWARF_VALUE_MEMORY means to check whether any bit is valid.
 827    DWARF_VALUE_OPTIMIZED_OUT means to check whether any bit is
 828    optimized out.
 829    DWARF_VALUE_IMPLICIT_POINTER means to check whether the bits are an
 830    implicit pointer.  */
 831
 832 static int
 833 check_pieced_value_bits (const struct value *value, int bit_offset,
 834                          int bit_length,
 835                          enum dwarf_value_location check_for)
 836 {
 837   struct piece_closure *c
 838     = (struct piece_closure *) value_computed_closure (value);
 839   int i;
 840   int validity = (check_for == DWARF_VALUE_MEMORY
 841                   || check_for == DWARF_VALUE_IMPLICIT_POINTER);
 842
 843   bit_offset += 8 * value_offset (value);
 844   if (value_bitsize (value))
 845     bit_offset += value_bitpos (value);
 846
 847   for (i = 0; i < c->n_pieces && bit_length > 0; i++)
 848     {
 849       struct dwarf_expr_piece *p = &c->pieces[i];
 850       size_t this_size_bits = p->size;
 851
 852       if (bit_offset > 0)
 853         {
 854           if (bit_offset >= this_size_bits)
 855             {
 856               bit_offset -= this_size_bits;
 857               continue;
 858             }
 859
 860           bit_length -= this_size_bits - bit_offset;
 861           bit_offset = 0;
 862         }
 863       else
 864         bit_length -= this_size_bits;
 865
 866       if (check_for == DWARF_VALUE_IMPLICIT_POINTER)
 867         {
 868           if (p->location != DWARF_VALUE_IMPLICIT_POINTER)
 869             return 0;
 870         }
 871       else if (p->location == DWARF_VALUE_OPTIMIZED_OUT
 872                || p->location == DWARF_VALUE_IMPLICIT_POINTER)
 873         {
 874           if (validity)
 875             return 0;
 876         }
 877       else
 878         {
 879           if (!validity)
 880             return 1;
 881         }
 882     }
 883
 884   return validity;
 885 }
 886
 887 static int
 888 check_pieced_value_validity (const struct value *value, int bit_offset,
 889                              int bit_length)
 890 {
 891   return check_pieced_value_bits (value, bit_offset, bit_length,
 892                                   DWARF_VALUE_MEMORY);
 893 }
 894
 895 static int
 896 check_pieced_value_invalid (const struct value *value)
 897 {
 898   return check_pieced_value_bits (value, 0,
 899                                   8 * TYPE_LENGTH (value_type (value)),
 900                                   DWARF_VALUE_OPTIMIZED_OUT);
 901 }
 902
 903 /* An implementation of an lval_funcs method to see whether a value is
 904    a synthetic pointer.  */
 905
 906 static int
 907 check_pieced_synthetic_pointer (const struct value *value, int bit_offset,
 908                                 int bit_length)
 909 {
 910   return check_pieced_value_bits (value, bit_offset, bit_length,
 911                                   DWARF_VALUE_IMPLICIT_POINTER);
 912 }
 913
 914 /* A wrapper function for get_frame_address_in_block.  */
 915
 916 static CORE_ADDR
 917 get_frame_address_in_block_wrapper (void *baton)
 918 {
 919   return get_frame_address_in_block (baton);
 920 }
 921
 922 /* An implementation of an lval_funcs method to indirect through a
 923    pointer.  This handles the synthetic pointer case when needed.  */
 924
 925 static struct value *
 926 indirect_pieced_value (struct value *value)
 927 {
 928   struct piece_closure *c
 929     = (struct piece_closure *) value_computed_closure (value);
 930   struct type *type;
 931   struct frame_info *frame;
 932   struct dwarf2_locexpr_baton baton;
 933   int i, bit_offset, bit_length;
 934   struct dwarf_expr_piece *piece = NULL;
 935   struct value *result;
 936   LONGEST byte_offset;
 937
 938   type = value_type (value);
 939   if (TYPE_CODE (type) != TYPE_CODE_PTR)
 940     return NULL;
 941
 942   bit_length = 8 * TYPE_LENGTH (type);
 943   bit_offset = 8 * value_offset (value);
 944   if (value_bitsize (value))
 945     bit_offset += value_bitpos (value);
 946
 947   for (i = 0; i < c->n_pieces && bit_length > 0; i++)
 948     {
 949       struct dwarf_expr_piece *p = &c->pieces[i];
 950       size_t this_size_bits = p->size;
 951
 952       if (bit_offset > 0)
 953         {
 954           if (bit_offset >= this_size_bits)
 955             {
 956               bit_offset -= this_size_bits;
 957               continue;
 958             }
 959
 960           bit_length -= this_size_bits - bit_offset;
 961           bit_offset = 0;
 962         }
 963       else
 964         bit_length -= this_size_bits;
 965
 966       if (p->location != DWARF_VALUE_IMPLICIT_POINTER)
 967         return NULL;
 968
 969       if (bit_length != 0)
 970         error (_("Invalid use of DW_OP_GNU_implicit_pointer"));
 971
 972       piece = p;
 973       break;
 974     }
 975
 976   frame = get_selected_frame (_("No frame selected."));
 977   byte_offset = value_as_address (value);
 978
 979   baton = dwarf2_fetch_die_location_block (piece->v.ptr.die, c->per_cu,
 980                                            get_frame_address_in_block_wrapper,
 981                                            frame);
 982
 983   result = dwarf2_evaluate_loc_desc_full (TYPE_TARGET_TYPE (type), frame,
 984                                           baton.data, baton.size, baton.per_cu,
 985                                           byte_offset);
 986
 987   return result;
 988 }
 989
 990 static void *
 991 copy_pieced_value_closure (const struct value *v)
 992 {
 993   struct piece_closure *c
 994     = (struct piece_closure *) value_computed_closure (v);
 995
 996   ++c->refc;
 997   return c;
 998 }
 999
1000 static void
1001 free_pieced_value_closure (struct value *v)
1002 {
1003   struct piece_closure *c
1004     = (struct piece_closure *) value_computed_closure (v);
1005
1006   --c->refc;
1007   if (c->refc == 0)
1008     {
1009       xfree (c->pieces);
1010       xfree (c);
1011     }
1012 }
1013
1014 /* Functions for accessing a variable described by DW_OP_piece.  */
1015 static struct lval_funcs pieced_value_funcs = {
1016   read_pieced_value,
1017   write_pieced_value,
1018   check_pieced_value_validity,
1019   check_pieced_value_invalid,
1020   indirect_pieced_value,
1021   check_pieced_synthetic_pointer,
1022   copy_pieced_value_closure,
1023   free_pieced_value_closure
1024 };
1025
1026 /* Helper function which throws an error if a synthetic pointer is
1027    invalid.  */
1028
1029 static void
1030 invalid_synthetic_pointer (void)
1031 {
1032   error (_("access outside bounds of object "
1033            "referenced via synthetic pointer"));
1034 }
1035
1036 /* Evaluate a location description, starting at DATA and with length
1037    SIZE, to find the current location of variable of TYPE in the
1038    context of FRAME.  BYTE_OFFSET is applied after the contents are
1039    computed.  */
1040
1041 static struct value *
1042 dwarf2_evaluate_loc_desc_full (struct type *type, struct frame_info *frame,
1043                                const gdb_byte *data, unsigned short size,
1044                                struct dwarf2_per_cu_data *per_cu,
1045                                LONGEST byte_offset)
1046 {
1047   struct value *retval;
1048   struct dwarf_expr_baton baton;
1049   struct dwarf_expr_context *ctx;
1050   struct cleanup *old_chain;
1051   struct objfile *objfile = dwarf2_per_cu_objfile (per_cu);
1052
1053   if (byte_offset < 0)
1054     invalid_synthetic_pointer ();
1055
1056   if (size == 0)
1057     {
1058       retval = allocate_value (type);
1059       VALUE_LVAL (retval) = not_lval;
1060       set_value_optimized_out (retval, 1);
1061       return retval;
1062     }
1063
1064   baton.frame = frame;
1065   baton.per_cu = per_cu;
1066
1067   ctx = new_dwarf_expr_context ();
1068   old_chain = make_cleanup_free_dwarf_expr_context (ctx);
1069
1070   ctx->gdbarch = get_objfile_arch (objfile);
1071   ctx->addr_size = dwarf2_per_cu_addr_size (per_cu);
1072   ctx->offset = dwarf2_per_cu_text_offset (per_cu);
1073   ctx->baton = &baton;
1074   ctx->read_reg = dwarf_expr_read_reg;
1075   ctx->read_mem = dwarf_expr_read_mem;
1076   ctx->get_frame_base = dwarf_expr_frame_base;
1077   ctx->get_frame_cfa = dwarf_expr_frame_cfa;
1078   ctx->get_frame_pc = dwarf_expr_frame_pc;
1079   ctx->get_tls_address = dwarf_expr_tls_address;
1080   ctx->dwarf_call = dwarf_expr_dwarf_call;
1081
1082   dwarf_expr_eval (ctx, data, size);
1083   if (ctx->num_pieces > 0)
1084     {
1085       struct piece_closure *c;
1086       struct frame_id frame_id = get_frame_id (frame);
1087       ULONGEST bit_size = 0;
1088       int i;
1089
1090       for (i = 0; i < ctx->num_pieces; ++i)
1091         bit_size += ctx->pieces[i].size;
1092       if (8 * (byte_offset + TYPE_LENGTH (type)) > bit_size)
1093         invalid_synthetic_pointer ();
1094
1095       c = allocate_piece_closure (per_cu, ctx->num_pieces, ctx->pieces,
1096                                   ctx->addr_size);
1097       retval = allocate_computed_value (type, &pieced_value_funcs, c);
1098       VALUE_FRAME_ID (retval) = frame_id;
1099       set_value_offset (retval, byte_offset);
1100     }
1101   else
1102     {
1103       switch (ctx->location)
1104         {
1105         case DWARF_VALUE_REGISTER:
1106           {
1107             struct gdbarch *arch = get_frame_arch (frame);
1108             ULONGEST dwarf_regnum = dwarf_expr_fetch (ctx, 0);
1109             int gdb_regnum = gdbarch_dwarf2_reg_to_regnum (arch, dwarf_regnum);
1110
1111             if (byte_offset != 0)
1112               error (_("cannot use offset on synthetic pointer to register"));
1113             if (gdb_regnum != -1)
1114               retval = value_from_register (type, gdb_regnum, frame);
1115             else
1116               error (_("Unable to access DWARF register number %s"),
1117                      paddress (arch, dwarf_regnum));
1118           }
1119           break;
1120
1121         case DWARF_VALUE_MEMORY:
1122           {
1123             CORE_ADDR address = dwarf_expr_fetch_address (ctx, 0);
1124             int in_stack_memory = dwarf_expr_fetch_in_stack_memory (ctx, 0);
1125
1126             retval = allocate_value_lazy (type);
1127             VALUE_LVAL (retval) = lval_memory;
1128             if (in_stack_memory)
1129               set_value_stack (retval, 1);
1130             set_value_address (retval, address + byte_offset);
1131           }
1132           break;
1133
1134         case DWARF_VALUE_STACK:
1135           {
1136             ULONGEST value = dwarf_expr_fetch (ctx, 0);
1137             bfd_byte *contents, *tem;
1138             size_t n = ctx->addr_size;
1139
1140             if (byte_offset + TYPE_LENGTH (type) > n)
1141               invalid_synthetic_pointer ();
1142
1143             tem = alloca (n);
1144             store_unsigned_integer (tem, n,
1145                                     gdbarch_byte_order (ctx->gdbarch),
1146                                     value);
1147
1148             tem += byte_offset;
1149             n -= byte_offset;
1150
1151             retval = allocate_value (type);
1152             contents = value_contents_raw (retval);
1153             if (n > TYPE_LENGTH (type))
1154               n = TYPE_LENGTH (type);
1155             memcpy (contents, tem, n);
1156           }
1157           break;
1158
1159         case DWARF_VALUE_LITERAL:
1160           {
1161             bfd_byte *contents;
1162             const bfd_byte *data;
1163             size_t n = ctx->len;
1164
1165             if (byte_offset + TYPE_LENGTH (type) > n)
1166               invalid_synthetic_pointer ();
1167
1168             retval = allocate_value (type);
1169             contents = value_contents_raw (retval);
1170
1171             data = ctx->data + byte_offset;
1172             n -= byte_offset;
1173
1174             if (n > TYPE_LENGTH (type))
1175               n = TYPE_LENGTH (type);
1176             memcpy (contents, data, n);
1177           }
1178           break;
1179
1180           /* DWARF_VALUE_IMPLICIT_POINTER was converted to a pieced
1181              operation by execute_stack_op.  */
1182         case DWARF_VALUE_IMPLICIT_POINTER:
1183           /* DWARF_VALUE_OPTIMIZED_OUT can't occur in this context --
1184              it can only be encountered when making a piece.  */
1185         case DWARF_VALUE_OPTIMIZED_OUT:
1186         default:
1187           internal_error (__FILE__, __LINE__, _("invalid location type"));
1188         }
1189     }
1190
1191   set_value_initialized (retval, ctx->initialized);
1192
1193   do_cleanups (old_chain);
1194
1195   return retval;
1196 }
1197
1198 /* The exported interface to dwarf2_evaluate_loc_desc_full; it always
1199    passes 0 as the byte_offset.  */
1200
1201 struct value *
1202 dwarf2_evaluate_loc_desc (struct type *type, struct frame_info *frame,
1203                           const gdb_byte *data, unsigned short size,
1204                           struct dwarf2_per_cu_data *per_cu)
1205 {
1206   return dwarf2_evaluate_loc_desc_full (type, frame, data, size, per_cu, 0);
1207 }
1208
1209 \f
1210 /* Helper functions and baton for dwarf2_loc_desc_needs_frame.  */
1211
1212 struct needs_frame_baton
1213 {
1214   int needs_frame;
1215   struct dwarf2_per_cu_data *per_cu;
1216 };
1217
1218 /* Reads from registers do require a frame.  */
1219 static CORE_ADDR
1220 needs_frame_read_reg (void *baton, int regnum)
1221 {
1222   struct needs_frame_baton *nf_baton = baton;
1223
1224   nf_baton->needs_frame = 1;
1225   return 1;
1226 }
1227
1228 /* Reads from memory do not require a frame.  */
1229 static void
1230 needs_frame_read_mem (void *baton, gdb_byte *buf, CORE_ADDR addr, size_t len)
1231 {
1232   memset (buf, 0, len);
1233 }
1234
1235 /* Frame-relative accesses do require a frame.  */
1236 static void
1237 needs_frame_frame_base (void *baton, const gdb_byte **start, size_t * length)
1238 {
1239   static gdb_byte lit0 = DW_OP_lit0;
1240   struct needs_frame_baton *nf_baton = baton;
1241
1242   *start = &lit0;
1243   *length = 1;
1244
1245   nf_baton->needs_frame = 1;
1246 }
1247
1248 /* CFA accesses require a frame.  */
1249
1250 static CORE_ADDR
1251 needs_frame_frame_cfa (void *baton)
1252 {
1253   struct needs_frame_baton *nf_baton = baton;
1254
1255   nf_baton->needs_frame = 1;
1256   return 1;
1257 }
1258
1259 /* Thread-local accesses do require a frame.  */
1260 static CORE_ADDR
1261 needs_frame_tls_address (void *baton, CORE_ADDR offset)
1262 {
1263   struct needs_frame_baton *nf_baton = baton;
1264
1265   nf_baton->needs_frame = 1;
1266   return 1;
1267 }
1268
1269 /* Helper interface of per_cu_dwarf_call for dwarf2_loc_desc_needs_frame.  */
1270
1271 static void
1272 needs_frame_dwarf_call (struct dwarf_expr_context *ctx, size_t die_offset)
1273 {
1274   struct needs_frame_baton *nf_baton = ctx->baton;
1275
1276   return per_cu_dwarf_call (ctx, die_offset, nf_baton->per_cu,
1277                             ctx->get_frame_pc, ctx->baton);
1278 }
1279
1280 /* Return non-zero iff the location expression at DATA (length SIZE)
1281    requires a frame to evaluate.  */
1282
1283 static int
1284 dwarf2_loc_desc_needs_frame (const gdb_byte *data, unsigned short size,
1285                              struct dwarf2_per_cu_data *per_cu)
1286 {
1287   struct needs_frame_baton baton;
1288   struct dwarf_expr_context *ctx;
1289   int in_reg;
1290   struct cleanup *old_chain;
1291   struct objfile *objfile = dwarf2_per_cu_objfile (per_cu);
1292
1293   baton.needs_frame = 0;
1294   baton.per_cu = per_cu;
1295
1296   ctx = new_dwarf_expr_context ();
1297   old_chain = make_cleanup_free_dwarf_expr_context (ctx);
1298
1299   ctx->gdbarch = get_objfile_arch (objfile);
1300   ctx->addr_size = dwarf2_per_cu_addr_size (per_cu);
1301   ctx->offset = dwarf2_per_cu_text_offset (per_cu);
1302   ctx->baton = &baton;
1303   ctx->read_reg = needs_frame_read_reg;
1304   ctx->read_mem = needs_frame_read_mem;
1305   ctx->get_frame_base = needs_frame_frame_base;
1306   ctx->get_frame_cfa = needs_frame_frame_cfa;
1307   ctx->get_frame_pc = needs_frame_frame_cfa;
1308   ctx->get_tls_address = needs_frame_tls_address;
1309   ctx->dwarf_call = needs_frame_dwarf_call;
1310
1311   dwarf_expr_eval (ctx, data, size);
1312
1313   in_reg = ctx->location == DWARF_VALUE_REGISTER;
1314
1315   if (ctx->num_pieces > 0)
1316     {
1317       int i;
1318
1319       /* If the location has several pieces, and any of them are in
1320          registers, then we will need a frame to fetch them from.  */
1321       for (i = 0; i < ctx->num_pieces; i++)
1322         if (ctx->pieces[i].location == DWARF_VALUE_REGISTER)
1323           in_reg = 1;
1324     }
1325
1326   do_cleanups (old_chain);
1327
1328   return baton.needs_frame || in_reg;
1329 }
1330
1331 /* A helper function that throws an unimplemented error mentioning a
1332    given DWARF operator.  */
1333
1334 static void
1335 unimplemented (unsigned int op)
1336 {
1337   const char *name = dwarf_stack_op_name (op);
1338
1339   if (name)
1340     error (_("DWARF operator %s cannot be translated to an agent expression"),
1341            name);
1342   else
1343     error (_("Unknown DWARF operator 0x%02x cannot be translated "
1344              "to an agent expression"),
1345            op);
1346 }
1347
1348 /* A helper function to convert a DWARF register to an arch register.
1349    ARCH is the architecture.
1350    DWARF_REG is the register.
1351    This will throw an exception if the DWARF register cannot be
1352    translated to an architecture register.  */
1353
1354 static int
1355 translate_register (struct gdbarch *arch, int dwarf_reg)
1356 {
1357   int reg = gdbarch_dwarf2_reg_to_regnum (arch, dwarf_reg);
1358   if (reg == -1)
1359     error (_("Unable to access DWARF register number %d"), dwarf_reg);
1360   return reg;
1361 }
1362
1363 /* A helper function that emits an access to memory.  ARCH is the
1364    target architecture.  EXPR is the expression which we are building.
1365    NBITS is the number of bits we want to read.  This emits the
1366    opcodes needed to read the memory and then extract the desired
1367    bits.  */
1368
1369 static void
1370 access_memory (struct gdbarch *arch, struct agent_expr *expr, ULONGEST nbits)
1371 {
1372   ULONGEST nbytes = (nbits + 7) / 8;
1373
1374   gdb_assert (nbits > 0 && nbits <= sizeof (LONGEST));
1375
1376   if (trace_kludge)
1377     ax_trace_quick (expr, nbytes);
1378
1379   if (nbits <= 8)
1380     ax_simple (expr, aop_ref8);
1381   else if (nbits <= 16)
1382     ax_simple (expr, aop_ref16);
1383   else if (nbits <= 32)
1384     ax_simple (expr, aop_ref32);
1385   else
1386     ax_simple (expr, aop_ref64);
1387
1388   /* If we read exactly the number of bytes we wanted, we're done.  */
1389   if (8 * nbytes == nbits)
1390     return;
1391
1392   if (gdbarch_bits_big_endian (arch))
1393     {
1394       /* On a bits-big-endian machine, we want the high-order
1395          NBITS.  */
1396       ax_const_l (expr, 8 * nbytes - nbits);
1397       ax_simple (expr, aop_rsh_unsigned);
1398     }
1399   else
1400     {
1401       /* On a bits-little-endian box, we want the low-order NBITS.  */
1402       ax_zero_ext (expr, nbits);
1403     }
1404 }
1405
1406 /* A helper function to return the frame's PC.  */
1407
1408 static CORE_ADDR
1409 get_ax_pc (void *baton)
1410 {
1411   struct agent_expr *expr = baton;
1412
1413   return expr->scope;
1414 }
1415
1416 /* Compile a DWARF location expression to an agent expression.
1417
1418    EXPR is the agent expression we are building.
1419    LOC is the agent value we modify.
1420    ARCH is the architecture.
1421    ADDR_SIZE is the size of addresses, in bytes.
1422    OP_PTR is the start of the location expression.
1423    OP_END is one past the last byte of the location expression.
1424
1425    This will throw an exception for various kinds of errors -- for
1426    example, if the expression cannot be compiled, or if the expression
1427    is invalid.  */
1428
1429 void
1430 dwarf2_compile_expr_to_ax (struct agent_expr *expr, struct axs_value *loc,
1431                            struct gdbarch *arch, unsigned int addr_size,
1432                            const gdb_byte *op_ptr, const gdb_byte *op_end,
1433                            struct dwarf2_per_cu_data *per_cu)
1434 {
1435   struct cleanup *cleanups;
1436   int i, *offsets;
1437   VEC(int) *dw_labels = NULL, *patches = NULL;
1438   const gdb_byte * const base = op_ptr;
1439   const gdb_byte *previous_piece = op_ptr;
1440   enum bfd_endian byte_order = gdbarch_byte_order (arch);
1441   ULONGEST bits_collected = 0;
1442   unsigned int addr_size_bits = 8 * addr_size;
1443   int bits_big_endian = gdbarch_bits_big_endian (arch);
1444
1445   offsets = xmalloc ((op_end - op_ptr) * sizeof (int));
1446   cleanups = make_cleanup (xfree, offsets);
1447
1448   for (i = 0; i < op_end - op_ptr; ++i)
1449     offsets[i] = -1;
1450
1451   make_cleanup (VEC_cleanup (int), &dw_labels);
1452   make_cleanup (VEC_cleanup (int), &patches);
1453
1454   /* By default we are making an address.  */
1455   loc->kind = axs_lvalue_memory;
1456
1457   while (op_ptr < op_end)
1458     {
1459       enum dwarf_location_atom op = *op_ptr;
1460       ULONGEST uoffset, reg;
1461       LONGEST offset;
1462       int i;
1463
1464       offsets[op_ptr - base] = expr->len;
1465       ++op_ptr;
1466
1467       /* Our basic approach to code generation is to map DWARF
1468          operations directly to AX operations.  However, there are
1469          some differences.
1470
1471          First, DWARF works on address-sized units, but AX always uses
1472          LONGEST.  For most operations we simply ignore this
1473          difference; instead we generate sign extensions as needed
1474          before division and comparison operations.  It would be nice
1475          to omit the sign extensions, but there is no way to determine
1476          the size of the target's LONGEST.  (This code uses the size
1477          of the host LONGEST in some cases -- that is a bug but it is
1478          difficult to fix.)
1479
1480          Second, some DWARF operations cannot be translated to AX.
1481          For these we simply fail.  See
1482          http://sourceware.org/bugzilla/show_bug.cgi?id=11662.  */
1483       switch (op)
1484         {
1485         case DW_OP_lit0:
1486         case DW_OP_lit1:
1487         case DW_OP_lit2:
1488         case DW_OP_lit3:
1489         case DW_OP_lit4:
1490         case DW_OP_lit5:
1491         case DW_OP_lit6:
1492         case DW_OP_lit7:
1493         case DW_OP_lit8:
1494         case DW_OP_lit9:
1495         case DW_OP_lit10:
1496         case DW_OP_lit11:
1497         case DW_OP_lit12:
1498         case DW_OP_lit13:
1499         case DW_OP_lit14:
1500         case DW_OP_lit15:
1501         case DW_OP_lit16:
1502         case DW_OP_lit17:
1503         case DW_OP_lit18:
1504         case DW_OP_lit19:
1505         case DW_OP_lit20:
1506         case DW_OP_lit21:
1507         case DW_OP_lit22:
1508         case DW_OP_lit23:
1509         case DW_OP_lit24:
1510         case DW_OP_lit25:
1511         case DW_OP_lit26:
1512         case DW_OP_lit27:
1513         case DW_OP_lit28:
1514         case DW_OP_lit29:
1515         case DW_OP_lit30:
1516         case DW_OP_lit31:
1517           ax_const_l (expr, op - DW_OP_lit0);
1518           break;
1519
1520         case DW_OP_addr:
1521           uoffset = extract_unsigned_integer (op_ptr, addr_size, byte_order);
1522           op_ptr += addr_size;
1523           /* Some versions of GCC emit DW_OP_addr before
1524              DW_OP_GNU_push_tls_address.  In this case the value is an
1525              index, not an address.  We don't support things like
1526              branching between the address and the TLS op.  */
1527           if (op_ptr >= op_end || *op_ptr != DW_OP_GNU_push_tls_address)
1528             uoffset += dwarf2_per_cu_text_offset (per_cu);
1529           ax_const_l (expr, uoffset);
1530           break;
1531
1532         case DW_OP_const1u:
1533           ax_const_l (expr, extract_unsigned_integer (op_ptr, 1, byte_order));
1534           op_ptr += 1;
1535           break;
1536         case DW_OP_const1s:
1537           ax_const_l (expr, extract_signed_integer (op_ptr, 1, byte_order));
1538           op_ptr += 1;
1539           break;
1540         case DW_OP_const2u:
1541           ax_const_l (expr, extract_unsigned_integer (op_ptr, 2, byte_order));
1542           op_ptr += 2;
1543           break;
1544         case DW_OP_const2s:
1545           ax_const_l (expr, extract_signed_integer (op_ptr, 2, byte_order));
1546           op_ptr += 2;
1547           break;
1548         case DW_OP_const4u:
1549           ax_const_l (expr, extract_unsigned_integer (op_ptr, 4, byte_order));
1550           op_ptr += 4;
1551           break;
1552         case DW_OP_const4s:
1553           ax_const_l (expr, extract_signed_integer (op_ptr, 4, byte_order));
1554           op_ptr += 4;
1555           break;
1556         case DW_OP_const8u:
1557           ax_const_l (expr, extract_unsigned_integer (op_ptr, 8, byte_order));
1558           op_ptr += 8;
1559           break;
1560         case DW_OP_const8s:
1561           ax_const_l (expr, extract_signed_integer (op_ptr, 8, byte_order));
1562           op_ptr += 8;
1563           break;
1564         case DW_OP_constu:
1565           op_ptr = read_uleb128 (op_ptr, op_end, &uoffset);
1566           ax_const_l (expr, uoffset);
1567           break;
1568         case DW_OP_consts:
1569           op_ptr = read_sleb128 (op_ptr, op_end, &offset);
1570           ax_const_l (expr, offset);
1571           break;
1572
1573         case DW_OP_reg0:
1574         case DW_OP_reg1:
1575         case DW_OP_reg2:
1576         case DW_OP_reg3:
1577         case DW_OP_reg4:
1578         case DW_OP_reg5:
1579         case DW_OP_reg6:
1580         case DW_OP_reg7:
1581         case DW_OP_reg8:
1582         case DW_OP_reg9:
1583         case DW_OP_reg10:
1584         case DW_OP_reg11:
1585         case DW_OP_reg12:
1586         case DW_OP_reg13:
1587         case DW_OP_reg14:
1588         case DW_OP_reg15:
1589         case DW_OP_reg16:
1590         case DW_OP_reg17:
1591         case DW_OP_reg18:
1592         case DW_OP_reg19:
1593         case DW_OP_reg20:
1594         case DW_OP_reg21:
1595         case DW_OP_reg22:
1596         case DW_OP_reg23:
1597         case DW_OP_reg24:
1598         case DW_OP_reg25:
1599         case DW_OP_reg26:
1600         case DW_OP_reg27:
1601         case DW_OP_reg28:
1602         case DW_OP_reg29:
1603         case DW_OP_reg30:
1604         case DW_OP_reg31:
1605           dwarf_expr_require_composition (op_ptr, op_end, "DW_OP_regx");
1606           loc->u.reg = translate_register (arch, op - DW_OP_reg0);
1607           loc->kind = axs_lvalue_register;
1608           break;
1609
1610         case DW_OP_regx:
1611           op_ptr = read_uleb128 (op_ptr, op_end, &reg);
1612           dwarf_expr_require_composition (op_ptr, op_end, "DW_OP_regx");
1613           loc->u.reg = translate_register (arch, reg);
1614           loc->kind = axs_lvalue_register;
1615           break;
1616
1617         case DW_OP_implicit_value:
1618           {
1619             ULONGEST len;
1620
1621             op_ptr = read_uleb128 (op_ptr, op_end, &len);
1622             if (op_ptr + len > op_end)
1623               error (_("DW_OP_implicit_value: too few bytes available."));
1624             if (len > sizeof (ULONGEST))
1625               error (_("Cannot translate DW_OP_implicit_value of %d bytes"),
1626                      (int) len);
1627
1628             ax_const_l (expr, extract_unsigned_integer (op_ptr, len,
1629                                                         byte_order));
1630             op_ptr += len;
1631             dwarf_expr_require_composition (op_ptr, op_end,
1632                                             "DW_OP_implicit_value");
1633
1634             loc->kind = axs_rvalue;
1635           }
1636           break;
1637
1638         case DW_OP_stack_value:
1639           dwarf_expr_require_composition (op_ptr, op_end, "DW_OP_stack_value");
1640           loc->kind = axs_rvalue;
1641           break;
1642
1643         case DW_OP_breg0:
1644         case DW_OP_breg1:
1645         case DW_OP_breg2:
1646         case DW_OP_breg3:
1647         case DW_OP_breg4:
1648         case DW_OP_breg5:
1649         case DW_OP_breg6:
1650         case DW_OP_breg7:
1651         case DW_OP_breg8:
1652         case DW_OP_breg9:
1653         case DW_OP_breg10:
1654         case DW_OP_breg11:
1655         case DW_OP_breg12:
1656         case DW_OP_breg13:
1657         case DW_OP_breg14:
1658         case DW_OP_breg15:
1659         case DW_OP_breg16:
1660         case DW_OP_breg17:
1661         case DW_OP_breg18:
1662         case DW_OP_breg19:
1663         case DW_OP_breg20:
1664         case DW_OP_breg21:
1665         case DW_OP_breg22:
1666         case DW_OP_breg23:
1667         case DW_OP_breg24:
1668         case DW_OP_breg25:
1669         case DW_OP_breg26:
1670         case DW_OP_breg27:
1671         case DW_OP_breg28:
1672         case DW_OP_breg29:
1673         case DW_OP_breg30:
1674         case DW_OP_breg31:
1675           op_ptr = read_sleb128 (op_ptr, op_end, &offset);
1676           i = translate_register (arch, op - DW_OP_breg0);
1677           ax_reg (expr, i);
1678           if (offset != 0)
1679             {
1680               ax_const_l (expr, offset);
1681               ax_simple (expr, aop_add);
1682             }
1683           break;
1684         case DW_OP_bregx:
1685           {
1686             op_ptr = read_uleb128 (op_ptr, op_end, &reg);
1687             op_ptr = read_sleb128 (op_ptr, op_end, &offset);
1688             i = translate_register (arch, reg);
1689             ax_reg (expr, i);
1690             if (offset != 0)
1691               {
1692                 ax_const_l (expr, offset);
1693                 ax_simple (expr, aop_add);
1694               }
1695           }
1696           break;
1697         case DW_OP_fbreg:
1698           {
1699             const gdb_byte *datastart;
1700             size_t datalen;
1701             unsigned int before_stack_len;
1702             struct block *b;
1703             struct symbol *framefunc;
1704             LONGEST base_offset = 0;
1705
1706             b = block_for_pc (expr->scope);
1707
1708             if (!b)
1709               error (_("No block found for address"));
1710
1711             framefunc = block_linkage_function (b);
1712
1713             if (!framefunc)
1714               error (_("No function found for block"));
1715
1716             dwarf_expr_frame_base_1 (framefunc, expr->scope,
1717                                      &datastart, &datalen);
1718
1719             op_ptr = read_sleb128 (op_ptr, op_end, &offset);
1720             dwarf2_compile_expr_to_ax (expr, loc, arch, addr_size, datastart,
1721                                        datastart + datalen, per_cu);
1722
1723             if (offset != 0)
1724               {
1725                 ax_const_l (expr, offset);
1726                 ax_simple (expr, aop_add);
1727               }
1728
1729             loc->kind = axs_lvalue_memory;
1730           }
1731           break;
1732
1733         case DW_OP_dup:
1734           ax_simple (expr, aop_dup);
1735           break;
1736
1737         case DW_OP_drop:
1738           ax_simple (expr, aop_pop);
1739           break;
1740
1741         case DW_OP_pick:
1742           offset = *op_ptr++;
1743           unimplemented (op);
1744           break;
1745
1746         case DW_OP_swap:
1747           ax_simple (expr, aop_swap);
1748           break;
1749
1750         case DW_OP_over:
1751           /* We can't directly support DW_OP_over, but GCC emits it as
1752              part of a sequence to implement signed modulus.  As a
1753              hack, we recognize this sequence.  Note that if GCC ever
1754              generates a branch to the middle of this sequence, then
1755              we will die somehow.  */
1756           if (op_end - op_ptr >= 4
1757               && op_ptr[0] == DW_OP_over
1758               && op_ptr[1] == DW_OP_div
1759               && op_ptr[2] == DW_OP_mul
1760               && op_ptr[3] == DW_OP_minus)
1761             {
1762               /* Sign extend the operands.  */
1763               ax_ext (expr, addr_size_bits);
1764               ax_simple (expr, aop_swap);
1765               ax_ext (expr, addr_size_bits);
1766               ax_simple (expr, aop_swap);
1767               ax_simple (expr, aop_rem_signed);
1768               op_ptr += 4;
1769             }
1770           else
1771             unimplemented (op);
1772           break;
1773
1774         case DW_OP_rot:
1775           unimplemented (op);
1776           break;
1777
1778         case DW_OP_deref:
1779         case DW_OP_deref_size:
1780           {
1781             int size;
1782
1783             if (op == DW_OP_deref_size)
1784               size = *op_ptr++;
1785             else
1786               size = addr_size;
1787
1788             switch (size)
1789               {
1790               case 8:
1791                 ax_simple (expr, aop_ref8);
1792                 break;
1793               case 16:
1794                 ax_simple (expr, aop_ref16);
1795                 break;
1796               case 32:
1797                 ax_simple (expr, aop_ref32);
1798                 break;
1799               case 64:
1800                 ax_simple (expr, aop_ref64);
1801                 break;
1802               default:
1803                 /* Note that dwarf_stack_op_name will never return
1804                    NULL here.  */
1805                 error (_("Unsupported size %d in %s"),
1806                        size, dwarf_stack_op_name (op));
1807               }
1808           }
1809           break;
1810
1811         case DW_OP_abs:
1812           /* Sign extend the operand.  */
1813           ax_ext (expr, addr_size_bits);
1814           ax_simple (expr, aop_dup);
1815           ax_const_l (expr, 0);
1816           ax_simple (expr, aop_less_signed);
1817           ax_simple (expr, aop_log_not);
1818           i = ax_goto (expr, aop_if_goto);
1819           /* We have to emit 0 - X.  */
1820           ax_const_l (expr, 0);
1821           ax_simple (expr, aop_swap);
1822           ax_simple (expr, aop_sub);
1823           ax_label (expr, i, expr->len);
1824           break;
1825
1826         case DW_OP_neg:
1827           /* No need to sign extend here.  */
1828           ax_const_l (expr, 0);
1829           ax_simple (expr, aop_swap);
1830           ax_simple (expr, aop_sub);
1831           break;
1832
1833         case DW_OP_not:
1834           /* Sign extend the operand.  */
1835           ax_ext (expr, addr_size_bits);
1836           ax_simple (expr, aop_bit_not);
1837           break;
1838
1839         case DW_OP_plus_uconst:
1840           op_ptr = read_uleb128 (op_ptr, op_end, &reg);
1841           /* It would be really weird to emit `DW_OP_plus_uconst 0',
1842              but we micro-optimize anyhow.  */
1843           if (reg != 0)
1844             {
1845               ax_const_l (expr, reg);
1846               ax_simple (expr, aop_add);
1847             }
1848           break;
1849
1850         case DW_OP_and:
1851           ax_simple (expr, aop_bit_and);
1852           break;
1853
1854         case DW_OP_div:
1855           /* Sign extend the operands.  */
1856           ax_ext (expr, addr_size_bits);
1857           ax_simple (expr, aop_swap);
1858           ax_ext (expr, addr_size_bits);
1859           ax_simple (expr, aop_swap);
1860           ax_simple (expr, aop_div_signed);
1861           break;
1862
1863         case DW_OP_minus:
1864           ax_simple (expr, aop_sub);
1865           break;
1866
1867         case DW_OP_mod:
1868           ax_simple (expr, aop_rem_unsigned);
1869           break;
1870
1871         case DW_OP_mul:
1872           ax_simple (expr, aop_mul);
1873           break;
1874
1875         case DW_OP_or:
1876           ax_simple (expr, aop_bit_or);
1877           break;
1878
1879         case DW_OP_plus:
1880           ax_simple (expr, aop_add);
1881           break;
1882
1883         case DW_OP_shl:
1884           ax_simple (expr, aop_lsh);
1885           break;
1886
1887         case DW_OP_shr:
1888           ax_simple (expr, aop_rsh_unsigned);
1889           break;
1890
1891         case DW_OP_shra:
1892           ax_simple (expr, aop_rsh_signed);
1893           break;
1894
1895         case DW_OP_xor:
1896           ax_simple (expr, aop_bit_xor);
1897           break;
1898
1899         case DW_OP_le:
1900           /* Sign extend the operands.  */
1901           ax_ext (expr, addr_size_bits);
1902           ax_simple (expr, aop_swap);
1903           ax_ext (expr, addr_size_bits);
1904           /* Note no swap here: A <= B is !(B < A).  */
1905           ax_simple (expr, aop_less_signed);
1906           ax_simple (expr, aop_log_not);
1907           break;
1908
1909         case DW_OP_ge:
1910           /* Sign extend the operands.  */
1911           ax_ext (expr, addr_size_bits);
1912           ax_simple (expr, aop_swap);
1913           ax_ext (expr, addr_size_bits);
1914           ax_simple (expr, aop_swap);
1915           /* A >= B is !(A < B).  */
1916           ax_simple (expr, aop_less_signed);
1917           ax_simple (expr, aop_log_not);
1918           break;
1919
1920         case DW_OP_eq:
1921           /* Sign extend the operands.  */
1922           ax_ext (expr, addr_size_bits);
1923           ax_simple (expr, aop_swap);
1924           ax_ext (expr, addr_size_bits);
1925           /* No need for a second swap here.  */
1926           ax_simple (expr, aop_equal);
1927           break;
1928
1929         case DW_OP_lt:
1930           /* Sign extend the operands.  */
1931           ax_ext (expr, addr_size_bits);
1932           ax_simple (expr, aop_swap);
1933           ax_ext (expr, addr_size_bits);
1934           ax_simple (expr, aop_swap);
1935           ax_simple (expr, aop_less_signed);
1936           break;
1937
1938         case DW_OP_gt:
1939           /* Sign extend the operands.  */
1940           ax_ext (expr, addr_size_bits);
1941           ax_simple (expr, aop_swap);
1942           ax_ext (expr, addr_size_bits);
1943           /* Note no swap here: A > B is B < A.  */
1944           ax_simple (expr, aop_less_signed);
1945           break;
1946
1947         case DW_OP_ne:
1948           /* Sign extend the operands.  */
1949           ax_ext (expr, addr_size_bits);
1950           ax_simple (expr, aop_swap);
1951           ax_ext (expr, addr_size_bits);
1952           /* No need for a swap here.  */
1953           ax_simple (expr, aop_equal);
1954           ax_simple (expr, aop_log_not);
1955           break;
1956
1957         case DW_OP_call_frame_cfa:
1958           dwarf2_compile_cfa_to_ax (expr, loc, arch, expr->scope, per_cu);
1959           loc->kind = axs_lvalue_memory;
1960           break;
1961
1962         case DW_OP_GNU_push_tls_address:
1963           unimplemented (op);
1964           break;
1965
1966         case DW_OP_skip:
1967           offset = extract_signed_integer (op_ptr, 2, byte_order);
1968           op_ptr += 2;
1969           i = ax_goto (expr, aop_goto);
1970           VEC_safe_push (int, dw_labels, op_ptr + offset - base);
1971           VEC_safe_push (int, patches, i);
1972           break;
1973
1974         case DW_OP_bra:
1975           offset = extract_signed_integer (op_ptr, 2, byte_order);
1976           op_ptr += 2;
1977           /* Zero extend the operand.  */
1978           ax_zero_ext (expr, addr_size_bits);
1979           i = ax_goto (expr, aop_if_goto);
1980           VEC_safe_push (int, dw_labels, op_ptr + offset - base);
1981           VEC_safe_push (int, patches, i);
1982           break;
1983
1984         case DW_OP_nop:
1985           break;
1986
1987         case DW_OP_piece:
1988         case DW_OP_bit_piece:
1989           {
1990             ULONGEST size, offset;
1991
1992             if (op_ptr - 1 == previous_piece)
1993               error (_("Cannot translate empty pieces to agent expressions"));
1994             previous_piece = op_ptr - 1;
1995
1996             op_ptr = read_uleb128 (op_ptr, op_end, &size);
1997             if (op == DW_OP_piece)
1998               {
1999                 size *= 8;
2000                 offset = 0;
2001               }
2002             else
2003               op_ptr = read_uleb128 (op_ptr, op_end, &offset);
2004
2005             if (bits_collected + size > 8 * sizeof (LONGEST))
2006               error (_("Expression pieces exceed word size"));
2007
2008             /* Access the bits.  */
2009             switch (loc->kind)
2010               {
2011               case axs_lvalue_register:
2012                 ax_reg (expr, loc->u.reg);
2013                 break;
2014
2015               case axs_lvalue_memory:
2016                 /* Offset the pointer, if needed.  */
2017                 if (offset > 8)
2018                   {
2019                     ax_const_l (expr, offset / 8);
2020                     ax_simple (expr, aop_add);
2021                     offset %= 8;
2022                   }
2023                 access_memory (arch, expr, size);
2024                 break;
2025               }
2026
2027             /* For a bits-big-endian target, shift up what we already
2028                have.  For a bits-little-endian target, shift up the
2029                new data.  Note that there is a potential bug here if
2030                the DWARF expression leaves multiple values on the
2031                stack.  */
2032             if (bits_collected > 0)
2033               {
2034                 if (bits_big_endian)
2035                   {
2036                     ax_simple (expr, aop_swap);
2037                     ax_const_l (expr, size);
2038                     ax_simple (expr, aop_lsh);
2039                     /* We don't need a second swap here, because
2040                        aop_bit_or is symmetric.  */
2041                   }
2042                 else
2043                   {
2044                     ax_const_l (expr, size);
2045                     ax_simple (expr, aop_lsh);
2046                   }
2047                 ax_simple (expr, aop_bit_or);
2048               }
2049
2050             bits_collected += size;
2051             loc->kind = axs_rvalue;
2052           }
2053           break;
2054
2055         case DW_OP_GNU_uninit:
2056           unimplemented (op);
2057
2058         case DW_OP_call2:
2059         case DW_OP_call4:
2060           {
2061             struct dwarf2_locexpr_baton block;
2062             int size = (op == DW_OP_call2 ? 2 : 4);
2063
2064             uoffset = extract_unsigned_integer (op_ptr, size, byte_order);
2065             op_ptr += size;
2066
2067             block = dwarf2_fetch_die_location_block (uoffset, per_cu,
2068                                                      get_ax_pc, expr);
2069
2070             /* DW_OP_call_ref is currently not supported.  */
2071             gdb_assert (block.per_cu == per_cu);
2072
2073             dwarf2_compile_expr_to_ax (expr, loc, arch, addr_size,
2074                                        block.data, block.data + block.size,
2075                                        per_cu);
2076           }
2077           break;
2078
2079         case DW_OP_call_ref:
2080           unimplemented (op);
2081
2082         default:
2083           unimplemented (op);
2084         }
2085     }
2086
2087   /* Patch all the branches we emitted.  */
2088   for (i = 0; i < VEC_length (int, patches); ++i)
2089     {
2090       int targ = offsets[VEC_index (int, dw_labels, i)];
2091       if (targ == -1)
2092         internal_error (__FILE__, __LINE__, _("invalid label"));
2093       ax_label (expr, VEC_index (int, patches, i), targ);
2094     }
2095
2096   do_cleanups (cleanups);
2097 }
2098
2099 \f
2100 /* Return the value of SYMBOL in FRAME using the DWARF-2 expression
2101    evaluator to calculate the location.  */
2102 static struct value *
2103 locexpr_read_variable (struct symbol *symbol, struct frame_info *frame)
2104 {
2105   struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
2106   struct value *val;
2107
2108   val = dwarf2_evaluate_loc_desc (SYMBOL_TYPE (symbol), frame, dlbaton->data,
2109                                   dlbaton->size, dlbaton->per_cu);
2110
2111   return val;
2112 }
2113
2114 /* Return non-zero iff we need a frame to evaluate SYMBOL.  */
2115 static int
2116 locexpr_read_needs_frame (struct symbol *symbol)
2117 {
2118   struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
2119
2120   return dwarf2_loc_desc_needs_frame (dlbaton->data, dlbaton->size,
2121                                       dlbaton->per_cu);
2122 }
2123
2124 /* Return true if DATA points to the end of a piece.  END is one past
2125    the last byte in the expression.  */
2126
2127 static int
2128 piece_end_p (const gdb_byte *data, const gdb_byte *end)
2129 {
2130   return data == end || data[0] == DW_OP_piece || data[0] == DW_OP_bit_piece;
2131 }
2132
2133 /* Nicely describe a single piece of a location, returning an updated
2134    position in the bytecode sequence.  This function cannot recognize
2135    all locations; if a location is not recognized, it simply returns
2136    DATA.  */
2137
2138 static const gdb_byte *
2139 locexpr_describe_location_piece (struct symbol *symbol, struct ui_file *stream,
2140                                  CORE_ADDR addr, struct objfile *objfile,
2141                                  const gdb_byte *data, const gdb_byte *end,
2142                                  unsigned int addr_size)
2143 {
2144   struct gdbarch *gdbarch = get_objfile_arch (objfile);
2145   int regno;
2146
2147   if (data[0] >= DW_OP_reg0 && data[0] <= DW_OP_reg31)
2148     {
2149       regno = gdbarch_dwarf2_reg_to_regnum (gdbarch, data[0] - DW_OP_reg0);
2150       fprintf_filtered (stream, _("a variable in $%s"),
2151                         gdbarch_register_name (gdbarch, regno));
2152       data += 1;
2153     }
2154   else if (data[0] == DW_OP_regx)
2155     {
2156       ULONGEST reg;
2157
2158       data = read_uleb128 (data + 1, end, &reg);
2159       regno = gdbarch_dwarf2_reg_to_regnum (gdbarch, reg);
2160       fprintf_filtered (stream, _("a variable in $%s"),
2161                         gdbarch_register_name (gdbarch, regno));
2162     }
2163   else if (data[0] == DW_OP_fbreg)
2164     {
2165       struct block *b;
2166       struct symbol *framefunc;
2167       int frame_reg = 0;
2168       LONGEST frame_offset;
2169       const gdb_byte *base_data, *new_data, *save_data = data;
2170       size_t base_size;
2171       LONGEST base_offset = 0;
2172
2173       new_data = read_sleb128 (data + 1, end, &frame_offset);
2174       if (!piece_end_p (new_data, end))
2175         return data;
2176       data = new_data;
2177
2178       b = block_for_pc (addr);
2179
2180       if (!b)
2181         error (_("No block found for address for symbol \"%s\"."),
2182                SYMBOL_PRINT_NAME (symbol));
2183
2184       framefunc = block_linkage_function (b);
2185
2186       if (!framefunc)
2187         error (_("No function found for block for symbol \"%s\"."),
2188                SYMBOL_PRINT_NAME (symbol));
2189
2190       dwarf_expr_frame_base_1 (framefunc, addr, &base_data, &base_size);
2191
2192       if (base_data[0] >= DW_OP_breg0 && base_data[0] <= DW_OP_breg31)
2193         {
2194           const gdb_byte *buf_end;
2195
2196           frame_reg = base_data[0] - DW_OP_breg0;
2197           buf_end = read_sleb128 (base_data + 1,
2198                                   base_data + base_size, &base_offset);
2199           if (buf_end != base_data + base_size)
2200             error (_("Unexpected opcode after "
2201                      "DW_OP_breg%u for symbol \"%s\"."),
2202                    frame_reg, SYMBOL_PRINT_NAME (symbol));
2203         }
2204       else if (base_data[0] >= DW_OP_reg0 && base_data[0] <= DW_OP_reg31)
2205         {
2206           /* The frame base is just the register, with no offset.  */
2207           frame_reg = base_data[0] - DW_OP_reg0;
2208           base_offset = 0;
2209         }
2210       else
2211         {
2212           /* We don't know what to do with the frame base expression,
2213              so we can't trace this variable; give up.  */
2214           return save_data;
2215         }
2216
2217       regno = gdbarch_dwarf2_reg_to_regnum (gdbarch, frame_reg);
2218
2219       fprintf_filtered (stream,
2220                         _("a variable at frame base reg $%s offset %s+%s"),
2221                         gdbarch_register_name (gdbarch, regno),
2222                         plongest (base_offset), plongest (frame_offset));
2223     }
2224   else if (data[0] >= DW_OP_breg0 && data[0] <= DW_OP_breg31
2225            && piece_end_p (data, end))
2226     {
2227       LONGEST offset;
2228
2229       regno = gdbarch_dwarf2_reg_to_regnum (gdbarch, data[0] - DW_OP_breg0);
2230
2231       data = read_sleb128 (data + 1, end, &offset);
2232
2233       fprintf_filtered (stream,
2234                         _("a variable at offset %s from base reg $%s"),
2235                         plongest (offset),
2236                         gdbarch_register_name (gdbarch, regno));
2237     }
2238
2239   /* The location expression for a TLS variable looks like this (on a
2240      64-bit LE machine):
2241
2242      DW_AT_location    : 10 byte block: 3 4 0 0 0 0 0 0 0 e0
2243                         (DW_OP_addr: 4; DW_OP_GNU_push_tls_address)
2244
2245      0x3 is the encoding for DW_OP_addr, which has an operand as long
2246      as the size of an address on the target machine (here is 8
2247      bytes).  Note that more recent version of GCC emit DW_OP_const4u
2248      or DW_OP_const8u, depending on address size, rather than
2249      DW_OP_addr.  0xe0 is the encoding for DW_OP_GNU_push_tls_address.
2250      The operand represents the offset at which the variable is within
2251      the thread local storage.  */
2252
2253   else if (data + 1 + addr_size < end
2254            && (data[0] == DW_OP_addr
2255                || (addr_size == 4 && data[0] == DW_OP_const4u)
2256                || (addr_size == 8 && data[0] == DW_OP_const8u))
2257            && data[1 + addr_size] == DW_OP_GNU_push_tls_address
2258            && piece_end_p (data + 2 + addr_size, end))
2259     {
2260       ULONGEST offset;
2261       offset = extract_unsigned_integer (data + 1, addr_size,
2262                                          gdbarch_byte_order (gdbarch));
2263
2264       fprintf_filtered (stream,
2265                         _("a thread-local variable at offset 0x%s "
2266                           "in the thread-local storage for `%s'"),
2267                         phex_nz (offset, addr_size), objfile->name);
2268
2269       data += 1 + addr_size + 1;
2270     }
2271   else if (data[0] >= DW_OP_lit0
2272            && data[0] <= DW_OP_lit31
2273            && data + 1 < end
2274            && data[1] == DW_OP_stack_value)
2275     {
2276       fprintf_filtered (stream, _("the constant %d"), data[0] - DW_OP_lit0);
2277       data += 2;
2278     }
2279
2280   return data;
2281 }
2282
2283 /* Disassemble an expression, stopping at the end of a piece or at the
2284    end of the expression.  Returns a pointer to the next unread byte
2285    in the input expression.  If ALL is nonzero, then this function
2286    will keep going until it reaches the end of the expression.  */
2287
2288 static const gdb_byte *
2289 disassemble_dwarf_expression (struct ui_file *stream,
2290                               struct gdbarch *arch, unsigned int addr_size,
2291                               int offset_size,
2292                               const gdb_byte *data, const gdb_byte *end,
2293                               int all)
2294 {
2295   const gdb_byte *start = data;
2296
2297   fprintf_filtered (stream, _("a complex DWARF expression:\n"));
2298
2299   while (data < end
2300          && (all
2301              || (data[0] != DW_OP_piece && data[0] != DW_OP_bit_piece)))
2302     {
2303       enum dwarf_location_atom op = *data++;
2304       ULONGEST ul;
2305       LONGEST l;
2306       const char *name;
2307
2308       name = dwarf_stack_op_name (op);
2309
2310       if (!name)
2311         error (_("Unrecognized DWARF opcode 0x%02x at %ld"),
2312                op, (long) (data - start));
2313       fprintf_filtered (stream, "  % 4ld: %s", (long) (data - start), name);
2314
2315       switch (op)
2316         {
2317         case DW_OP_addr:
2318           ul = extract_unsigned_integer (data, addr_size,
2319                                          gdbarch_byte_order (arch));
2320           data += addr_size;
2321           fprintf_filtered (stream, " 0x%s", phex_nz (ul, addr_size));
2322           break;
2323
2324         case DW_OP_const1u:
2325           ul = extract_unsigned_integer (data, 1, gdbarch_byte_order (arch));
2326           data += 1;
2327           fprintf_filtered (stream, " %s", pulongest (ul));
2328           break;
2329         case DW_OP_const1s:
2330           l = extract_signed_integer (data, 1, gdbarch_byte_order (arch));
2331           data += 1;
2332           fprintf_filtered (stream, " %s", plongest (l));
2333           break;
2334         case DW_OP_const2u:
2335           ul = extract_unsigned_integer (data, 2, gdbarch_byte_order (arch));
2336           data += 2;
2337           fprintf_filtered (stream, " %s", pulongest (ul));
2338           break;
2339         case DW_OP_const2s:
2340           l = extract_signed_integer (data, 2, gdbarch_byte_order (arch));
2341           data += 2;
2342           fprintf_filtered (stream, " %s", plongest (l));
2343           break;
2344         case DW_OP_const4u:
2345           ul = extract_unsigned_integer (data, 4, gdbarch_byte_order (arch));
2346           data += 4;
2347           fprintf_filtered (stream, " %s", pulongest (ul));
2348           break;
2349         case DW_OP_const4s:
2350           l = extract_signed_integer (data, 4, gdbarch_byte_order (arch));
2351           data += 4;
2352           fprintf_filtered (stream, " %s", plongest (l));
2353           break;
2354         case DW_OP_const8u:
2355           ul = extract_unsigned_integer (data, 8, gdbarch_byte_order (arch));
2356           data += 8;
2357           fprintf_filtered (stream, " %s", pulongest (ul));
2358           break;
2359         case DW_OP_const8s:
2360           l = extract_signed_integer (data, 8, gdbarch_byte_order (arch));
2361           data += 8;
2362           fprintf_filtered (stream, " %s", plongest (l));
2363           break;
2364         case DW_OP_constu:
2365           data = read_uleb128 (data, end, &ul);
2366           fprintf_filtered (stream, " %s", pulongest (ul));
2367           break;
2368         case DW_OP_consts:
2369           data = read_sleb128 (data, end, &l);
2370           fprintf_filtered (stream, " %s", plongest (l));
2371           break;
2372
2373         case DW_OP_reg0:
2374         case DW_OP_reg1:
2375         case DW_OP_reg2:
2376         case DW_OP_reg3:
2377         case DW_OP_reg4:
2378         case DW_OP_reg5:
2379         case DW_OP_reg6:
2380         case DW_OP_reg7:
2381         case DW_OP_reg8:
2382         case DW_OP_reg9:
2383         case DW_OP_reg10:
2384         case DW_OP_reg11:
2385         case DW_OP_reg12:
2386         case DW_OP_reg13:
2387         case DW_OP_reg14:
2388         case DW_OP_reg15:
2389         case DW_OP_reg16:
2390         case DW_OP_reg17:
2391         case DW_OP_reg18:
2392         case DW_OP_reg19:
2393         case DW_OP_reg20:
2394         case DW_OP_reg21:
2395         case DW_OP_reg22:
2396         case DW_OP_reg23:
2397         case DW_OP_reg24:
2398         case DW_OP_reg25:
2399         case DW_OP_reg26:
2400         case DW_OP_reg27:
2401         case DW_OP_reg28:
2402         case DW_OP_reg29:
2403         case DW_OP_reg30:
2404         case DW_OP_reg31:
2405           fprintf_filtered (stream, " [$%s]",
2406                             gdbarch_register_name (arch, op - DW_OP_reg0));
2407           break;
2408
2409         case DW_OP_regx:
2410           data = read_uleb128 (data, end, &ul);
2411           fprintf_filtered (stream, " %s [$%s]", pulongest (ul),
2412                             gdbarch_register_name (arch, (int) ul));
2413           break;
2414
2415         case DW_OP_implicit_value:
2416           data = read_uleb128 (data, end, &ul);
2417           data += ul;
2418           fprintf_filtered (stream, " %s", pulongest (ul));
2419           break;
2420
2421         case DW_OP_breg0:
2422         case DW_OP_breg1:
2423         case DW_OP_breg2:
2424         case DW_OP_breg3:
2425         case DW_OP_breg4:
2426         case DW_OP_breg5:
2427         case DW_OP_breg6:
2428         case DW_OP_breg7:
2429         case DW_OP_breg8:
2430         case DW_OP_breg9:
2431         case DW_OP_breg10:
2432         case DW_OP_breg11:
2433         case DW_OP_breg12:
2434         case DW_OP_breg13:
2435         case DW_OP_breg14:
2436         case DW_OP_breg15:
2437         case DW_OP_breg16:
2438         case DW_OP_breg17:
2439         case DW_OP_breg18:
2440         case DW_OP_breg19:
2441         case DW_OP_breg20:
2442         case DW_OP_breg21:
2443         case DW_OP_breg22:
2444         case DW_OP_breg23:
2445         case DW_OP_breg24:
2446         case DW_OP_breg25:
2447         case DW_OP_breg26:
2448         case DW_OP_breg27:
2449         case DW_OP_breg28:
2450         case DW_OP_breg29:
2451         case DW_OP_breg30:
2452         case DW_OP_breg31:
2453           data = read_sleb128 (data, end, &ul);
2454           fprintf_filtered (stream, " %s [$%s]", pulongest (ul),
2455                             gdbarch_register_name (arch, op - DW_OP_breg0));
2456           break;
2457
2458         case DW_OP_bregx:
2459           {
2460             ULONGEST offset;
2461
2462             data = read_uleb128 (data, end, &ul);
2463             data = read_sleb128 (data, end, &offset);
2464             fprintf_filtered (stream, " register %s [$%s] offset %s",
2465                               pulongest (ul),
2466                               gdbarch_register_name (arch, (int) ul),
2467                               pulongest (offset));
2468           }
2469           break;
2470
2471         case DW_OP_fbreg:
2472           data = read_sleb128 (data, end, &ul);
2473           fprintf_filtered (stream, " %s", pulongest (ul));
2474           break;
2475
2476         case DW_OP_xderef_size:
2477         case DW_OP_deref_size:
2478         case DW_OP_pick:
2479           fprintf_filtered (stream, " %d", *data);
2480           ++data;
2481           break;
2482
2483         case DW_OP_plus_uconst:
2484           data = read_uleb128 (data, end, &ul);
2485           fprintf_filtered (stream, " %s", pulongest (ul));
2486           break;
2487
2488         case DW_OP_skip:
2489           l = extract_signed_integer (data, 2, gdbarch_byte_order (arch));
2490           data += 2;
2491           fprintf_filtered (stream, " to %ld",
2492                             (long) (data + l - start));
2493           break;
2494
2495         case DW_OP_bra:
2496           l = extract_signed_integer (data, 2, gdbarch_byte_order (arch));
2497           data += 2;
2498           fprintf_filtered (stream, " %ld",
2499                             (long) (data + l - start));
2500           break;
2501
2502         case DW_OP_call2:
2503           ul = extract_unsigned_integer (data, 2, gdbarch_byte_order (arch));
2504           data += 2;
2505           fprintf_filtered (stream, " offset %s", phex_nz (ul, 2));
2506           break;
2507
2508         case DW_OP_call4:
2509           ul = extract_unsigned_integer (data, 4, gdbarch_byte_order (arch));
2510           data += 4;
2511           fprintf_filtered (stream, " offset %s", phex_nz (ul, 4));
2512           break;
2513
2514         case DW_OP_call_ref:
2515           ul = extract_unsigned_integer (data, offset_size,
2516                                          gdbarch_byte_order (arch));
2517           data += offset_size;
2518           fprintf_filtered (stream, " offset %s", phex_nz (ul, offset_size));
2519           break;
2520
2521         case DW_OP_piece:
2522           data = read_uleb128 (data, end, &ul);
2523           fprintf_filtered (stream, " %s (bytes)", pulongest (ul));
2524           break;
2525
2526         case DW_OP_bit_piece:
2527           {
2528             ULONGEST offset;
2529
2530             data = read_uleb128 (data, end, &ul);
2531             data = read_uleb128 (data, end, &offset);
2532             fprintf_filtered (stream, " size %s offset %s (bits)",
2533                               pulongest (ul), pulongest (offset));
2534           }
2535           break;
2536
2537         case DW_OP_GNU_implicit_pointer:
2538           {
2539             ul = extract_unsigned_integer (data, offset_size,
2540                                            gdbarch_byte_order (arch));
2541             data += offset_size;
2542
2543             data = read_sleb128 (data, end, &l);
2544
2545             fprintf_filtered (stream, " DIE %s offset %s",
2546                               phex_nz (ul, offset_size),
2547                               plongest (l));
2548           }
2549           break;
2550         }
2551
2552       fprintf_filtered (stream, "\n");
2553     }
2554
2555   return data;
2556 }
2557
2558 /* Describe a single location, which may in turn consist of multiple
2559    pieces.  */
2560
2561 static void
2562 locexpr_describe_location_1 (struct symbol *symbol, CORE_ADDR addr,
2563                              struct ui_file *stream,
2564                              const gdb_byte *data, int size,
2565                              struct objfile *objfile, unsigned int addr_size,
2566                              int offset_size)
2567 {
2568   const gdb_byte *end = data + size;
2569   int first_piece = 1, bad = 0;
2570
2571   while (data < end)
2572     {
2573       const gdb_byte *here = data;
2574       int disassemble = 1;
2575
2576       if (first_piece)
2577         first_piece = 0;
2578       else
2579         fprintf_filtered (stream, _(", and "));
2580
2581       if (!dwarf2_always_disassemble)
2582         {
2583           data = locexpr_describe_location_piece (symbol, stream,
2584                                                   addr, objfile,
2585                                                   data, end, addr_size);
2586           /* If we printed anything, or if we have an empty piece,
2587              then don't disassemble.  */
2588           if (data != here
2589               || data[0] == DW_OP_piece
2590               || data[0] == DW_OP_bit_piece)
2591             disassemble = 0;
2592         }
2593       if (disassemble)
2594         data = disassemble_dwarf_expression (stream,
2595                                              get_objfile_arch (objfile),
2596                                              addr_size, offset_size, data, end,
2597                                              dwarf2_always_disassemble);
2598
2599       if (data < end)
2600         {
2601           int empty = data == here;
2602
2603           if (disassemble)
2604             fprintf_filtered (stream, "   ");
2605           if (data[0] == DW_OP_piece)
2606             {
2607               ULONGEST bytes;
2608
2609               data = read_uleb128 (data + 1, end, &bytes);
2610
2611               if (empty)
2612                 fprintf_filtered (stream, _("an empty %s-byte piece"),
2613                                   pulongest (bytes));
2614               else
2615                 fprintf_filtered (stream, _(" [%s-byte piece]"),
2616                                   pulongest (bytes));
2617             }
2618           else if (data[0] == DW_OP_bit_piece)
2619             {
2620               ULONGEST bits, offset;
2621
2622               data = read_uleb128 (data + 1, end, &bits);
2623               data = read_uleb128 (data, end, &offset);
2624
2625               if (empty)
2626                 fprintf_filtered (stream,
2627                                   _("an empty %s-bit piece"),
2628                                   pulongest (bits));
2629               else
2630                 fprintf_filtered (stream,
2631                                   _(" [%s-bit piece, offset %s bits]"),
2632                                   pulongest (bits), pulongest (offset));
2633             }
2634           else
2635             {
2636               bad = 1;
2637               break;
2638             }
2639         }
2640     }
2641
2642   if (bad || data > end)
2643     error (_("Corrupted DWARF2 expression for \"%s\"."),
2644            SYMBOL_PRINT_NAME (symbol));
2645 }
2646
2647 /* Print a natural-language description of SYMBOL to STREAM.  This
2648    version is for a symbol with a single location.  */
2649
2650 static void
2651 locexpr_describe_location (struct symbol *symbol, CORE_ADDR addr,
2652                            struct ui_file *stream)
2653 {
2654   struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
2655   struct objfile *objfile = dwarf2_per_cu_objfile (dlbaton->per_cu);
2656   unsigned int addr_size = dwarf2_per_cu_addr_size (dlbaton->per_cu);
2657   int offset_size = dwarf2_per_cu_offset_size (dlbaton->per_cu);
2658
2659   locexpr_describe_location_1 (symbol, addr, stream,
2660                                dlbaton->data, dlbaton->size,
2661                                objfile, addr_size, offset_size);
2662 }
2663
2664 /* Describe the location of SYMBOL as an agent value in VALUE, generating
2665    any necessary bytecode in AX.  */
2666
2667 static void
2668 locexpr_tracepoint_var_ref (struct symbol *symbol, struct gdbarch *gdbarch,
2669                             struct agent_expr *ax, struct axs_value *value)
2670 {
2671   struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
2672   unsigned int addr_size = dwarf2_per_cu_addr_size (dlbaton->per_cu);
2673
2674   if (dlbaton->data == NULL || dlbaton->size == 0)
2675     value->optimized_out = 1;
2676   else
2677     dwarf2_compile_expr_to_ax (ax, value, gdbarch, addr_size,
2678                                dlbaton->data, dlbaton->data + dlbaton->size,
2679                                dlbaton->per_cu);
2680 }
2681
2682 /* The set of location functions used with the DWARF-2 expression
2683    evaluator.  */
2684 const struct symbol_computed_ops dwarf2_locexpr_funcs = {
2685   locexpr_read_variable,
2686   locexpr_read_needs_frame,
2687   locexpr_describe_location,
2688   locexpr_tracepoint_var_ref
2689 };
2690
2691
2692 /* Wrapper functions for location lists.  These generally find
2693    the appropriate location expression and call something above.  */
2694
2695 /* Return the value of SYMBOL in FRAME using the DWARF-2 expression
2696    evaluator to calculate the location.  */
2697 static struct value *
2698 loclist_read_variable (struct symbol *symbol, struct frame_info *frame)
2699 {
2700   struct dwarf2_loclist_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
2701   struct value *val;
2702   const gdb_byte *data;
2703   size_t size;
2704   CORE_ADDR pc = frame ? get_frame_address_in_block (frame) : 0;
2705
2706   data = dwarf2_find_location_expression (dlbaton, &size, pc);
2707   if (data == NULL)
2708     {
2709       val = allocate_value (SYMBOL_TYPE (symbol));
2710       VALUE_LVAL (val) = not_lval;
2711       set_value_optimized_out (val, 1);
2712     }
2713   else
2714     val = dwarf2_evaluate_loc_desc (SYMBOL_TYPE (symbol), frame, data, size,
2715                                     dlbaton->per_cu);
2716
2717   return val;
2718 }
2719
2720 /* Return non-zero iff we need a frame to evaluate SYMBOL.  */
2721 static int
2722 loclist_read_needs_frame (struct symbol *symbol)
2723 {
2724   /* If there's a location list, then assume we need to have a frame
2725      to choose the appropriate location expression.  With tracking of
2726      global variables this is not necessarily true, but such tracking
2727      is disabled in GCC at the moment until we figure out how to
2728      represent it.  */
2729
2730   return 1;
2731 }
2732
2733 /* Print a natural-language description of SYMBOL to STREAM.  This
2734    version applies when there is a list of different locations, each
2735    with a specified address range.  */
2736
2737 static void
2738 loclist_describe_location (struct symbol *symbol, CORE_ADDR addr,
2739                            struct ui_file *stream)
2740 {
2741   struct dwarf2_loclist_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
2742   CORE_ADDR low, high;
2743   const gdb_byte *loc_ptr, *buf_end;
2744   int length, first = 1;
2745   struct objfile *objfile = dwarf2_per_cu_objfile (dlbaton->per_cu);
2746   struct gdbarch *gdbarch = get_objfile_arch (objfile);
2747   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
2748   unsigned int addr_size = dwarf2_per_cu_addr_size (dlbaton->per_cu);
2749   int offset_size = dwarf2_per_cu_offset_size (dlbaton->per_cu);
2750   int signed_addr_p = bfd_get_sign_extend_vma (objfile->obfd);
2751   CORE_ADDR base_mask = ~(~(CORE_ADDR)1 << (addr_size * 8 - 1));
2752   /* Adjust base_address for relocatable objects.  */
2753   CORE_ADDR base_offset = dwarf2_per_cu_text_offset (dlbaton->per_cu);
2754   CORE_ADDR base_address = dlbaton->base_address + base_offset;
2755
2756   loc_ptr = dlbaton->data;
2757   buf_end = dlbaton->data + dlbaton->size;
2758
2759   fprintf_filtered (stream, _("multi-location:\n"));
2760
2761   /* Iterate through locations until we run out.  */
2762   while (1)
2763     {
2764       if (buf_end - loc_ptr < 2 * addr_size)
2765         error (_("Corrupted DWARF expression for symbol \"%s\"."),
2766                SYMBOL_PRINT_NAME (symbol));
2767
2768       if (signed_addr_p)
2769         low = extract_signed_integer (loc_ptr, addr_size, byte_order);
2770       else
2771         low = extract_unsigned_integer (loc_ptr, addr_size, byte_order);
2772       loc_ptr += addr_size;
2773
2774       if (signed_addr_p)
2775         high = extract_signed_integer (loc_ptr, addr_size, byte_order);
2776       else
2777         high = extract_unsigned_integer (loc_ptr, addr_size, byte_order);
2778       loc_ptr += addr_size;
2779
2780       /* A base-address-selection entry.  */
2781       if ((low & base_mask) == base_mask)
2782         {
2783           base_address = high + base_offset;
2784           fprintf_filtered (stream, _("  Base address %s"),
2785                             paddress (gdbarch, base_address));
2786           continue;
2787         }
2788
2789       /* An end-of-list entry.  */
2790       if (low == 0 && high == 0)
2791         break;
2792
2793       /* Otherwise, a location expression entry.  */
2794       low += base_address;
2795       high += base_address;
2796
2797       length = extract_unsigned_integer (loc_ptr, 2, byte_order);
2798       loc_ptr += 2;
2799
2800       /* (It would improve readability to print only the minimum
2801          necessary digits of the second number of the range.)  */
2802       fprintf_filtered (stream, _("  Range %s-%s: "),
2803                         paddress (gdbarch, low), paddress (gdbarch, high));
2804
2805       /* Now describe this particular location.  */
2806       locexpr_describe_location_1 (symbol, low, stream, loc_ptr, length,
2807                                    objfile, addr_size, offset_size);
2808
2809       fprintf_filtered (stream, "\n");
2810
2811       loc_ptr += length;
2812     }
2813 }
2814
2815 /* Describe the location of SYMBOL as an agent value in VALUE, generating
2816    any necessary bytecode in AX.  */
2817 static void
2818 loclist_tracepoint_var_ref (struct symbol *symbol, struct gdbarch *gdbarch,
2819                             struct agent_expr *ax, struct axs_value *value)
2820 {
2821   struct dwarf2_loclist_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
2822   const gdb_byte *data;
2823   size_t size;
2824   unsigned int addr_size = dwarf2_per_cu_addr_size (dlbaton->per_cu);
2825
2826   data = dwarf2_find_location_expression (dlbaton, &size, ax->scope);
2827   if (data == NULL || size == 0)
2828     value->optimized_out = 1;
2829   else
2830     dwarf2_compile_expr_to_ax (ax, value, gdbarch, addr_size, data, data + size,
2831                                dlbaton->per_cu);
2832 }
2833
2834 /* The set of location functions used with the DWARF-2 expression
2835    evaluator and location lists.  */
2836 const struct symbol_computed_ops dwarf2_loclist_funcs = {
2837   loclist_read_variable,
2838   loclist_read_needs_frame,
2839   loclist_describe_location,
2840   loclist_tracepoint_var_ref
2841 };