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