gdb/dwarf2loc.c

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