gdb/dwarf2loc.c

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