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   LONGEST byte_offset;
 968
 969   type = check_typedef (value_type (value));
 970   if (TYPE_CODE (type) != TYPE_CODE_PTR)
 971     return NULL;
 972
 973   bit_length = 8 * TYPE_LENGTH (type);
 974   bit_offset = 8 * value_offset (value);
 975   if (value_bitsize (value))
 976     bit_offset += value_bitpos (value);
 977
 978   for (i = 0; i < c->n_pieces && bit_length > 0; i++)
 979     {
 980       struct dwarf_expr_piece *p = &c->pieces[i];
 981       size_t this_size_bits = p->size;
 982
 983       if (bit_offset > 0)
 984         {
 985           if (bit_offset >= this_size_bits)
 986             {
 987               bit_offset -= this_size_bits;
 988               continue;
 989             }
 990
 991           bit_length -= this_size_bits - bit_offset;
 992           bit_offset = 0;
 993         }
 994       else
 995         bit_length -= this_size_bits;
 996
 997       if (p->location != DWARF_VALUE_IMPLICIT_POINTER)
 998         return NULL;
 999
1000       if (bit_length != 0)
1001         error (_("Invalid use of DW_OP_GNU_implicit_pointer"));
1002
1003       piece = p;
1004       break;
1005     }
1006
1007   frame = get_selected_frame (_("No frame selected."));
1008
1009   /* This is an offset requested by GDB, such as value subcripts.  */
1010   byte_offset = value_as_address (value);
1011
1012   gdb_assert (piece);
1013   baton = dwarf2_fetch_die_location_block (piece->v.ptr.die, c->per_cu,
1014                                            get_frame_address_in_block_wrapper,
1015                                            frame);
1016
1017   return dwarf2_evaluate_loc_desc_full (TYPE_TARGET_TYPE (type), frame,
1018                                         baton.data, baton.size, baton.per_cu,
1019                                         piece->v.ptr.offset + byte_offset);
1020 }
1021
1022 static void *
1023 copy_pieced_value_closure (const struct value *v)
1024 {
1025   struct piece_closure *c
1026     = (struct piece_closure *) value_computed_closure (v);
1027
1028   ++c->refc;
1029   return c;
1030 }
1031
1032 static void
1033 free_pieced_value_closure (struct value *v)
1034 {
1035   struct piece_closure *c
1036     = (struct piece_closure *) value_computed_closure (v);
1037
1038   --c->refc;
1039   if (c->refc == 0)
1040     {
1041       int i;
1042
1043       for (i = 0; i < c->n_pieces; ++i)
1044         if (c->pieces[i].location == DWARF_VALUE_STACK)
1045           value_free (c->pieces[i].v.value);
1046
1047       xfree (c->pieces);
1048       xfree (c);
1049     }
1050 }
1051
1052 /* Functions for accessing a variable described by DW_OP_piece.  */
1053 static const struct lval_funcs pieced_value_funcs = {
1054   read_pieced_value,
1055   write_pieced_value,
1056   check_pieced_value_validity,
1057   check_pieced_value_invalid,
1058   indirect_pieced_value,
1059   check_pieced_synthetic_pointer,
1060   copy_pieced_value_closure,
1061   free_pieced_value_closure
1062 };
1063
1064 /* Helper function which throws an error if a synthetic pointer is
1065    invalid.  */
1066
1067 static void
1068 invalid_synthetic_pointer (void)
1069 {
1070   error (_("access outside bounds of object "
1071            "referenced via synthetic pointer"));
1072 }
1073
1074 /* Virtual method table for dwarf2_evaluate_loc_desc_full below.  */
1075
1076 static const struct dwarf_expr_context_funcs dwarf_expr_ctx_funcs =
1077 {
1078   dwarf_expr_read_reg,
1079   dwarf_expr_read_mem,
1080   dwarf_expr_frame_base,
1081   dwarf_expr_frame_cfa,
1082   dwarf_expr_frame_pc,
1083   dwarf_expr_tls_address,
1084   dwarf_expr_dwarf_call,
1085   dwarf_expr_get_base_type
1086 };
1087
1088 /* Evaluate a location description, starting at DATA and with length
1089    SIZE, to find the current location of variable of TYPE in the
1090    context of FRAME.  BYTE_OFFSET is applied after the contents are
1091    computed.  */
1092
1093 static struct value *
1094 dwarf2_evaluate_loc_desc_full (struct type *type, struct frame_info *frame,
1095                                const gdb_byte *data, unsigned short size,
1096                                struct dwarf2_per_cu_data *per_cu,
1097                                LONGEST byte_offset)
1098 {
1099   struct value *retval;
1100   struct dwarf_expr_baton baton;
1101   struct dwarf_expr_context *ctx;
1102   struct cleanup *old_chain, *value_chain;
1103   struct objfile *objfile = dwarf2_per_cu_objfile (per_cu);
1104   volatile struct gdb_exception ex;
1105
1106   if (byte_offset < 0)
1107     invalid_synthetic_pointer ();
1108
1109   if (size == 0)
1110     return allocate_optimized_out_value (type);
1111
1112   baton.frame = frame;
1113   baton.per_cu = per_cu;
1114
1115   ctx = new_dwarf_expr_context ();
1116   old_chain = make_cleanup_free_dwarf_expr_context (ctx);
1117   value_chain = make_cleanup_value_free_to_mark (value_mark ());
1118
1119   ctx->gdbarch = get_objfile_arch (objfile);
1120   ctx->addr_size = dwarf2_per_cu_addr_size (per_cu);
1121   ctx->ref_addr_size = dwarf2_per_cu_ref_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               {
1224                 struct gdbarch *objfile_gdbarch = get_objfile_arch (objfile);
1225
1226                 if (gdbarch_byte_order (objfile_gdbarch) == BFD_ENDIAN_BIG)
1227                   val_bytes += n - TYPE_LENGTH (type);
1228                 n = TYPE_LENGTH (type);
1229               }
1230             memcpy (contents, val_bytes, n);
1231           }
1232           break;
1233
1234         case DWARF_VALUE_LITERAL:
1235           {
1236             bfd_byte *contents;
1237             const bfd_byte *ldata;
1238             size_t n = ctx->len;
1239
1240             if (byte_offset + TYPE_LENGTH (type) > n)
1241               invalid_synthetic_pointer ();
1242
1243             do_cleanups (value_chain);
1244             retval = allocate_value (type);
1245             contents = value_contents_raw (retval);
1246
1247             ldata = ctx->data + byte_offset;
1248             n -= byte_offset;
1249
1250             if (n > TYPE_LENGTH (type))
1251               {
1252                 struct gdbarch *objfile_gdbarch = get_objfile_arch (objfile);
1253
1254                 if (gdbarch_byte_order (objfile_gdbarch) == BFD_ENDIAN_BIG)
1255                   ldata += n - TYPE_LENGTH (type);
1256                 n = TYPE_LENGTH (type);
1257               }
1258             memcpy (contents, ldata, n);
1259           }
1260           break;
1261
1262         case DWARF_VALUE_OPTIMIZED_OUT:
1263           do_cleanups (value_chain);
1264           retval = allocate_optimized_out_value (type);
1265           break;
1266
1267           /* DWARF_VALUE_IMPLICIT_POINTER was converted to a pieced
1268              operation by execute_stack_op.  */
1269         case DWARF_VALUE_IMPLICIT_POINTER:
1270           /* DWARF_VALUE_OPTIMIZED_OUT can't occur in this context --
1271              it can only be encountered when making a piece.  */
1272         default:
1273           internal_error (__FILE__, __LINE__, _("invalid location type"));
1274         }
1275     }
1276
1277   set_value_initialized (retval, ctx->initialized);
1278
1279   do_cleanups (old_chain);
1280
1281   return retval;
1282 }
1283
1284 /* The exported interface to dwarf2_evaluate_loc_desc_full; it always
1285    passes 0 as the byte_offset.  */
1286
1287 struct value *
1288 dwarf2_evaluate_loc_desc (struct type *type, struct frame_info *frame,
1289                           const gdb_byte *data, unsigned short size,
1290                           struct dwarf2_per_cu_data *per_cu)
1291 {
1292   return dwarf2_evaluate_loc_desc_full (type, frame, data, size, per_cu, 0);
1293 }
1294
1295 \f
1296 /* Helper functions and baton for dwarf2_loc_desc_needs_frame.  */
1297
1298 struct needs_frame_baton
1299 {
1300   int needs_frame;
1301   struct dwarf2_per_cu_data *per_cu;
1302 };
1303
1304 /* Reads from registers do require a frame.  */
1305 static CORE_ADDR
1306 needs_frame_read_reg (void *baton, int regnum)
1307 {
1308   struct needs_frame_baton *nf_baton = baton;
1309
1310   nf_baton->needs_frame = 1;
1311   return 1;
1312 }
1313
1314 /* Reads from memory do not require a frame.  */
1315 static void
1316 needs_frame_read_mem (void *baton, gdb_byte *buf, CORE_ADDR addr, size_t len)
1317 {
1318   memset (buf, 0, len);
1319 }
1320
1321 /* Frame-relative accesses do require a frame.  */
1322 static void
1323 needs_frame_frame_base (void *baton, const gdb_byte **start, size_t * length)
1324 {
1325   static gdb_byte lit0 = DW_OP_lit0;
1326   struct needs_frame_baton *nf_baton = baton;
1327
1328   *start = &lit0;
1329   *length = 1;
1330
1331   nf_baton->needs_frame = 1;
1332 }
1333
1334 /* CFA accesses require a frame.  */
1335
1336 static CORE_ADDR
1337 needs_frame_frame_cfa (void *baton)
1338 {
1339   struct needs_frame_baton *nf_baton = baton;
1340
1341   nf_baton->needs_frame = 1;
1342   return 1;
1343 }
1344
1345 /* Thread-local accesses do require a frame.  */
1346 static CORE_ADDR
1347 needs_frame_tls_address (void *baton, CORE_ADDR offset)
1348 {
1349   struct needs_frame_baton *nf_baton = baton;
1350
1351   nf_baton->needs_frame = 1;
1352   return 1;
1353 }
1354
1355 /* Helper interface of per_cu_dwarf_call for dwarf2_loc_desc_needs_frame.  */
1356
1357 static void
1358 needs_frame_dwarf_call (struct dwarf_expr_context *ctx, size_t die_offset)
1359 {
1360   struct needs_frame_baton *nf_baton = ctx->baton;
1361
1362   per_cu_dwarf_call (ctx, die_offset, nf_baton->per_cu,
1363                      ctx->funcs->get_frame_pc, ctx->baton);
1364 }
1365
1366 /* Virtual method table for dwarf2_loc_desc_needs_frame below.  */
1367
1368 static const struct dwarf_expr_context_funcs needs_frame_ctx_funcs =
1369 {
1370   needs_frame_read_reg,
1371   needs_frame_read_mem,
1372   needs_frame_frame_base,
1373   needs_frame_frame_cfa,
1374   needs_frame_frame_cfa,        /* get_frame_pc */
1375   needs_frame_tls_address,
1376   needs_frame_dwarf_call,
1377   NULL                          /* get_base_type */
1378 };
1379
1380 /* Return non-zero iff the location expression at DATA (length SIZE)
1381    requires a frame to evaluate.  */
1382
1383 static int
1384 dwarf2_loc_desc_needs_frame (const gdb_byte *data, unsigned short size,
1385                              struct dwarf2_per_cu_data *per_cu)
1386 {
1387   struct needs_frame_baton baton;
1388   struct dwarf_expr_context *ctx;
1389   int in_reg;
1390   struct cleanup *old_chain;
1391   struct objfile *objfile = dwarf2_per_cu_objfile (per_cu);
1392
1393   baton.needs_frame = 0;
1394   baton.per_cu = per_cu;
1395
1396   ctx = new_dwarf_expr_context ();
1397   old_chain = make_cleanup_free_dwarf_expr_context (ctx);
1398   make_cleanup_value_free_to_mark (value_mark ());
1399
1400   ctx->gdbarch = get_objfile_arch (objfile);
1401   ctx->addr_size = dwarf2_per_cu_addr_size (per_cu);
1402   ctx->ref_addr_size = dwarf2_per_cu_ref_addr_size (per_cu);
1403   ctx->offset = dwarf2_per_cu_text_offset (per_cu);
1404   ctx->baton = &baton;
1405   ctx->funcs = &needs_frame_ctx_funcs;
1406
1407   dwarf_expr_eval (ctx, data, size);
1408
1409   in_reg = ctx->location == DWARF_VALUE_REGISTER;
1410
1411   if (ctx->num_pieces > 0)
1412     {
1413       int i;
1414
1415       /* If the location has several pieces, and any of them are in
1416          registers, then we will need a frame to fetch them from.  */
1417       for (i = 0; i < ctx->num_pieces; i++)
1418         if (ctx->pieces[i].location == DWARF_VALUE_REGISTER)
1419           in_reg = 1;
1420     }
1421
1422   do_cleanups (old_chain);
1423
1424   return baton.needs_frame || in_reg;
1425 }
1426
1427 /* A helper function that throws an unimplemented error mentioning a
1428    given DWARF operator.  */
1429
1430 static void
1431 unimplemented (unsigned int op)
1432 {
1433   const char *name = dwarf_stack_op_name (op);
1434
1435   if (name)
1436     error (_("DWARF operator %s cannot be translated to an agent expression"),
1437            name);
1438   else
1439     error (_("Unknown DWARF operator 0x%02x cannot be translated "
1440              "to an agent expression"),
1441            op);
1442 }
1443
1444 /* A helper function to convert a DWARF register to an arch register.
1445    ARCH is the architecture.
1446    DWARF_REG is the register.
1447    This will throw an exception if the DWARF register cannot be
1448    translated to an architecture register.  */
1449
1450 static int
1451 translate_register (struct gdbarch *arch, int dwarf_reg)
1452 {
1453   int reg = gdbarch_dwarf2_reg_to_regnum (arch, dwarf_reg);
1454   if (reg == -1)
1455     error (_("Unable to access DWARF register number %d"), dwarf_reg);
1456   return reg;
1457 }
1458
1459 /* A helper function that emits an access to memory.  ARCH is the
1460    target architecture.  EXPR is the expression which we are building.
1461    NBITS is the number of bits we want to read.  This emits the
1462    opcodes needed to read the memory and then extract the desired
1463    bits.  */
1464
1465 static void
1466 access_memory (struct gdbarch *arch, struct agent_expr *expr, ULONGEST nbits)
1467 {
1468   ULONGEST nbytes = (nbits + 7) / 8;
1469
1470   gdb_assert (nbits > 0 && nbits <= sizeof (LONGEST));
1471
1472   if (trace_kludge)
1473     ax_trace_quick (expr, nbytes);
1474
1475   if (nbits <= 8)
1476     ax_simple (expr, aop_ref8);
1477   else if (nbits <= 16)
1478     ax_simple (expr, aop_ref16);
1479   else if (nbits <= 32)
1480     ax_simple (expr, aop_ref32);
1481   else
1482     ax_simple (expr, aop_ref64);
1483
1484   /* If we read exactly the number of bytes we wanted, we're done.  */
1485   if (8 * nbytes == nbits)
1486     return;
1487
1488   if (gdbarch_bits_big_endian (arch))
1489     {
1490       /* On a bits-big-endian machine, we want the high-order
1491          NBITS.  */
1492       ax_const_l (expr, 8 * nbytes - nbits);
1493       ax_simple (expr, aop_rsh_unsigned);
1494     }
1495   else
1496     {
1497       /* On a bits-little-endian box, we want the low-order NBITS.  */
1498       ax_zero_ext (expr, nbits);
1499     }
1500 }
1501
1502 /* A helper function to return the frame's PC.  */
1503
1504 static CORE_ADDR
1505 get_ax_pc (void *baton)
1506 {
1507   struct agent_expr *expr = baton;
1508
1509   return expr->scope;
1510 }
1511
1512 /* Compile a DWARF location expression to an agent expression.
1513
1514    EXPR is the agent expression we are building.
1515    LOC is the agent value we modify.
1516    ARCH is the architecture.
1517    ADDR_SIZE is the size of addresses, in bytes.
1518    OP_PTR is the start of the location expression.
1519    OP_END is one past the last byte of the location expression.
1520
1521    This will throw an exception for various kinds of errors -- for
1522    example, if the expression cannot be compiled, or if the expression
1523    is invalid.  */
1524
1525 void
1526 dwarf2_compile_expr_to_ax (struct agent_expr *expr, struct axs_value *loc,
1527                            struct gdbarch *arch, unsigned int addr_size,
1528                            const gdb_byte *op_ptr, const gdb_byte *op_end,
1529                            struct dwarf2_per_cu_data *per_cu)
1530 {
1531   struct cleanup *cleanups;
1532   int i, *offsets;
1533   VEC(int) *dw_labels = NULL, *patches = NULL;
1534   const gdb_byte * const base = op_ptr;
1535   const gdb_byte *previous_piece = op_ptr;
1536   enum bfd_endian byte_order = gdbarch_byte_order (arch);
1537   ULONGEST bits_collected = 0;
1538   unsigned int addr_size_bits = 8 * addr_size;
1539   int bits_big_endian = gdbarch_bits_big_endian (arch);
1540
1541   offsets = xmalloc ((op_end - op_ptr) * sizeof (int));
1542   cleanups = make_cleanup (xfree, offsets);
1543
1544   for (i = 0; i < op_end - op_ptr; ++i)
1545     offsets[i] = -1;
1546
1547   make_cleanup (VEC_cleanup (int), &dw_labels);
1548   make_cleanup (VEC_cleanup (int), &patches);
1549
1550   /* By default we are making an address.  */
1551   loc->kind = axs_lvalue_memory;
1552
1553   while (op_ptr < op_end)
1554     {
1555       enum dwarf_location_atom op = *op_ptr;
1556       ULONGEST uoffset, reg;
1557       LONGEST offset;
1558       int i;
1559
1560       offsets[op_ptr - base] = expr->len;
1561       ++op_ptr;
1562
1563       /* Our basic approach to code generation is to map DWARF
1564          operations directly to AX operations.  However, there are
1565          some differences.
1566
1567          First, DWARF works on address-sized units, but AX always uses
1568          LONGEST.  For most operations we simply ignore this
1569          difference; instead we generate sign extensions as needed
1570          before division and comparison operations.  It would be nice
1571          to omit the sign extensions, but there is no way to determine
1572          the size of the target's LONGEST.  (This code uses the size
1573          of the host LONGEST in some cases -- that is a bug but it is
1574          difficult to fix.)
1575
1576          Second, some DWARF operations cannot be translated to AX.
1577          For these we simply fail.  See
1578          http://sourceware.org/bugzilla/show_bug.cgi?id=11662.  */
1579       switch (op)
1580         {
1581         case DW_OP_lit0:
1582         case DW_OP_lit1:
1583         case DW_OP_lit2:
1584         case DW_OP_lit3:
1585         case DW_OP_lit4:
1586         case DW_OP_lit5:
1587         case DW_OP_lit6:
1588         case DW_OP_lit7:
1589         case DW_OP_lit8:
1590         case DW_OP_lit9:
1591         case DW_OP_lit10:
1592         case DW_OP_lit11:
1593         case DW_OP_lit12:
1594         case DW_OP_lit13:
1595         case DW_OP_lit14:
1596         case DW_OP_lit15:
1597         case DW_OP_lit16:
1598         case DW_OP_lit17:
1599         case DW_OP_lit18:
1600         case DW_OP_lit19:
1601         case DW_OP_lit20:
1602         case DW_OP_lit21:
1603         case DW_OP_lit22:
1604         case DW_OP_lit23:
1605         case DW_OP_lit24:
1606         case DW_OP_lit25:
1607         case DW_OP_lit26:
1608         case DW_OP_lit27:
1609         case DW_OP_lit28:
1610         case DW_OP_lit29:
1611         case DW_OP_lit30:
1612         case DW_OP_lit31:
1613           ax_const_l (expr, op - DW_OP_lit0);
1614           break;
1615
1616         case DW_OP_addr:
1617           uoffset = extract_unsigned_integer (op_ptr, addr_size, byte_order);
1618           op_ptr += addr_size;
1619           /* Some versions of GCC emit DW_OP_addr before
1620              DW_OP_GNU_push_tls_address.  In this case the value is an
1621              index, not an address.  We don't support things like
1622              branching between the address and the TLS op.  */
1623           if (op_ptr >= op_end || *op_ptr != DW_OP_GNU_push_tls_address)
1624             uoffset += dwarf2_per_cu_text_offset (per_cu);
1625           ax_const_l (expr, uoffset);
1626           break;
1627
1628         case DW_OP_const1u:
1629           ax_const_l (expr, extract_unsigned_integer (op_ptr, 1, byte_order));
1630           op_ptr += 1;
1631           break;
1632         case DW_OP_const1s:
1633           ax_const_l (expr, extract_signed_integer (op_ptr, 1, byte_order));
1634           op_ptr += 1;
1635           break;
1636         case DW_OP_const2u:
1637           ax_const_l (expr, extract_unsigned_integer (op_ptr, 2, byte_order));
1638           op_ptr += 2;
1639           break;
1640         case DW_OP_const2s:
1641           ax_const_l (expr, extract_signed_integer (op_ptr, 2, byte_order));
1642           op_ptr += 2;
1643           break;
1644         case DW_OP_const4u:
1645           ax_const_l (expr, extract_unsigned_integer (op_ptr, 4, byte_order));
1646           op_ptr += 4;
1647           break;
1648         case DW_OP_const4s:
1649           ax_const_l (expr, extract_signed_integer (op_ptr, 4, byte_order));
1650           op_ptr += 4;
1651           break;
1652         case DW_OP_const8u:
1653           ax_const_l (expr, extract_unsigned_integer (op_ptr, 8, byte_order));
1654           op_ptr += 8;
1655           break;
1656         case DW_OP_const8s:
1657           ax_const_l (expr, extract_signed_integer (op_ptr, 8, byte_order));
1658           op_ptr += 8;
1659           break;
1660         case DW_OP_constu:
1661           op_ptr = read_uleb128 (op_ptr, op_end, &uoffset);
1662           ax_const_l (expr, uoffset);
1663           break;
1664         case DW_OP_consts:
1665           op_ptr = read_sleb128 (op_ptr, op_end, &offset);
1666           ax_const_l (expr, offset);
1667           break;
1668
1669         case DW_OP_reg0:
1670         case DW_OP_reg1:
1671         case DW_OP_reg2:
1672         case DW_OP_reg3:
1673         case DW_OP_reg4:
1674         case DW_OP_reg5:
1675         case DW_OP_reg6:
1676         case DW_OP_reg7:
1677         case DW_OP_reg8:
1678         case DW_OP_reg9:
1679         case DW_OP_reg10:
1680         case DW_OP_reg11:
1681         case DW_OP_reg12:
1682         case DW_OP_reg13:
1683         case DW_OP_reg14:
1684         case DW_OP_reg15:
1685         case DW_OP_reg16:
1686         case DW_OP_reg17:
1687         case DW_OP_reg18:
1688         case DW_OP_reg19:
1689         case DW_OP_reg20:
1690         case DW_OP_reg21:
1691         case DW_OP_reg22:
1692         case DW_OP_reg23:
1693         case DW_OP_reg24:
1694         case DW_OP_reg25:
1695         case DW_OP_reg26:
1696         case DW_OP_reg27:
1697         case DW_OP_reg28:
1698         case DW_OP_reg29:
1699         case DW_OP_reg30:
1700         case DW_OP_reg31:
1701           dwarf_expr_require_composition (op_ptr, op_end, "DW_OP_regx");
1702           loc->u.reg = translate_register (arch, op - DW_OP_reg0);
1703           loc->kind = axs_lvalue_register;
1704           break;
1705
1706         case DW_OP_regx:
1707           op_ptr = read_uleb128 (op_ptr, op_end, &reg);
1708           dwarf_expr_require_composition (op_ptr, op_end, "DW_OP_regx");
1709           loc->u.reg = translate_register (arch, reg);
1710           loc->kind = axs_lvalue_register;
1711           break;
1712
1713         case DW_OP_implicit_value:
1714           {
1715             ULONGEST len;
1716
1717             op_ptr = read_uleb128 (op_ptr, op_end, &len);
1718             if (op_ptr + len > op_end)
1719               error (_("DW_OP_implicit_value: too few bytes available."));
1720             if (len > sizeof (ULONGEST))
1721               error (_("Cannot translate DW_OP_implicit_value of %d bytes"),
1722                      (int) len);
1723
1724             ax_const_l (expr, extract_unsigned_integer (op_ptr, len,
1725                                                         byte_order));
1726             op_ptr += len;
1727             dwarf_expr_require_composition (op_ptr, op_end,
1728                                             "DW_OP_implicit_value");
1729
1730             loc->kind = axs_rvalue;
1731           }
1732           break;
1733
1734         case DW_OP_stack_value:
1735           dwarf_expr_require_composition (op_ptr, op_end, "DW_OP_stack_value");
1736           loc->kind = axs_rvalue;
1737           break;
1738
1739         case DW_OP_breg0:
1740         case DW_OP_breg1:
1741         case DW_OP_breg2:
1742         case DW_OP_breg3:
1743         case DW_OP_breg4:
1744         case DW_OP_breg5:
1745         case DW_OP_breg6:
1746         case DW_OP_breg7:
1747         case DW_OP_breg8:
1748         case DW_OP_breg9:
1749         case DW_OP_breg10:
1750         case DW_OP_breg11:
1751         case DW_OP_breg12:
1752         case DW_OP_breg13:
1753         case DW_OP_breg14:
1754         case DW_OP_breg15:
1755         case DW_OP_breg16:
1756         case DW_OP_breg17:
1757         case DW_OP_breg18:
1758         case DW_OP_breg19:
1759         case DW_OP_breg20:
1760         case DW_OP_breg21:
1761         case DW_OP_breg22:
1762         case DW_OP_breg23:
1763         case DW_OP_breg24:
1764         case DW_OP_breg25:
1765         case DW_OP_breg26:
1766         case DW_OP_breg27:
1767         case DW_OP_breg28:
1768         case DW_OP_breg29:
1769         case DW_OP_breg30:
1770         case DW_OP_breg31:
1771           op_ptr = read_sleb128 (op_ptr, op_end, &offset);
1772           i = translate_register (arch, op - DW_OP_breg0);
1773           ax_reg (expr, i);
1774           if (offset != 0)
1775             {
1776               ax_const_l (expr, offset);
1777               ax_simple (expr, aop_add);
1778             }
1779           break;
1780         case DW_OP_bregx:
1781           {
1782             op_ptr = read_uleb128 (op_ptr, op_end, &reg);
1783             op_ptr = read_sleb128 (op_ptr, op_end, &offset);
1784             i = translate_register (arch, reg);
1785             ax_reg (expr, i);
1786             if (offset != 0)
1787               {
1788                 ax_const_l (expr, offset);
1789                 ax_simple (expr, aop_add);
1790               }
1791           }
1792           break;
1793         case DW_OP_fbreg:
1794           {
1795             const gdb_byte *datastart;
1796             size_t datalen;
1797             unsigned int before_stack_len;
1798             struct block *b;
1799             struct symbol *framefunc;
1800             LONGEST base_offset = 0;
1801
1802             b = block_for_pc (expr->scope);
1803
1804             if (!b)
1805               error (_("No block found for address"));
1806
1807             framefunc = block_linkage_function (b);
1808
1809             if (!framefunc)
1810               error (_("No function found for block"));
1811
1812             dwarf_expr_frame_base_1 (framefunc, expr->scope,
1813                                      &datastart, &datalen);
1814
1815             op_ptr = read_sleb128 (op_ptr, op_end, &offset);
1816             dwarf2_compile_expr_to_ax (expr, loc, arch, addr_size, datastart,
1817                                        datastart + datalen, per_cu);
1818
1819             if (offset != 0)
1820               {
1821                 ax_const_l (expr, offset);
1822                 ax_simple (expr, aop_add);
1823               }
1824
1825             loc->kind = axs_lvalue_memory;
1826           }
1827           break;
1828
1829         case DW_OP_dup:
1830           ax_simple (expr, aop_dup);
1831           break;
1832
1833         case DW_OP_drop:
1834           ax_simple (expr, aop_pop);
1835           break;
1836
1837         case DW_OP_pick:
1838           offset = *op_ptr++;
1839           ax_pick (expr, offset);
1840           break;
1841
1842         case DW_OP_swap:
1843           ax_simple (expr, aop_swap);
1844           break;
1845
1846         case DW_OP_over:
1847           ax_pick (expr, 1);
1848           break;
1849
1850         case DW_OP_rot:
1851           ax_simple (expr, aop_rot);
1852           break;
1853
1854         case DW_OP_deref:
1855         case DW_OP_deref_size:
1856           {
1857             int size;
1858
1859             if (op == DW_OP_deref_size)
1860               size = *op_ptr++;
1861             else
1862               size = addr_size;
1863
1864             switch (size)
1865               {
1866               case 8:
1867                 ax_simple (expr, aop_ref8);
1868                 break;
1869               case 16:
1870                 ax_simple (expr, aop_ref16);
1871                 break;
1872               case 32:
1873                 ax_simple (expr, aop_ref32);
1874                 break;
1875               case 64:
1876                 ax_simple (expr, aop_ref64);
1877                 break;
1878               default:
1879                 /* Note that dwarf_stack_op_name will never return
1880                    NULL here.  */
1881                 error (_("Unsupported size %d in %s"),
1882                        size, dwarf_stack_op_name (op));
1883               }
1884           }
1885           break;
1886
1887         case DW_OP_abs:
1888           /* Sign extend the operand.  */
1889           ax_ext (expr, addr_size_bits);
1890           ax_simple (expr, aop_dup);
1891           ax_const_l (expr, 0);
1892           ax_simple (expr, aop_less_signed);
1893           ax_simple (expr, aop_log_not);
1894           i = ax_goto (expr, aop_if_goto);
1895           /* We have to emit 0 - X.  */
1896           ax_const_l (expr, 0);
1897           ax_simple (expr, aop_swap);
1898           ax_simple (expr, aop_sub);
1899           ax_label (expr, i, expr->len);
1900           break;
1901
1902         case DW_OP_neg:
1903           /* No need to sign extend here.  */
1904           ax_const_l (expr, 0);
1905           ax_simple (expr, aop_swap);
1906           ax_simple (expr, aop_sub);
1907           break;
1908
1909         case DW_OP_not:
1910           /* Sign extend the operand.  */
1911           ax_ext (expr, addr_size_bits);
1912           ax_simple (expr, aop_bit_not);
1913           break;
1914
1915         case DW_OP_plus_uconst:
1916           op_ptr = read_uleb128 (op_ptr, op_end, &reg);
1917           /* It would be really weird to emit `DW_OP_plus_uconst 0',
1918              but we micro-optimize anyhow.  */
1919           if (reg != 0)
1920             {
1921               ax_const_l (expr, reg);
1922               ax_simple (expr, aop_add);
1923             }
1924           break;
1925
1926         case DW_OP_and:
1927           ax_simple (expr, aop_bit_and);
1928           break;
1929
1930         case DW_OP_div:
1931           /* Sign extend the operands.  */
1932           ax_ext (expr, addr_size_bits);
1933           ax_simple (expr, aop_swap);
1934           ax_ext (expr, addr_size_bits);
1935           ax_simple (expr, aop_swap);
1936           ax_simple (expr, aop_div_signed);
1937           break;
1938
1939         case DW_OP_minus:
1940           ax_simple (expr, aop_sub);
1941           break;
1942
1943         case DW_OP_mod:
1944           ax_simple (expr, aop_rem_unsigned);
1945           break;
1946
1947         case DW_OP_mul:
1948           ax_simple (expr, aop_mul);
1949           break;
1950
1951         case DW_OP_or:
1952           ax_simple (expr, aop_bit_or);
1953           break;
1954
1955         case DW_OP_plus:
1956           ax_simple (expr, aop_add);
1957           break;
1958
1959         case DW_OP_shl:
1960           ax_simple (expr, aop_lsh);
1961           break;
1962
1963         case DW_OP_shr:
1964           ax_simple (expr, aop_rsh_unsigned);
1965           break;
1966
1967         case DW_OP_shra:
1968           ax_simple (expr, aop_rsh_signed);
1969           break;
1970
1971         case DW_OP_xor:
1972           ax_simple (expr, aop_bit_xor);
1973           break;
1974
1975         case DW_OP_le:
1976           /* Sign extend the operands.  */
1977           ax_ext (expr, addr_size_bits);
1978           ax_simple (expr, aop_swap);
1979           ax_ext (expr, addr_size_bits);
1980           /* Note no swap here: A <= B is !(B < A).  */
1981           ax_simple (expr, aop_less_signed);
1982           ax_simple (expr, aop_log_not);
1983           break;
1984
1985         case DW_OP_ge:
1986           /* Sign extend the operands.  */
1987           ax_ext (expr, addr_size_bits);
1988           ax_simple (expr, aop_swap);
1989           ax_ext (expr, addr_size_bits);
1990           ax_simple (expr, aop_swap);
1991           /* A >= B is !(A < B).  */
1992           ax_simple (expr, aop_less_signed);
1993           ax_simple (expr, aop_log_not);
1994           break;
1995
1996         case DW_OP_eq:
1997           /* Sign extend the operands.  */
1998           ax_ext (expr, addr_size_bits);
1999           ax_simple (expr, aop_swap);
2000           ax_ext (expr, addr_size_bits);
2001           /* No need for a second swap here.  */
2002           ax_simple (expr, aop_equal);
2003           break;
2004
2005         case DW_OP_lt:
2006           /* Sign extend the operands.  */
2007           ax_ext (expr, addr_size_bits);
2008           ax_simple (expr, aop_swap);
2009           ax_ext (expr, addr_size_bits);
2010           ax_simple (expr, aop_swap);
2011           ax_simple (expr, aop_less_signed);
2012           break;
2013
2014         case DW_OP_gt:
2015           /* Sign extend the operands.  */
2016           ax_ext (expr, addr_size_bits);
2017           ax_simple (expr, aop_swap);
2018           ax_ext (expr, addr_size_bits);
2019           /* Note no swap here: A > B is B < A.  */
2020           ax_simple (expr, aop_less_signed);
2021           break;
2022
2023         case DW_OP_ne:
2024           /* Sign extend the operands.  */
2025           ax_ext (expr, addr_size_bits);
2026           ax_simple (expr, aop_swap);
2027           ax_ext (expr, addr_size_bits);
2028           /* No need for a swap here.  */
2029           ax_simple (expr, aop_equal);
2030           ax_simple (expr, aop_log_not);
2031           break;
2032
2033         case DW_OP_call_frame_cfa:
2034           dwarf2_compile_cfa_to_ax (expr, loc, arch, expr->scope, per_cu);
2035           loc->kind = axs_lvalue_memory;
2036           break;
2037
2038         case DW_OP_GNU_push_tls_address:
2039           unimplemented (op);
2040           break;
2041
2042         case DW_OP_skip:
2043           offset = extract_signed_integer (op_ptr, 2, byte_order);
2044           op_ptr += 2;
2045           i = ax_goto (expr, aop_goto);
2046           VEC_safe_push (int, dw_labels, op_ptr + offset - base);
2047           VEC_safe_push (int, patches, i);
2048           break;
2049
2050         case DW_OP_bra:
2051           offset = extract_signed_integer (op_ptr, 2, byte_order);
2052           op_ptr += 2;
2053           /* Zero extend the operand.  */
2054           ax_zero_ext (expr, addr_size_bits);
2055           i = ax_goto (expr, aop_if_goto);
2056           VEC_safe_push (int, dw_labels, op_ptr + offset - base);
2057           VEC_safe_push (int, patches, i);
2058           break;
2059
2060         case DW_OP_nop:
2061           break;
2062
2063         case DW_OP_piece:
2064         case DW_OP_bit_piece:
2065           {
2066             ULONGEST size, offset;
2067
2068             if (op_ptr - 1 == previous_piece)
2069               error (_("Cannot translate empty pieces to agent expressions"));
2070             previous_piece = op_ptr - 1;
2071
2072             op_ptr = read_uleb128 (op_ptr, op_end, &size);
2073             if (op == DW_OP_piece)
2074               {
2075                 size *= 8;
2076                 offset = 0;
2077               }
2078             else
2079               op_ptr = read_uleb128 (op_ptr, op_end, &offset);
2080
2081             if (bits_collected + size > 8 * sizeof (LONGEST))
2082               error (_("Expression pieces exceed word size"));
2083
2084             /* Access the bits.  */
2085             switch (loc->kind)
2086               {
2087               case axs_lvalue_register:
2088                 ax_reg (expr, loc->u.reg);
2089                 break;
2090
2091               case axs_lvalue_memory:
2092                 /* Offset the pointer, if needed.  */
2093                 if (offset > 8)
2094                   {
2095                     ax_const_l (expr, offset / 8);
2096                     ax_simple (expr, aop_add);
2097                     offset %= 8;
2098                   }
2099                 access_memory (arch, expr, size);
2100                 break;
2101               }
2102
2103             /* For a bits-big-endian target, shift up what we already
2104                have.  For a bits-little-endian target, shift up the
2105                new data.  Note that there is a potential bug here if
2106                the DWARF expression leaves multiple values on the
2107                stack.  */
2108             if (bits_collected > 0)
2109               {
2110                 if (bits_big_endian)
2111                   {
2112                     ax_simple (expr, aop_swap);
2113                     ax_const_l (expr, size);
2114                     ax_simple (expr, aop_lsh);
2115                     /* We don't need a second swap here, because
2116                        aop_bit_or is symmetric.  */
2117                   }
2118                 else
2119                   {
2120                     ax_const_l (expr, size);
2121                     ax_simple (expr, aop_lsh);
2122                   }
2123                 ax_simple (expr, aop_bit_or);
2124               }
2125
2126             bits_collected += size;
2127             loc->kind = axs_rvalue;
2128           }
2129           break;
2130
2131         case DW_OP_GNU_uninit:
2132           unimplemented (op);
2133
2134         case DW_OP_call2:
2135         case DW_OP_call4:
2136           {
2137             struct dwarf2_locexpr_baton block;
2138             int size = (op == DW_OP_call2 ? 2 : 4);
2139
2140             uoffset = extract_unsigned_integer (op_ptr, size, byte_order);
2141             op_ptr += size;
2142
2143             block = dwarf2_fetch_die_location_block (uoffset, per_cu,
2144                                                      get_ax_pc, expr);
2145
2146             /* DW_OP_call_ref is currently not supported.  */
2147             gdb_assert (block.per_cu == per_cu);
2148
2149             dwarf2_compile_expr_to_ax (expr, loc, arch, addr_size,
2150                                        block.data, block.data + block.size,
2151                                        per_cu);
2152           }
2153           break;
2154
2155         case DW_OP_call_ref:
2156           unimplemented (op);
2157
2158         default:
2159           unimplemented (op);
2160         }
2161     }
2162
2163   /* Patch all the branches we emitted.  */
2164   for (i = 0; i < VEC_length (int, patches); ++i)
2165     {
2166       int targ = offsets[VEC_index (int, dw_labels, i)];
2167       if (targ == -1)
2168         internal_error (__FILE__, __LINE__, _("invalid label"));
2169       ax_label (expr, VEC_index (int, patches, i), targ);
2170     }
2171
2172   do_cleanups (cleanups);
2173 }
2174
2175 \f
2176 /* Return the value of SYMBOL in FRAME using the DWARF-2 expression
2177    evaluator to calculate the location.  */
2178 static struct value *
2179 locexpr_read_variable (struct symbol *symbol, struct frame_info *frame)
2180 {
2181   struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
2182   struct value *val;
2183
2184   val = dwarf2_evaluate_loc_desc (SYMBOL_TYPE (symbol), frame, dlbaton->data,
2185                                   dlbaton->size, dlbaton->per_cu);
2186
2187   return val;
2188 }
2189
2190 /* Return non-zero iff we need a frame to evaluate SYMBOL.  */
2191 static int
2192 locexpr_read_needs_frame (struct symbol *symbol)
2193 {
2194   struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
2195
2196   return dwarf2_loc_desc_needs_frame (dlbaton->data, dlbaton->size,
2197                                       dlbaton->per_cu);
2198 }
2199
2200 /* Return true if DATA points to the end of a piece.  END is one past
2201    the last byte in the expression.  */
2202
2203 static int
2204 piece_end_p (const gdb_byte *data, const gdb_byte *end)
2205 {
2206   return data == end || data[0] == DW_OP_piece || data[0] == DW_OP_bit_piece;
2207 }
2208
2209 /* Helper for locexpr_describe_location_piece that finds the name of a
2210    DWARF register.  */
2211
2212 static const char *
2213 locexpr_regname (struct gdbarch *gdbarch, int dwarf_regnum)
2214 {
2215   int regnum;
2216
2217   regnum = gdbarch_dwarf2_reg_to_regnum (gdbarch, dwarf_regnum);
2218   return gdbarch_register_name (gdbarch, regnum);
2219 }
2220
2221 /* Nicely describe a single piece of a location, returning an updated
2222    position in the bytecode sequence.  This function cannot recognize
2223    all locations; if a location is not recognized, it simply returns
2224    DATA.  */
2225
2226 static const gdb_byte *
2227 locexpr_describe_location_piece (struct symbol *symbol, struct ui_file *stream,
2228                                  CORE_ADDR addr, struct objfile *objfile,
2229                                  const gdb_byte *data, const gdb_byte *end,
2230                                  unsigned int addr_size)
2231 {
2232   struct gdbarch *gdbarch = get_objfile_arch (objfile);
2233
2234   if (data[0] >= DW_OP_reg0 && data[0] <= DW_OP_reg31)
2235     {
2236       fprintf_filtered (stream, _("a variable in $%s"),
2237                         locexpr_regname (gdbarch, data[0] - DW_OP_reg0));
2238       data += 1;
2239     }
2240   else if (data[0] == DW_OP_regx)
2241     {
2242       ULONGEST reg;
2243
2244       data = read_uleb128 (data + 1, end, &reg);
2245       fprintf_filtered (stream, _("a variable in $%s"),
2246                         locexpr_regname (gdbarch, reg));
2247     }
2248   else if (data[0] == DW_OP_fbreg)
2249     {
2250       struct block *b;
2251       struct symbol *framefunc;
2252       int frame_reg = 0;
2253       LONGEST frame_offset;
2254       const gdb_byte *base_data, *new_data, *save_data = data;
2255       size_t base_size;
2256       LONGEST base_offset = 0;
2257
2258       new_data = read_sleb128 (data + 1, end, &frame_offset);
2259       if (!piece_end_p (new_data, end))
2260         return data;
2261       data = new_data;
2262
2263       b = block_for_pc (addr);
2264
2265       if (!b)
2266         error (_("No block found for address for symbol \"%s\"."),
2267                SYMBOL_PRINT_NAME (symbol));
2268
2269       framefunc = block_linkage_function (b);
2270
2271       if (!framefunc)
2272         error (_("No function found for block for symbol \"%s\"."),
2273                SYMBOL_PRINT_NAME (symbol));
2274
2275       dwarf_expr_frame_base_1 (framefunc, addr, &base_data, &base_size);
2276
2277       if (base_data[0] >= DW_OP_breg0 && base_data[0] <= DW_OP_breg31)
2278         {
2279           const gdb_byte *buf_end;
2280
2281           frame_reg = base_data[0] - DW_OP_breg0;
2282           buf_end = read_sleb128 (base_data + 1,
2283                                   base_data + base_size, &base_offset);
2284           if (buf_end != base_data + base_size)
2285             error (_("Unexpected opcode after "
2286                      "DW_OP_breg%u for symbol \"%s\"."),
2287                    frame_reg, SYMBOL_PRINT_NAME (symbol));
2288         }
2289       else if (base_data[0] >= DW_OP_reg0 && base_data[0] <= DW_OP_reg31)
2290         {
2291           /* The frame base is just the register, with no offset.  */
2292           frame_reg = base_data[0] - DW_OP_reg0;
2293           base_offset = 0;
2294         }
2295       else
2296         {
2297           /* We don't know what to do with the frame base expression,
2298              so we can't trace this variable; give up.  */
2299           return save_data;
2300         }
2301
2302       fprintf_filtered (stream,
2303                         _("a variable at frame base reg $%s offset %s+%s"),
2304                         locexpr_regname (gdbarch, frame_reg),
2305                         plongest (base_offset), plongest (frame_offset));
2306     }
2307   else if (data[0] >= DW_OP_breg0 && data[0] <= DW_OP_breg31
2308            && piece_end_p (data, end))
2309     {
2310       LONGEST offset;
2311
2312       data = read_sleb128 (data + 1, end, &offset);
2313
2314       fprintf_filtered (stream,
2315                         _("a variable at offset %s from base reg $%s"),
2316                         plongest (offset),
2317                         locexpr_regname (gdbarch, data[0] - DW_OP_breg0));
2318     }
2319
2320   /* The location expression for a TLS variable looks like this (on a
2321      64-bit LE machine):
2322
2323      DW_AT_location    : 10 byte block: 3 4 0 0 0 0 0 0 0 e0
2324                         (DW_OP_addr: 4; DW_OP_GNU_push_tls_address)
2325
2326      0x3 is the encoding for DW_OP_addr, which has an operand as long
2327      as the size of an address on the target machine (here is 8
2328      bytes).  Note that more recent version of GCC emit DW_OP_const4u
2329      or DW_OP_const8u, depending on address size, rather than
2330      DW_OP_addr.  0xe0 is the encoding for DW_OP_GNU_push_tls_address.
2331      The operand represents the offset at which the variable is within
2332      the thread local storage.  */
2333
2334   else if (data + 1 + addr_size < end
2335            && (data[0] == DW_OP_addr
2336                || (addr_size == 4 && data[0] == DW_OP_const4u)
2337                || (addr_size == 8 && data[0] == DW_OP_const8u))
2338            && data[1 + addr_size] == DW_OP_GNU_push_tls_address
2339            && piece_end_p (data + 2 + addr_size, end))
2340     {
2341       ULONGEST offset;
2342       offset = extract_unsigned_integer (data + 1, addr_size,
2343                                          gdbarch_byte_order (gdbarch));
2344
2345       fprintf_filtered (stream,
2346                         _("a thread-local variable at offset 0x%s "
2347                           "in the thread-local storage for `%s'"),
2348                         phex_nz (offset, addr_size), objfile->name);
2349
2350       data += 1 + addr_size + 1;
2351     }
2352   else if (data[0] >= DW_OP_lit0
2353            && data[0] <= DW_OP_lit31
2354            && data + 1 < end
2355            && data[1] == DW_OP_stack_value)
2356     {
2357       fprintf_filtered (stream, _("the constant %d"), data[0] - DW_OP_lit0);
2358       data += 2;
2359     }
2360
2361   return data;
2362 }
2363
2364 /* Disassemble an expression, stopping at the end of a piece or at the
2365    end of the expression.  Returns a pointer to the next unread byte
2366    in the input expression.  If ALL is nonzero, then this function
2367    will keep going until it reaches the end of the expression.  */
2368
2369 static const gdb_byte *
2370 disassemble_dwarf_expression (struct ui_file *stream,
2371                               struct gdbarch *arch, unsigned int addr_size,
2372                               int offset_size,
2373                               const gdb_byte *data, const gdb_byte *end,
2374                               int all,
2375                               struct dwarf2_per_cu_data *per_cu)
2376 {
2377   const gdb_byte *start = data;
2378
2379   fprintf_filtered (stream, _("a complex DWARF expression:\n"));
2380
2381   while (data < end
2382          && (all
2383              || (data[0] != DW_OP_piece && data[0] != DW_OP_bit_piece)))
2384     {
2385       enum dwarf_location_atom op = *data++;
2386       ULONGEST ul;
2387       LONGEST l;
2388       const char *name;
2389
2390       name = dwarf_stack_op_name (op);
2391
2392       if (!name)
2393         error (_("Unrecognized DWARF opcode 0x%02x at %ld"),
2394                op, (long) (data - 1 - start));
2395       fprintf_filtered (stream, "  % 4ld: %s", (long) (data - 1 - start), name);
2396
2397       switch (op)
2398         {
2399         case DW_OP_addr:
2400           ul = extract_unsigned_integer (data, addr_size,
2401                                          gdbarch_byte_order (arch));
2402           data += addr_size;
2403           fprintf_filtered (stream, " 0x%s", phex_nz (ul, addr_size));
2404           break;
2405
2406         case DW_OP_const1u:
2407           ul = extract_unsigned_integer (data, 1, gdbarch_byte_order (arch));
2408           data += 1;
2409           fprintf_filtered (stream, " %s", pulongest (ul));
2410           break;
2411         case DW_OP_const1s:
2412           l = extract_signed_integer (data, 1, gdbarch_byte_order (arch));
2413           data += 1;
2414           fprintf_filtered (stream, " %s", plongest (l));
2415           break;
2416         case DW_OP_const2u:
2417           ul = extract_unsigned_integer (data, 2, gdbarch_byte_order (arch));
2418           data += 2;
2419           fprintf_filtered (stream, " %s", pulongest (ul));
2420           break;
2421         case DW_OP_const2s:
2422           l = extract_signed_integer (data, 2, gdbarch_byte_order (arch));
2423           data += 2;
2424           fprintf_filtered (stream, " %s", plongest (l));
2425           break;
2426         case DW_OP_const4u:
2427           ul = extract_unsigned_integer (data, 4, gdbarch_byte_order (arch));
2428           data += 4;
2429           fprintf_filtered (stream, " %s", pulongest (ul));
2430           break;
2431         case DW_OP_const4s:
2432           l = extract_signed_integer (data, 4, gdbarch_byte_order (arch));
2433           data += 4;
2434           fprintf_filtered (stream, " %s", plongest (l));
2435           break;
2436         case DW_OP_const8u:
2437           ul = extract_unsigned_integer (data, 8, gdbarch_byte_order (arch));
2438           data += 8;
2439           fprintf_filtered (stream, " %s", pulongest (ul));
2440           break;
2441         case DW_OP_const8s:
2442           l = extract_signed_integer (data, 8, gdbarch_byte_order (arch));
2443           data += 8;
2444           fprintf_filtered (stream, " %s", plongest (l));
2445           break;
2446         case DW_OP_constu:
2447           data = read_uleb128 (data, end, &ul);
2448           fprintf_filtered (stream, " %s", pulongest (ul));
2449           break;
2450         case DW_OP_consts:
2451           data = read_sleb128 (data, end, &l);
2452           fprintf_filtered (stream, " %s", plongest (l));
2453           break;
2454
2455         case DW_OP_reg0:
2456         case DW_OP_reg1:
2457         case DW_OP_reg2:
2458         case DW_OP_reg3:
2459         case DW_OP_reg4:
2460         case DW_OP_reg5:
2461         case DW_OP_reg6:
2462         case DW_OP_reg7:
2463         case DW_OP_reg8:
2464         case DW_OP_reg9:
2465         case DW_OP_reg10:
2466         case DW_OP_reg11:
2467         case DW_OP_reg12:
2468         case DW_OP_reg13:
2469         case DW_OP_reg14:
2470         case DW_OP_reg15:
2471         case DW_OP_reg16:
2472         case DW_OP_reg17:
2473         case DW_OP_reg18:
2474         case DW_OP_reg19:
2475         case DW_OP_reg20:
2476         case DW_OP_reg21:
2477         case DW_OP_reg22:
2478         case DW_OP_reg23:
2479         case DW_OP_reg24:
2480         case DW_OP_reg25:
2481         case DW_OP_reg26:
2482         case DW_OP_reg27:
2483         case DW_OP_reg28:
2484         case DW_OP_reg29:
2485         case DW_OP_reg30:
2486         case DW_OP_reg31:
2487           fprintf_filtered (stream, " [$%s]",
2488                             locexpr_regname (arch, op - DW_OP_reg0));
2489           break;
2490
2491         case DW_OP_regx:
2492           data = read_uleb128 (data, end, &ul);
2493           fprintf_filtered (stream, " %s [$%s]", pulongest (ul),
2494                             locexpr_regname (arch, (int) ul));
2495           break;
2496
2497         case DW_OP_implicit_value:
2498           data = read_uleb128 (data, end, &ul);
2499           data += ul;
2500           fprintf_filtered (stream, " %s", pulongest (ul));
2501           break;
2502
2503         case DW_OP_breg0:
2504         case DW_OP_breg1:
2505         case DW_OP_breg2:
2506         case DW_OP_breg3:
2507         case DW_OP_breg4:
2508         case DW_OP_breg5:
2509         case DW_OP_breg6:
2510         case DW_OP_breg7:
2511         case DW_OP_breg8:
2512         case DW_OP_breg9:
2513         case DW_OP_breg10:
2514         case DW_OP_breg11:
2515         case DW_OP_breg12:
2516         case DW_OP_breg13:
2517         case DW_OP_breg14:
2518         case DW_OP_breg15:
2519         case DW_OP_breg16:
2520         case DW_OP_breg17:
2521         case DW_OP_breg18:
2522         case DW_OP_breg19:
2523         case DW_OP_breg20:
2524         case DW_OP_breg21:
2525         case DW_OP_breg22:
2526         case DW_OP_breg23:
2527         case DW_OP_breg24:
2528         case DW_OP_breg25:
2529         case DW_OP_breg26:
2530         case DW_OP_breg27:
2531         case DW_OP_breg28:
2532         case DW_OP_breg29:
2533         case DW_OP_breg30:
2534         case DW_OP_breg31:
2535           data = read_sleb128 (data, end, &l);
2536           fprintf_filtered (stream, " %s [$%s]", plongest (l),
2537                             locexpr_regname (arch, op - DW_OP_breg0));
2538           break;
2539
2540         case DW_OP_bregx:
2541           data = read_uleb128 (data, end, &ul);
2542           data = read_sleb128 (data, end, &l);
2543           fprintf_filtered (stream, " register %s [$%s] offset %s",
2544                             pulongest (ul),
2545                             locexpr_regname (arch, (int) ul),
2546                             plongest (l));
2547           break;
2548
2549         case DW_OP_fbreg:
2550           data = read_sleb128 (data, end, &l);
2551           fprintf_filtered (stream, " %s", plongest (l));
2552           break;
2553
2554         case DW_OP_xderef_size:
2555         case DW_OP_deref_size:
2556         case DW_OP_pick:
2557           fprintf_filtered (stream, " %d", *data);
2558           ++data;
2559           break;
2560
2561         case DW_OP_plus_uconst:
2562           data = read_uleb128 (data, end, &ul);
2563           fprintf_filtered (stream, " %s", pulongest (ul));
2564           break;
2565
2566         case DW_OP_skip:
2567           l = extract_signed_integer (data, 2, gdbarch_byte_order (arch));
2568           data += 2;
2569           fprintf_filtered (stream, " to %ld",
2570                             (long) (data + l - start));
2571           break;
2572
2573         case DW_OP_bra:
2574           l = extract_signed_integer (data, 2, gdbarch_byte_order (arch));
2575           data += 2;
2576           fprintf_filtered (stream, " %ld",
2577                             (long) (data + l - start));
2578           break;
2579
2580         case DW_OP_call2:
2581           ul = extract_unsigned_integer (data, 2, gdbarch_byte_order (arch));
2582           data += 2;
2583           fprintf_filtered (stream, " offset %s", phex_nz (ul, 2));
2584           break;
2585
2586         case DW_OP_call4:
2587           ul = extract_unsigned_integer (data, 4, gdbarch_byte_order (arch));
2588           data += 4;
2589           fprintf_filtered (stream, " offset %s", phex_nz (ul, 4));
2590           break;
2591
2592         case DW_OP_call_ref:
2593           ul = extract_unsigned_integer (data, offset_size,
2594                                          gdbarch_byte_order (arch));
2595           data += offset_size;
2596           fprintf_filtered (stream, " offset %s", phex_nz (ul, offset_size));
2597           break;
2598
2599         case DW_OP_piece:
2600           data = read_uleb128 (data, end, &ul);
2601           fprintf_filtered (stream, " %s (bytes)", pulongest (ul));
2602           break;
2603
2604         case DW_OP_bit_piece:
2605           {
2606             ULONGEST offset;
2607
2608             data = read_uleb128 (data, end, &ul);
2609             data = read_uleb128 (data, end, &offset);
2610             fprintf_filtered (stream, " size %s offset %s (bits)",
2611                               pulongest (ul), pulongest (offset));
2612           }
2613           break;
2614
2615         case DW_OP_GNU_implicit_pointer:
2616           {
2617             ul = extract_unsigned_integer (data, offset_size,
2618                                            gdbarch_byte_order (arch));
2619             data += offset_size;
2620
2621             data = read_sleb128 (data, end, &l);
2622
2623             fprintf_filtered (stream, " DIE %s offset %s",
2624                               phex_nz (ul, offset_size),
2625                               plongest (l));
2626           }
2627           break;
2628
2629         case DW_OP_GNU_deref_type:
2630           {
2631             int addr_size = *data++;
2632             ULONGEST offset;
2633             struct type *type;
2634
2635             data = read_uleb128 (data, end, &offset);
2636             type = dwarf2_get_die_type (offset, per_cu);
2637             fprintf_filtered (stream, "<");
2638             type_print (type, "", stream, -1);
2639             fprintf_filtered (stream, " [0x%s]> %d", phex_nz (offset, 0),
2640                               addr_size);
2641           }
2642           break;
2643
2644         case DW_OP_GNU_const_type:
2645           {
2646             ULONGEST type_die;
2647             struct type *type;
2648
2649             data = read_uleb128 (data, end, &type_die);
2650             type = dwarf2_get_die_type (type_die, per_cu);
2651             fprintf_filtered (stream, "<");
2652             type_print (type, "", stream, -1);
2653             fprintf_filtered (stream, " [0x%s]>", phex_nz (type_die, 0));
2654           }
2655           break;
2656
2657         case DW_OP_GNU_regval_type:
2658           {
2659             ULONGEST type_die, reg;
2660             struct type *type;
2661
2662             data = read_uleb128 (data, end, &reg);
2663             data = read_uleb128 (data, end, &type_die);
2664
2665             type = dwarf2_get_die_type (type_die, per_cu);
2666             fprintf_filtered (stream, "<");
2667             type_print (type, "", stream, -1);
2668             fprintf_filtered (stream, " [0x%s]> [$%s]", phex_nz (type_die, 0),
2669                               locexpr_regname (arch, reg));
2670           }
2671           break;
2672
2673         case DW_OP_GNU_convert:
2674         case DW_OP_GNU_reinterpret:
2675           {
2676             ULONGEST type_die;
2677
2678             data = read_uleb128 (data, end, &type_die);
2679
2680             if (type_die == 0)
2681               fprintf_filtered (stream, "<0>");
2682             else
2683               {
2684                 struct type *type;
2685
2686                 type = dwarf2_get_die_type (type_die, per_cu);
2687                 fprintf_filtered (stream, "<");
2688                 type_print (type, "", stream, -1);
2689                 fprintf_filtered (stream, " [0x%s]>", phex_nz (type_die, 0));
2690               }
2691           }
2692           break;
2693         }
2694
2695       fprintf_filtered (stream, "\n");
2696     }
2697
2698   return data;
2699 }
2700
2701 /* Describe a single location, which may in turn consist of multiple
2702    pieces.  */
2703
2704 static void
2705 locexpr_describe_location_1 (struct symbol *symbol, CORE_ADDR addr,
2706                              struct ui_file *stream,
2707                              const gdb_byte *data, int size,
2708                              struct objfile *objfile, unsigned int addr_size,
2709                              int offset_size, struct dwarf2_per_cu_data *per_cu)
2710 {
2711   const gdb_byte *end = data + size;
2712   int first_piece = 1, bad = 0;
2713
2714   while (data < end)
2715     {
2716       const gdb_byte *here = data;
2717       int disassemble = 1;
2718
2719       if (first_piece)
2720         first_piece = 0;
2721       else
2722         fprintf_filtered (stream, _(", and "));
2723
2724       if (!dwarf2_always_disassemble)
2725         {
2726           data = locexpr_describe_location_piece (symbol, stream,
2727                                                   addr, objfile,
2728                                                   data, end, addr_size);
2729           /* If we printed anything, or if we have an empty piece,
2730              then don't disassemble.  */
2731           if (data != here
2732               || data[0] == DW_OP_piece
2733               || data[0] == DW_OP_bit_piece)
2734             disassemble = 0;
2735         }
2736       if (disassemble)
2737         data = disassemble_dwarf_expression (stream,
2738                                              get_objfile_arch (objfile),
2739                                              addr_size, offset_size, data, end,
2740                                              dwarf2_always_disassemble,
2741                                              per_cu);
2742
2743       if (data < end)
2744         {
2745           int empty = data == here;
2746
2747           if (disassemble)
2748             fprintf_filtered (stream, "   ");
2749           if (data[0] == DW_OP_piece)
2750             {
2751               ULONGEST bytes;
2752
2753               data = read_uleb128 (data + 1, end, &bytes);
2754
2755               if (empty)
2756                 fprintf_filtered (stream, _("an empty %s-byte piece"),
2757                                   pulongest (bytes));
2758               else
2759                 fprintf_filtered (stream, _(" [%s-byte piece]"),
2760                                   pulongest (bytes));
2761             }
2762           else if (data[0] == DW_OP_bit_piece)
2763             {
2764               ULONGEST bits, offset;
2765
2766               data = read_uleb128 (data + 1, end, &bits);
2767               data = read_uleb128 (data, end, &offset);
2768
2769               if (empty)
2770                 fprintf_filtered (stream,
2771                                   _("an empty %s-bit piece"),
2772                                   pulongest (bits));
2773               else
2774                 fprintf_filtered (stream,
2775                                   _(" [%s-bit piece, offset %s bits]"),
2776                                   pulongest (bits), pulongest (offset));
2777             }
2778           else
2779             {
2780               bad = 1;
2781               break;
2782             }
2783         }
2784     }
2785
2786   if (bad || data > end)
2787     error (_("Corrupted DWARF2 expression for \"%s\"."),
2788            SYMBOL_PRINT_NAME (symbol));
2789 }
2790
2791 /* Print a natural-language description of SYMBOL to STREAM.  This
2792    version is for a symbol with a single location.  */
2793
2794 static void
2795 locexpr_describe_location (struct symbol *symbol, CORE_ADDR addr,
2796                            struct ui_file *stream)
2797 {
2798   struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
2799   struct objfile *objfile = dwarf2_per_cu_objfile (dlbaton->per_cu);
2800   unsigned int addr_size = dwarf2_per_cu_addr_size (dlbaton->per_cu);
2801   int offset_size = dwarf2_per_cu_offset_size (dlbaton->per_cu);
2802
2803   locexpr_describe_location_1 (symbol, addr, stream,
2804                                dlbaton->data, dlbaton->size,
2805                                objfile, addr_size, offset_size,
2806                                dlbaton->per_cu);
2807 }
2808
2809 /* Describe the location of SYMBOL as an agent value in VALUE, generating
2810    any necessary bytecode in AX.  */
2811
2812 static void
2813 locexpr_tracepoint_var_ref (struct symbol *symbol, struct gdbarch *gdbarch,
2814                             struct agent_expr *ax, struct axs_value *value)
2815 {
2816   struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
2817   unsigned int addr_size = dwarf2_per_cu_addr_size (dlbaton->per_cu);
2818
2819   if (dlbaton->data == NULL || dlbaton->size == 0)
2820     value->optimized_out = 1;
2821   else
2822     dwarf2_compile_expr_to_ax (ax, value, gdbarch, addr_size,
2823                                dlbaton->data, dlbaton->data + dlbaton->size,
2824                                dlbaton->per_cu);
2825 }
2826
2827 /* The set of location functions used with the DWARF-2 expression
2828    evaluator.  */
2829 const struct symbol_computed_ops dwarf2_locexpr_funcs = {
2830   locexpr_read_variable,
2831   locexpr_read_needs_frame,
2832   locexpr_describe_location,
2833   locexpr_tracepoint_var_ref
2834 };
2835
2836
2837 /* Wrapper functions for location lists.  These generally find
2838    the appropriate location expression and call something above.  */
2839
2840 /* Return the value of SYMBOL in FRAME using the DWARF-2 expression
2841    evaluator to calculate the location.  */
2842 static struct value *
2843 loclist_read_variable (struct symbol *symbol, struct frame_info *frame)
2844 {
2845   struct dwarf2_loclist_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
2846   struct value *val;
2847   const gdb_byte *data;
2848   size_t size;
2849   CORE_ADDR pc = frame ? get_frame_address_in_block (frame) : 0;
2850
2851   data = dwarf2_find_location_expression (dlbaton, &size, pc);
2852   if (data == NULL)
2853     val = allocate_optimized_out_value (SYMBOL_TYPE (symbol));
2854   else
2855     val = dwarf2_evaluate_loc_desc (SYMBOL_TYPE (symbol), frame, data, size,
2856                                     dlbaton->per_cu);
2857
2858   return val;
2859 }
2860
2861 /* Return non-zero iff we need a frame to evaluate SYMBOL.  */
2862 static int
2863 loclist_read_needs_frame (struct symbol *symbol)
2864 {
2865   /* If there's a location list, then assume we need to have a frame
2866      to choose the appropriate location expression.  With tracking of
2867      global variables this is not necessarily true, but such tracking
2868      is disabled in GCC at the moment until we figure out how to
2869      represent it.  */
2870
2871   return 1;
2872 }
2873
2874 /* Print a natural-language description of SYMBOL to STREAM.  This
2875    version applies when there is a list of different locations, each
2876    with a specified address range.  */
2877
2878 static void
2879 loclist_describe_location (struct symbol *symbol, CORE_ADDR addr,
2880                            struct ui_file *stream)
2881 {
2882   struct dwarf2_loclist_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
2883   CORE_ADDR low, high;
2884   const gdb_byte *loc_ptr, *buf_end;
2885   int length, first = 1;
2886   struct objfile *objfile = dwarf2_per_cu_objfile (dlbaton->per_cu);
2887   struct gdbarch *gdbarch = get_objfile_arch (objfile);
2888   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
2889   unsigned int addr_size = dwarf2_per_cu_addr_size (dlbaton->per_cu);
2890   int offset_size = dwarf2_per_cu_offset_size (dlbaton->per_cu);
2891   int signed_addr_p = bfd_get_sign_extend_vma (objfile->obfd);
2892   CORE_ADDR base_mask = ~(~(CORE_ADDR)1 << (addr_size * 8 - 1));
2893   /* Adjust base_address for relocatable objects.  */
2894   CORE_ADDR base_offset = dwarf2_per_cu_text_offset (dlbaton->per_cu);
2895   CORE_ADDR base_address = dlbaton->base_address + base_offset;
2896
2897   loc_ptr = dlbaton->data;
2898   buf_end = dlbaton->data + dlbaton->size;
2899
2900   fprintf_filtered (stream, _("multi-location:\n"));
2901
2902   /* Iterate through locations until we run out.  */
2903   while (1)
2904     {
2905       if (buf_end - loc_ptr < 2 * addr_size)
2906         error (_("Corrupted DWARF expression for symbol \"%s\"."),
2907                SYMBOL_PRINT_NAME (symbol));
2908
2909       if (signed_addr_p)
2910         low = extract_signed_integer (loc_ptr, addr_size, byte_order);
2911       else
2912         low = extract_unsigned_integer (loc_ptr, addr_size, byte_order);
2913       loc_ptr += addr_size;
2914
2915       if (signed_addr_p)
2916         high = extract_signed_integer (loc_ptr, addr_size, byte_order);
2917       else
2918         high = extract_unsigned_integer (loc_ptr, addr_size, byte_order);
2919       loc_ptr += addr_size;
2920
2921       /* A base-address-selection entry.  */
2922       if ((low & base_mask) == base_mask)
2923         {
2924           base_address = high + base_offset;
2925           fprintf_filtered (stream, _("  Base address %s"),
2926                             paddress (gdbarch, base_address));
2927           continue;
2928         }
2929
2930       /* An end-of-list entry.  */
2931       if (low == 0 && high == 0)
2932         break;
2933
2934       /* Otherwise, a location expression entry.  */
2935       low += base_address;
2936       high += base_address;
2937
2938       length = extract_unsigned_integer (loc_ptr, 2, byte_order);
2939       loc_ptr += 2;
2940
2941       /* (It would improve readability to print only the minimum
2942          necessary digits of the second number of the range.)  */
2943       fprintf_filtered (stream, _("  Range %s-%s: "),
2944                         paddress (gdbarch, low), paddress (gdbarch, high));
2945
2946       /* Now describe this particular location.  */
2947       locexpr_describe_location_1 (symbol, low, stream, loc_ptr, length,
2948                                    objfile, addr_size, offset_size,
2949                                    dlbaton->per_cu);
2950
2951       fprintf_filtered (stream, "\n");
2952
2953       loc_ptr += length;
2954     }
2955 }
2956
2957 /* Describe the location of SYMBOL as an agent value in VALUE, generating
2958    any necessary bytecode in AX.  */
2959 static void
2960 loclist_tracepoint_var_ref (struct symbol *symbol, struct gdbarch *gdbarch,
2961                             struct agent_expr *ax, struct axs_value *value)
2962 {
2963   struct dwarf2_loclist_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
2964   const gdb_byte *data;
2965   size_t size;
2966   unsigned int addr_size = dwarf2_per_cu_addr_size (dlbaton->per_cu);
2967
2968   data = dwarf2_find_location_expression (dlbaton, &size, ax->scope);
2969   if (data == NULL || size == 0)
2970     value->optimized_out = 1;
2971   else
2972     dwarf2_compile_expr_to_ax (ax, value, gdbarch, addr_size, data, data + size,
2973                                dlbaton->per_cu);
2974 }
2975
2976 /* The set of location functions used with the DWARF-2 expression
2977    evaluator and location lists.  */
2978 const struct symbol_computed_ops dwarf2_loclist_funcs = {
2979   loclist_read_variable,
2980   loclist_read_needs_frame,
2981   loclist_describe_location,
2982   loclist_tracepoint_var_ref
2983 };