gdb/dwarf2expr.c

   1 /* DWARF 2 Expression Evaluator.
   2
   3    Copyright (C) 2001-2003, 2005, 2007-2012 Free Software Foundation,
   4    Inc.
   5
   6    Contributed by Daniel Berlin (dan@dberlin.org)
   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 "symtab.h"
  25 #include "gdbtypes.h"
  26 #include "value.h"
  27 #include "gdbcore.h"
  28 #include "dwarf2.h"
  29 #include "dwarf2expr.h"
  30 #include "gdb_assert.h"
  31
  32 /* Local prototypes.  */
  33
  34 static void execute_stack_op (struct dwarf_expr_context *,
  35                               const gdb_byte *, const gdb_byte *);
  36
  37 /* Cookie for gdbarch data.  */
  38
  39 static struct gdbarch_data *dwarf_arch_cookie;
  40
  41 /* This holds gdbarch-specific types used by the DWARF expression
  42    evaluator.  See comments in execute_stack_op.  */
  43
  44 struct dwarf_gdbarch_types
  45 {
  46   struct type *dw_types[3];
  47 };
  48
  49 /* Allocate and fill in dwarf_gdbarch_types for an arch.  */
  50
  51 static void *
  52 dwarf_gdbarch_types_init (struct gdbarch *gdbarch)
  53 {
  54   struct dwarf_gdbarch_types *types
  55     = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct dwarf_gdbarch_types);
  56
  57   /* The types themselves are lazily initialized.  */
  58
  59   return types;
  60 }
  61
  62 /* Return the type used for DWARF operations where the type is
  63    unspecified in the DWARF spec.  Only certain sizes are
  64    supported.  */
  65
  66 static struct type *
  67 dwarf_expr_address_type (struct dwarf_expr_context *ctx)
  68 {
  69   struct dwarf_gdbarch_types *types = gdbarch_data (ctx->gdbarch,
  70                                                     dwarf_arch_cookie);
  71   int ndx;
  72
  73   if (ctx->addr_size == 2)
  74     ndx = 0;
  75   else if (ctx->addr_size == 4)
  76     ndx = 1;
  77   else if (ctx->addr_size == 8)
  78     ndx = 2;
  79   else
  80     error (_("Unsupported address size in DWARF expressions: %d bits"),
  81            8 * ctx->addr_size);
  82
  83   if (types->dw_types[ndx] == NULL)
  84     types->dw_types[ndx]
  85       = arch_integer_type (ctx->gdbarch,
  86                            8 * ctx->addr_size,
  87                            0, "<signed DWARF address type>");
  88
  89   return types->dw_types[ndx];
  90 }
  91
  92 /* Create a new context for the expression evaluator.  */
  93
  94 struct dwarf_expr_context *
  95 new_dwarf_expr_context (void)
  96 {
  97   struct dwarf_expr_context *retval;
  98
  99   retval = xcalloc (1, sizeof (struct dwarf_expr_context));
 100   retval->stack_len = 0;
 101   retval->stack_allocated = 10;
 102   retval->stack = xmalloc (retval->stack_allocated
 103                            * sizeof (struct dwarf_stack_value));
 104   retval->num_pieces = 0;
 105   retval->pieces = 0;
 106   retval->max_recursion_depth = 0x100;
 107   return retval;
 108 }
 109
 110 /* Release the memory allocated to CTX.  */
 111
 112 void
 113 free_dwarf_expr_context (struct dwarf_expr_context *ctx)
 114 {
 115   xfree (ctx->stack);
 116   xfree (ctx->pieces);
 117   xfree (ctx);
 118 }
 119
 120 /* Helper for make_cleanup_free_dwarf_expr_context.  */
 121
 122 static void
 123 free_dwarf_expr_context_cleanup (void *arg)
 124 {
 125   free_dwarf_expr_context (arg);
 126 }
 127
 128 /* Return a cleanup that calls free_dwarf_expr_context.  */
 129
 130 struct cleanup *
 131 make_cleanup_free_dwarf_expr_context (struct dwarf_expr_context *ctx)
 132 {
 133   return make_cleanup (free_dwarf_expr_context_cleanup, ctx);
 134 }
 135
 136 /* Expand the memory allocated to CTX's stack to contain at least
 137    NEED more elements than are currently used.  */
 138
 139 static void
 140 dwarf_expr_grow_stack (struct dwarf_expr_context *ctx, size_t need)
 141 {
 142   if (ctx->stack_len + need > ctx->stack_allocated)
 143     {
 144       size_t newlen = ctx->stack_len + need + 10;
 145
 146       ctx->stack = xrealloc (ctx->stack,
 147                              newlen * sizeof (struct dwarf_stack_value));
 148       ctx->stack_allocated = newlen;
 149     }
 150 }
 151
 152 /* Push VALUE onto CTX's stack.  */
 153
 154 static void
 155 dwarf_expr_push (struct dwarf_expr_context *ctx, struct value *value,
 156                  int in_stack_memory)
 157 {
 158   struct dwarf_stack_value *v;
 159
 160   dwarf_expr_grow_stack (ctx, 1);
 161   v = &ctx->stack[ctx->stack_len++];
 162   v->value = value;
 163   v->in_stack_memory = in_stack_memory;
 164 }
 165
 166 /* Push VALUE onto CTX's stack.  */
 167
 168 void
 169 dwarf_expr_push_address (struct dwarf_expr_context *ctx, CORE_ADDR value,
 170                          int in_stack_memory)
 171 {
 172   dwarf_expr_push (ctx,
 173                    value_from_ulongest (dwarf_expr_address_type (ctx), value),
 174                    in_stack_memory);
 175 }
 176
 177 /* Pop the top item off of CTX's stack.  */
 178
 179 static void
 180 dwarf_expr_pop (struct dwarf_expr_context *ctx)
 181 {
 182   if (ctx->stack_len <= 0)
 183     error (_("dwarf expression stack underflow"));
 184   ctx->stack_len--;
 185 }
 186
 187 /* Retrieve the N'th item on CTX's stack.  */
 188
 189 struct value *
 190 dwarf_expr_fetch (struct dwarf_expr_context *ctx, int n)
 191 {
 192   if (ctx->stack_len <= n)
 193      error (_("Asked for position %d of stack, "
 194               "stack only has %d elements on it."),
 195             n, ctx->stack_len);
 196   return ctx->stack[ctx->stack_len - (1 + n)].value;
 197 }
 198
 199 /* Require that TYPE be an integral type; throw an exception if not.  */
 200
 201 static void
 202 dwarf_require_integral (struct type *type)
 203 {
 204   if (TYPE_CODE (type) != TYPE_CODE_INT
 205       && TYPE_CODE (type) != TYPE_CODE_CHAR
 206       && TYPE_CODE (type) != TYPE_CODE_BOOL)
 207     error (_("integral type expected in DWARF expression"));
 208 }
 209
 210 /* Return the unsigned form of TYPE.  TYPE is necessarily an integral
 211    type.  */
 212
 213 static struct type *
 214 get_unsigned_type (struct gdbarch *gdbarch, struct type *type)
 215 {
 216   switch (TYPE_LENGTH (type))
 217     {
 218     case 1:
 219       return builtin_type (gdbarch)->builtin_uint8;
 220     case 2:
 221       return builtin_type (gdbarch)->builtin_uint16;
 222     case 4:
 223       return builtin_type (gdbarch)->builtin_uint32;
 224     case 8:
 225       return builtin_type (gdbarch)->builtin_uint64;
 226     default:
 227       error (_("no unsigned variant found for type, while evaluating "
 228                "DWARF expression"));
 229     }
 230 }
 231
 232 /* Return the signed form of TYPE.  TYPE is necessarily an integral
 233    type.  */
 234
 235 static struct type *
 236 get_signed_type (struct gdbarch *gdbarch, struct type *type)
 237 {
 238   switch (TYPE_LENGTH (type))
 239     {
 240     case 1:
 241       return builtin_type (gdbarch)->builtin_int8;
 242     case 2:
 243       return builtin_type (gdbarch)->builtin_int16;
 244     case 4:
 245       return builtin_type (gdbarch)->builtin_int32;
 246     case 8:
 247       return builtin_type (gdbarch)->builtin_int64;
 248     default:
 249       error (_("no signed variant found for type, while evaluating "
 250                "DWARF expression"));
 251     }
 252 }
 253
 254 /* Retrieve the N'th item on CTX's stack, converted to an address.  */
 255
 256 CORE_ADDR
 257 dwarf_expr_fetch_address (struct dwarf_expr_context *ctx, int n)
 258 {
 259   struct value *result_val = dwarf_expr_fetch (ctx, n);
 260   enum bfd_endian byte_order = gdbarch_byte_order (ctx->gdbarch);
 261   ULONGEST result;
 262
 263   dwarf_require_integral (value_type (result_val));
 264   result = extract_unsigned_integer (value_contents (result_val),
 265                                      TYPE_LENGTH (value_type (result_val)),
 266                                      byte_order);
 267
 268   /* For most architectures, calling extract_unsigned_integer() alone
 269      is sufficient for extracting an address.  However, some
 270      architectures (e.g. MIPS) use signed addresses and using
 271      extract_unsigned_integer() will not produce a correct
 272      result.  Make sure we invoke gdbarch_integer_to_address()
 273      for those architectures which require it.  */
 274   if (gdbarch_integer_to_address_p (ctx->gdbarch))
 275     {
 276       gdb_byte *buf = alloca (ctx->addr_size);
 277       struct type *int_type = get_unsigned_type (ctx->gdbarch,
 278                                                  value_type (result_val));
 279
 280       store_unsigned_integer (buf, ctx->addr_size, byte_order, result);
 281       return gdbarch_integer_to_address (ctx->gdbarch, int_type, buf);
 282     }
 283
 284   return (CORE_ADDR) result;
 285 }
 286
 287 /* Retrieve the in_stack_memory flag of the N'th item on CTX's stack.  */
 288
 289 int
 290 dwarf_expr_fetch_in_stack_memory (struct dwarf_expr_context *ctx, int n)
 291 {
 292   if (ctx->stack_len <= n)
 293      error (_("Asked for position %d of stack, "
 294               "stack only has %d elements on it."),
 295             n, ctx->stack_len);
 296   return ctx->stack[ctx->stack_len - (1 + n)].in_stack_memory;
 297 }
 298
 299 /* Return true if the expression stack is empty.  */
 300
 301 static int
 302 dwarf_expr_stack_empty_p (struct dwarf_expr_context *ctx)
 303 {
 304   return ctx->stack_len == 0;
 305 }
 306
 307 /* Add a new piece to CTX's piece list.  */
 308 static void
 309 add_piece (struct dwarf_expr_context *ctx, ULONGEST size, ULONGEST offset)
 310 {
 311   struct dwarf_expr_piece *p;
 312
 313   ctx->num_pieces++;
 314
 315   ctx->pieces = xrealloc (ctx->pieces,
 316                           (ctx->num_pieces
 317                            * sizeof (struct dwarf_expr_piece)));
 318
 319   p = &ctx->pieces[ctx->num_pieces - 1];
 320   p->location = ctx->location;
 321   p->size = size;
 322   p->offset = offset;
 323
 324   if (p->location == DWARF_VALUE_LITERAL)
 325     {
 326       p->v.literal.data = ctx->data;
 327       p->v.literal.length = ctx->len;
 328     }
 329   else if (dwarf_expr_stack_empty_p (ctx))
 330     {
 331       p->location = DWARF_VALUE_OPTIMIZED_OUT;
 332       /* Also reset the context's location, for our callers.  This is
 333          a somewhat strange approach, but this lets us avoid setting
 334          the location to DWARF_VALUE_MEMORY in all the individual
 335          cases in the evaluator.  */
 336       ctx->location = DWARF_VALUE_OPTIMIZED_OUT;
 337     }
 338   else if (p->location == DWARF_VALUE_MEMORY)
 339     {
 340       p->v.mem.addr = dwarf_expr_fetch_address (ctx, 0);
 341       p->v.mem.in_stack_memory = dwarf_expr_fetch_in_stack_memory (ctx, 0);
 342     }
 343   else if (p->location == DWARF_VALUE_IMPLICIT_POINTER)
 344     {
 345       p->v.ptr.die.cu_off = ctx->len;
 346       p->v.ptr.offset = value_as_long (dwarf_expr_fetch (ctx, 0));
 347     }
 348   else if (p->location == DWARF_VALUE_REGISTER)
 349     p->v.regno = value_as_long (dwarf_expr_fetch (ctx, 0));
 350   else
 351     {
 352       p->v.value = dwarf_expr_fetch (ctx, 0);
 353     }
 354 }
 355
 356 /* Evaluate the expression at ADDR (LEN bytes long) using the context
 357    CTX.  */
 358
 359 void
 360 dwarf_expr_eval (struct dwarf_expr_context *ctx, const gdb_byte *addr,
 361                  size_t len)
 362 {
 363   int old_recursion_depth = ctx->recursion_depth;
 364
 365   execute_stack_op (ctx, addr, addr + len);
 366
 367   /* CTX RECURSION_DEPTH becomes invalid if an exception was thrown here.  */
 368
 369   gdb_assert (ctx->recursion_depth == old_recursion_depth);
 370 }
 371
 372 /* Decode the unsigned LEB128 constant at BUF into the variable pointed to
 373    by R, and return the new value of BUF.  Verify that it doesn't extend
 374    past BUF_END.  R can be NULL, the constant is then only skipped.  */
 375
 376 const gdb_byte *
 377 read_uleb128 (const gdb_byte *buf, const gdb_byte *buf_end, ULONGEST * r)
 378 {
 379   unsigned shift = 0;
 380   ULONGEST result = 0;
 381   gdb_byte byte;
 382
 383   while (1)
 384     {
 385       if (buf >= buf_end)
 386         error (_("read_uleb128: Corrupted DWARF expression."));
 387
 388       byte = *buf++;
 389       result |= ((ULONGEST) (byte & 0x7f)) << shift;
 390       if ((byte & 0x80) == 0)
 391         break;
 392       shift += 7;
 393     }
 394   if (r)
 395     *r = result;
 396   return buf;
 397 }
 398
 399 /* Decode the signed LEB128 constant at BUF into the variable pointed to
 400    by R, and return the new value of BUF.  Verify that it doesn't extend
 401    past BUF_END.  R can be NULL, the constant is then only skipped.  */
 402
 403 const gdb_byte *
 404 read_sleb128 (const gdb_byte *buf, const gdb_byte *buf_end, LONGEST * r)
 405 {
 406   unsigned shift = 0;
 407   LONGEST result = 0;
 408   gdb_byte byte;
 409
 410   while (1)
 411     {
 412       if (buf >= buf_end)
 413         error (_("read_sleb128: Corrupted DWARF expression."));
 414
 415       byte = *buf++;
 416       result |= ((ULONGEST) (byte & 0x7f)) << shift;
 417       shift += 7;
 418       if ((byte & 0x80) == 0)
 419         break;
 420     }
 421   if (shift < (sizeof (*r) * 8) && (byte & 0x40) != 0)
 422     result |= -(((LONGEST) 1) << shift);
 423
 424   if (r)
 425     *r = result;
 426   return buf;
 427 }
 428 \f
 429
 430 /* Check that the current operator is either at the end of an
 431    expression, or that it is followed by a composition operator.  */
 432
 433 void
 434 dwarf_expr_require_composition (const gdb_byte *op_ptr, const gdb_byte *op_end,
 435                                 const char *op_name)
 436 {
 437   /* It seems like DW_OP_GNU_uninit should be handled here.  However,
 438      it doesn't seem to make sense for DW_OP_*_value, and it was not
 439      checked at the other place that this function is called.  */
 440   if (op_ptr != op_end && *op_ptr != DW_OP_piece && *op_ptr != DW_OP_bit_piece)
 441     error (_("DWARF-2 expression error: `%s' operations must be "
 442              "used either alone or in conjunction with DW_OP_piece "
 443              "or DW_OP_bit_piece."),
 444            op_name);
 445 }
 446
 447 /* Return true iff the types T1 and T2 are "the same".  This only does
 448    checks that might reasonably be needed to compare DWARF base
 449    types.  */
 450
 451 static int
 452 base_types_equal_p (struct type *t1, struct type *t2)
 453 {
 454   if (TYPE_CODE (t1) != TYPE_CODE (t2))
 455     return 0;
 456   if (TYPE_UNSIGNED (t1) != TYPE_UNSIGNED (t2))
 457     return 0;
 458   return TYPE_LENGTH (t1) == TYPE_LENGTH (t2);
 459 }
 460
 461 /* A convenience function to call get_base_type on CTX and return the
 462    result.  DIE is the DIE whose type we need.  SIZE is non-zero if
 463    this function should verify that the resulting type has the correct
 464    size.  */
 465
 466 static struct type *
 467 dwarf_get_base_type (struct dwarf_expr_context *ctx, cu_offset die, int size)
 468 {
 469   struct type *result;
 470
 471   if (ctx->funcs->get_base_type)
 472     {
 473       result = ctx->funcs->get_base_type (ctx, die);
 474       if (result == NULL)
 475         error (_("Could not find type for DW_OP_GNU_const_type"));
 476       if (size != 0 && TYPE_LENGTH (result) != size)
 477         error (_("DW_OP_GNU_const_type has different sizes for type and data"));
 478     }
 479   else
 480     /* Anything will do.  */
 481     result = builtin_type (ctx->gdbarch)->builtin_int;
 482
 483   return result;
 484 }
 485
 486 /* If <BUF..BUF_END] contains DW_FORM_block* with single DW_OP_reg* return the
 487    DWARF register number.  Otherwise return -1.  */
 488
 489 int
 490 dwarf_block_to_dwarf_reg (const gdb_byte *buf, const gdb_byte *buf_end)
 491 {
 492   ULONGEST dwarf_reg;
 493
 494   if (buf_end <= buf)
 495     return -1;
 496   if (*buf >= DW_OP_reg0 && *buf <= DW_OP_reg31)
 497     {
 498       if (buf_end - buf != 1)
 499         return -1;
 500       return *buf - DW_OP_reg0;
 501     }
 502
 503   if (*buf == DW_OP_GNU_regval_type)
 504     {
 505       buf++;
 506       buf = read_uleb128 (buf, buf_end, &dwarf_reg);
 507       buf = read_uleb128 (buf, buf_end, NULL);
 508     }
 509   else if (*buf == DW_OP_regx)
 510     {
 511       buf++;
 512       buf = read_uleb128 (buf, buf_end, &dwarf_reg);
 513     }
 514   else
 515     return -1;
 516   if (buf != buf_end || (int) dwarf_reg != dwarf_reg)
 517     return -1;
 518   return dwarf_reg;
 519 }
 520
 521 /* If <BUF..BUF_END] contains DW_FORM_block* with just DW_OP_breg*(0) and
 522    DW_OP_deref* return the DWARF register number.  Otherwise return -1.
 523    DEREF_SIZE_RETURN contains -1 for DW_OP_deref; otherwise it contains the
 524    size from DW_OP_deref_size.  */
 525
 526 int
 527 dwarf_block_to_dwarf_reg_deref (const gdb_byte *buf, const gdb_byte *buf_end,
 528                                 CORE_ADDR *deref_size_return)
 529 {
 530   ULONGEST dwarf_reg;
 531   LONGEST offset;
 532
 533   if (buf_end <= buf)
 534     return -1;
 535   if (*buf >= DW_OP_breg0 && *buf <= DW_OP_breg31)
 536     {
 537       dwarf_reg = *buf - DW_OP_breg0;
 538       buf++;
 539     }
 540   else if (*buf == DW_OP_bregx)
 541     {
 542       buf++;
 543       buf = read_uleb128 (buf, buf_end, &dwarf_reg);
 544       if ((int) dwarf_reg != dwarf_reg)
 545        return -1;
 546     }
 547   else
 548     return -1;
 549
 550   buf = read_sleb128 (buf, buf_end, &offset);
 551   if (offset != 0)
 552     return -1;
 553
 554   if (buf >= buf_end)
 555     return -1;
 556
 557   if (*buf == DW_OP_deref)
 558     {
 559       buf++;
 560       *deref_size_return = -1;
 561     }
 562   else if (*buf == DW_OP_deref_size)
 563     {
 564       buf++;
 565       if (buf >= buf_end)
 566        return -1;
 567       *deref_size_return = *buf++;
 568     }
 569   else
 570     return -1;
 571
 572   if (buf != buf_end)
 573     return -1;
 574
 575   return dwarf_reg;
 576 }
 577
 578 /* If <BUF..BUF_END] contains DW_FORM_block* with single DW_OP_fbreg(X) fill
 579    in FB_OFFSET_RETURN with the X offset and return 1.  Otherwise return 0.  */
 580
 581 int
 582 dwarf_block_to_fb_offset (const gdb_byte *buf, const gdb_byte *buf_end,
 583                           CORE_ADDR *fb_offset_return)
 584 {
 585   LONGEST fb_offset;
 586
 587   if (buf_end <= buf)
 588     return 0;
 589
 590   if (*buf != DW_OP_fbreg)
 591     return 0;
 592   buf++;
 593
 594   buf = read_sleb128 (buf, buf_end, &fb_offset);
 595   *fb_offset_return = fb_offset;
 596   if (buf != buf_end || fb_offset != (LONGEST) *fb_offset_return)
 597     return 0;
 598
 599   return 1;
 600 }
 601
 602 /* If <BUF..BUF_END] contains DW_FORM_block* with single DW_OP_bregSP(X) fill
 603    in SP_OFFSET_RETURN with the X offset and return 1.  Otherwise return 0.
 604    The matched SP register number depends on GDBARCH.  */
 605
 606 int
 607 dwarf_block_to_sp_offset (struct gdbarch *gdbarch, const gdb_byte *buf,
 608                           const gdb_byte *buf_end, CORE_ADDR *sp_offset_return)
 609 {
 610   ULONGEST dwarf_reg;
 611   LONGEST sp_offset;
 612
 613   if (buf_end <= buf)
 614     return 0;
 615   if (*buf >= DW_OP_breg0 && *buf <= DW_OP_breg31)
 616     {
 617       dwarf_reg = *buf - DW_OP_breg0;
 618       buf++;
 619     }
 620   else
 621     {
 622       if (*buf != DW_OP_bregx)
 623        return 0;
 624       buf++;
 625       buf = read_uleb128 (buf, buf_end, &dwarf_reg);
 626     }
 627
 628   if (gdbarch_dwarf2_reg_to_regnum (gdbarch, dwarf_reg)
 629       != gdbarch_sp_regnum (gdbarch))
 630     return 0;
 631
 632   buf = read_sleb128 (buf, buf_end, &sp_offset);
 633   *sp_offset_return = sp_offset;
 634   if (buf != buf_end || sp_offset != (LONGEST) *sp_offset_return)
 635     return 0;
 636
 637   return 1;
 638 }
 639
 640 /* The engine for the expression evaluator.  Using the context in CTX,
 641    evaluate the expression between OP_PTR and OP_END.  */
 642
 643 static void
 644 execute_stack_op (struct dwarf_expr_context *ctx,
 645                   const gdb_byte *op_ptr, const gdb_byte *op_end)
 646 {
 647   enum bfd_endian byte_order = gdbarch_byte_order (ctx->gdbarch);
 648   /* Old-style "untyped" DWARF values need special treatment in a
 649      couple of places, specifically DW_OP_mod and DW_OP_shr.  We need
 650      a special type for these values so we can distinguish them from
 651      values that have an explicit type, because explicitly-typed
 652      values do not need special treatment.  This special type must be
 653      different (in the `==' sense) from any base type coming from the
 654      CU.  */
 655   struct type *address_type = dwarf_expr_address_type (ctx);
 656
 657   ctx->location = DWARF_VALUE_MEMORY;
 658   ctx->initialized = 1;  /* Default is initialized.  */
 659
 660   if (ctx->recursion_depth > ctx->max_recursion_depth)
 661     error (_("DWARF-2 expression error: Loop detected (%d)."),
 662            ctx->recursion_depth);
 663   ctx->recursion_depth++;
 664
 665   while (op_ptr < op_end)
 666     {
 667       enum dwarf_location_atom op = *op_ptr++;
 668       ULONGEST result;
 669       /* Assume the value is not in stack memory.
 670          Code that knows otherwise sets this to 1.
 671          Some arithmetic on stack addresses can probably be assumed to still
 672          be a stack address, but we skip this complication for now.
 673          This is just an optimization, so it's always ok to punt
 674          and leave this as 0.  */
 675       int in_stack_memory = 0;
 676       ULONGEST uoffset, reg;
 677       LONGEST offset;
 678       struct value *result_val = NULL;
 679
 680       /* The DWARF expression might have a bug causing an infinite
 681          loop.  In that case, quitting is the only way out.  */
 682       QUIT;
 683
 684       switch (op)
 685         {
 686         case DW_OP_lit0:
 687         case DW_OP_lit1:
 688         case DW_OP_lit2:
 689         case DW_OP_lit3:
 690         case DW_OP_lit4:
 691         case DW_OP_lit5:
 692         case DW_OP_lit6:
 693         case DW_OP_lit7:
 694         case DW_OP_lit8:
 695         case DW_OP_lit9:
 696         case DW_OP_lit10:
 697         case DW_OP_lit11:
 698         case DW_OP_lit12:
 699         case DW_OP_lit13:
 700         case DW_OP_lit14:
 701         case DW_OP_lit15:
 702         case DW_OP_lit16:
 703         case DW_OP_lit17:
 704         case DW_OP_lit18:
 705         case DW_OP_lit19:
 706         case DW_OP_lit20:
 707         case DW_OP_lit21:
 708         case DW_OP_lit22:
 709         case DW_OP_lit23:
 710         case DW_OP_lit24:
 711         case DW_OP_lit25:
 712         case DW_OP_lit26:
 713         case DW_OP_lit27:
 714         case DW_OP_lit28:
 715         case DW_OP_lit29:
 716         case DW_OP_lit30:
 717         case DW_OP_lit31:
 718           result = op - DW_OP_lit0;
 719           result_val = value_from_ulongest (address_type, result);
 720           break;
 721
 722         case DW_OP_addr:
 723           result = extract_unsigned_integer (op_ptr,
 724                                              ctx->addr_size, byte_order);
 725           op_ptr += ctx->addr_size;
 726           /* Some versions of GCC emit DW_OP_addr before
 727              DW_OP_GNU_push_tls_address.  In this case the value is an
 728              index, not an address.  We don't support things like
 729              branching between the address and the TLS op.  */
 730           if (op_ptr >= op_end || *op_ptr != DW_OP_GNU_push_tls_address)
 731             result += ctx->offset;
 732           result_val = value_from_ulongest (address_type, result);
 733           break;
 734
 735         case DW_OP_GNU_addr_index:
 736           op_ptr = read_uleb128 (op_ptr, op_end, &uoffset);
 737           result = (ctx->funcs->get_addr_index) (ctx->baton, uoffset);
 738           result_val = value_from_ulongest (address_type, result);
 739           break;
 740
 741         case DW_OP_const1u:
 742           result = extract_unsigned_integer (op_ptr, 1, byte_order);
 743           result_val = value_from_ulongest (address_type, result);
 744           op_ptr += 1;
 745           break;
 746         case DW_OP_const1s:
 747           result = extract_signed_integer (op_ptr, 1, byte_order);
 748           result_val = value_from_ulongest (address_type, result);
 749           op_ptr += 1;
 750           break;
 751         case DW_OP_const2u:
 752           result = extract_unsigned_integer (op_ptr, 2, byte_order);
 753           result_val = value_from_ulongest (address_type, result);
 754           op_ptr += 2;
 755           break;
 756         case DW_OP_const2s:
 757           result = extract_signed_integer (op_ptr, 2, byte_order);
 758           result_val = value_from_ulongest (address_type, result);
 759           op_ptr += 2;
 760           break;
 761         case DW_OP_const4u:
 762           result = extract_unsigned_integer (op_ptr, 4, byte_order);
 763           result_val = value_from_ulongest (address_type, result);
 764           op_ptr += 4;
 765           break;
 766         case DW_OP_const4s:
 767           result = extract_signed_integer (op_ptr, 4, byte_order);
 768           result_val = value_from_ulongest (address_type, result);
 769           op_ptr += 4;
 770           break;
 771         case DW_OP_const8u:
 772           result = extract_unsigned_integer (op_ptr, 8, byte_order);
 773           result_val = value_from_ulongest (address_type, result);
 774           op_ptr += 8;
 775           break;
 776         case DW_OP_const8s:
 777           result = extract_signed_integer (op_ptr, 8, byte_order);
 778           result_val = value_from_ulongest (address_type, result);
 779           op_ptr += 8;
 780           break;
 781         case DW_OP_constu:
 782           op_ptr = read_uleb128 (op_ptr, op_end, &uoffset);
 783           result = uoffset;
 784           result_val = value_from_ulongest (address_type, result);
 785           break;
 786         case DW_OP_consts:
 787           op_ptr = read_sleb128 (op_ptr, op_end, &offset);
 788           result = offset;
 789           result_val = value_from_ulongest (address_type, result);
 790           break;
 791
 792         /* The DW_OP_reg operations are required to occur alone in
 793            location expressions.  */
 794         case DW_OP_reg0:
 795         case DW_OP_reg1:
 796         case DW_OP_reg2:
 797         case DW_OP_reg3:
 798         case DW_OP_reg4:
 799         case DW_OP_reg5:
 800         case DW_OP_reg6:
 801         case DW_OP_reg7:
 802         case DW_OP_reg8:
 803         case DW_OP_reg9:
 804         case DW_OP_reg10:
 805         case DW_OP_reg11:
 806         case DW_OP_reg12:
 807         case DW_OP_reg13:
 808         case DW_OP_reg14:
 809         case DW_OP_reg15:
 810         case DW_OP_reg16:
 811         case DW_OP_reg17:
 812         case DW_OP_reg18:
 813         case DW_OP_reg19:
 814         case DW_OP_reg20:
 815         case DW_OP_reg21:
 816         case DW_OP_reg22:
 817         case DW_OP_reg23:
 818         case DW_OP_reg24:
 819         case DW_OP_reg25:
 820         case DW_OP_reg26:
 821         case DW_OP_reg27:
 822         case DW_OP_reg28:
 823         case DW_OP_reg29:
 824         case DW_OP_reg30:
 825         case DW_OP_reg31:
 826           if (op_ptr != op_end
 827               && *op_ptr != DW_OP_piece
 828               && *op_ptr != DW_OP_bit_piece
 829               && *op_ptr != DW_OP_GNU_uninit)
 830             error (_("DWARF-2 expression error: DW_OP_reg operations must be "
 831                      "used either alone or in conjunction with DW_OP_piece "
 832                      "or DW_OP_bit_piece."));
 833
 834           result = op - DW_OP_reg0;
 835           result_val = value_from_ulongest (address_type, result);
 836           ctx->location = DWARF_VALUE_REGISTER;
 837           break;
 838
 839         case DW_OP_regx:
 840           op_ptr = read_uleb128 (op_ptr, op_end, &reg);
 841           dwarf_expr_require_composition (op_ptr, op_end, "DW_OP_regx");
 842
 843           result = reg;
 844           result_val = value_from_ulongest (address_type, result);
 845           ctx->location = DWARF_VALUE_REGISTER;
 846           break;
 847
 848         case DW_OP_implicit_value:
 849           {
 850             ULONGEST len;
 851
 852             op_ptr = read_uleb128 (op_ptr, op_end, &len);
 853             if (op_ptr + len > op_end)
 854               error (_("DW_OP_implicit_value: too few bytes available."));
 855             ctx->len = len;
 856             ctx->data = op_ptr;
 857             ctx->location = DWARF_VALUE_LITERAL;
 858             op_ptr += len;
 859             dwarf_expr_require_composition (op_ptr, op_end,
 860                                             "DW_OP_implicit_value");
 861           }
 862           goto no_push;
 863
 864         case DW_OP_stack_value:
 865           ctx->location = DWARF_VALUE_STACK;
 866           dwarf_expr_require_composition (op_ptr, op_end, "DW_OP_stack_value");
 867           goto no_push;
 868
 869         case DW_OP_GNU_implicit_pointer:
 870           {
 871             LONGEST len;
 872
 873             if (ctx->ref_addr_size == -1)
 874               error (_("DWARF-2 expression error: DW_OP_GNU_implicit_pointer "
 875                        "is not allowed in frame context"));
 876
 877             /* The referred-to DIE of cu_offset kind.  */
 878             ctx->len = extract_unsigned_integer (op_ptr, ctx->ref_addr_size,
 879                                                  byte_order);
 880             op_ptr += ctx->ref_addr_size;
 881
 882             /* The byte offset into the data.  */
 883             op_ptr = read_sleb128 (op_ptr, op_end, &len);
 884             result = (ULONGEST) len;
 885             result_val = value_from_ulongest (address_type, result);
 886
 887             ctx->location = DWARF_VALUE_IMPLICIT_POINTER;
 888             dwarf_expr_require_composition (op_ptr, op_end,
 889                                             "DW_OP_GNU_implicit_pointer");
 890           }
 891           break;
 892
 893         case DW_OP_breg0:
 894         case DW_OP_breg1:
 895         case DW_OP_breg2:
 896         case DW_OP_breg3:
 897         case DW_OP_breg4:
 898         case DW_OP_breg5:
 899         case DW_OP_breg6:
 900         case DW_OP_breg7:
 901         case DW_OP_breg8:
 902         case DW_OP_breg9:
 903         case DW_OP_breg10:
 904         case DW_OP_breg11:
 905         case DW_OP_breg12:
 906         case DW_OP_breg13:
 907         case DW_OP_breg14:
 908         case DW_OP_breg15:
 909         case DW_OP_breg16:
 910         case DW_OP_breg17:
 911         case DW_OP_breg18:
 912         case DW_OP_breg19:
 913         case DW_OP_breg20:
 914         case DW_OP_breg21:
 915         case DW_OP_breg22:
 916         case DW_OP_breg23:
 917         case DW_OP_breg24:
 918         case DW_OP_breg25:
 919         case DW_OP_breg26:
 920         case DW_OP_breg27:
 921         case DW_OP_breg28:
 922         case DW_OP_breg29:
 923         case DW_OP_breg30:
 924         case DW_OP_breg31:
 925           {
 926             op_ptr = read_sleb128 (op_ptr, op_end, &offset);
 927             result = (ctx->funcs->read_reg) (ctx->baton, op - DW_OP_breg0);
 928             result += offset;
 929             result_val = value_from_ulongest (address_type, result);
 930           }
 931           break;
 932         case DW_OP_bregx:
 933           {
 934             op_ptr = read_uleb128 (op_ptr, op_end, &reg);
 935             op_ptr = read_sleb128 (op_ptr, op_end, &offset);
 936             result = (ctx->funcs->read_reg) (ctx->baton, reg);
 937             result += offset;
 938             result_val = value_from_ulongest (address_type, result);
 939           }
 940           break;
 941         case DW_OP_fbreg:
 942           {
 943             const gdb_byte *datastart;
 944             size_t datalen;
 945             unsigned int before_stack_len;
 946
 947             op_ptr = read_sleb128 (op_ptr, op_end, &offset);
 948             /* Rather than create a whole new context, we simply
 949                record the stack length before execution, then reset it
 950                afterwards, effectively erasing whatever the recursive
 951                call put there.  */
 952             before_stack_len = ctx->stack_len;
 953             /* FIXME: cagney/2003-03-26: This code should be using
 954                get_frame_base_address(), and then implement a dwarf2
 955                specific this_base method.  */
 956             (ctx->funcs->get_frame_base) (ctx->baton, &datastart, &datalen);
 957             dwarf_expr_eval (ctx, datastart, datalen);
 958             if (ctx->location == DWARF_VALUE_MEMORY)
 959               result = dwarf_expr_fetch_address (ctx, 0);
 960             else if (ctx->location == DWARF_VALUE_REGISTER)
 961               result = (ctx->funcs->read_reg) (ctx->baton,
 962                                      value_as_long (dwarf_expr_fetch (ctx, 0)));
 963             else
 964               error (_("Not implemented: computing frame "
 965                        "base using explicit value operator"));
 966             result = result + offset;
 967             result_val = value_from_ulongest (address_type, result);
 968             in_stack_memory = 1;
 969             ctx->stack_len = before_stack_len;
 970             ctx->location = DWARF_VALUE_MEMORY;
 971           }
 972           break;
 973
 974         case DW_OP_dup:
 975           result_val = dwarf_expr_fetch (ctx, 0);
 976           in_stack_memory = dwarf_expr_fetch_in_stack_memory (ctx, 0);
 977           break;
 978
 979         case DW_OP_drop:
 980           dwarf_expr_pop (ctx);
 981           goto no_push;
 982
 983         case DW_OP_pick:
 984           offset = *op_ptr++;
 985           result_val = dwarf_expr_fetch (ctx, offset);
 986           in_stack_memory = dwarf_expr_fetch_in_stack_memory (ctx, offset);
 987           break;
 988
 989         case DW_OP_swap:
 990           {
 991             struct dwarf_stack_value t1, t2;
 992
 993             if (ctx->stack_len < 2)
 994                error (_("Not enough elements for "
 995                         "DW_OP_swap.  Need 2, have %d."),
 996                       ctx->stack_len);
 997             t1 = ctx->stack[ctx->stack_len - 1];
 998             t2 = ctx->stack[ctx->stack_len - 2];
 999             ctx->stack[ctx->stack_len - 1] = t2;
1000             ctx->stack[ctx->stack_len - 2] = t1;
1001             goto no_push;
1002           }
1003
1004         case DW_OP_over:
1005           result_val = dwarf_expr_fetch (ctx, 1);
1006           in_stack_memory = dwarf_expr_fetch_in_stack_memory (ctx, 1);
1007           break;
1008
1009         case DW_OP_rot:
1010           {
1011             struct dwarf_stack_value t1, t2, t3;
1012
1013             if (ctx->stack_len < 3)
1014                error (_("Not enough elements for "
1015                         "DW_OP_rot.  Need 3, have %d."),
1016                       ctx->stack_len);
1017             t1 = ctx->stack[ctx->stack_len - 1];
1018             t2 = ctx->stack[ctx->stack_len - 2];
1019             t3 = ctx->stack[ctx->stack_len - 3];
1020             ctx->stack[ctx->stack_len - 1] = t2;
1021             ctx->stack[ctx->stack_len - 2] = t3;
1022             ctx->stack[ctx->stack_len - 3] = t1;
1023             goto no_push;
1024           }
1025
1026         case DW_OP_deref:
1027         case DW_OP_deref_size:
1028         case DW_OP_GNU_deref_type:
1029           {
1030             int addr_size = (op == DW_OP_deref ? ctx->addr_size : *op_ptr++);
1031             gdb_byte *buf = alloca (addr_size);
1032             CORE_ADDR addr = dwarf_expr_fetch_address (ctx, 0);
1033             struct type *type;
1034
1035             dwarf_expr_pop (ctx);
1036
1037             if (op == DW_OP_GNU_deref_type)
1038               {
1039                 cu_offset type_die;
1040
1041                 op_ptr = read_uleb128 (op_ptr, op_end, &uoffset);
1042                 type_die.cu_off = uoffset;
1043                 type = dwarf_get_base_type (ctx, type_die, 0);
1044               }
1045             else
1046               type = address_type;
1047
1048             (ctx->funcs->read_mem) (ctx->baton, buf, addr, addr_size);
1049
1050             /* If the size of the object read from memory is different
1051                from the type length, we need to zero-extend it.  */
1052             if (TYPE_LENGTH (type) != addr_size)
1053               {
1054                 ULONGEST result =
1055                   extract_unsigned_integer (buf, addr_size, byte_order);
1056
1057                 buf = alloca (TYPE_LENGTH (type));
1058                 store_unsigned_integer (buf, TYPE_LENGTH (type),
1059                                         byte_order, result);
1060               }
1061
1062             result_val = value_from_contents_and_address (type, buf, addr);
1063             break;
1064           }
1065
1066         case DW_OP_abs:
1067         case DW_OP_neg:
1068         case DW_OP_not:
1069         case DW_OP_plus_uconst:
1070           {
1071             /* Unary operations.  */
1072             result_val = dwarf_expr_fetch (ctx, 0);
1073             dwarf_expr_pop (ctx);
1074
1075             switch (op)
1076               {
1077               case DW_OP_abs:
1078                 if (value_less (result_val,
1079                                 value_zero (value_type (result_val), not_lval)))
1080                   result_val = value_neg (result_val);
1081                 break;
1082               case DW_OP_neg:
1083                 result_val = value_neg (result_val);
1084                 break;
1085               case DW_OP_not:
1086                 dwarf_require_integral (value_type (result_val));
1087                 result_val = value_complement (result_val);
1088                 break;
1089               case DW_OP_plus_uconst:
1090                 dwarf_require_integral (value_type (result_val));
1091                 result = value_as_long (result_val);
1092                 op_ptr = read_uleb128 (op_ptr, op_end, &reg);
1093                 result += reg;
1094                 result_val = value_from_ulongest (address_type, result);
1095                 break;
1096               }
1097           }
1098           break;
1099
1100         case DW_OP_and:
1101         case DW_OP_div:
1102         case DW_OP_minus:
1103         case DW_OP_mod:
1104         case DW_OP_mul:
1105         case DW_OP_or:
1106         case DW_OP_plus:
1107         case DW_OP_shl:
1108         case DW_OP_shr:
1109         case DW_OP_shra:
1110         case DW_OP_xor:
1111         case DW_OP_le:
1112         case DW_OP_ge:
1113         case DW_OP_eq:
1114         case DW_OP_lt:
1115         case DW_OP_gt:
1116         case DW_OP_ne:
1117           {
1118             /* Binary operations.  */
1119             struct value *first, *second;
1120
1121             second = dwarf_expr_fetch (ctx, 0);
1122             dwarf_expr_pop (ctx);
1123
1124             first = dwarf_expr_fetch (ctx, 0);
1125             dwarf_expr_pop (ctx);
1126
1127             if (! base_types_equal_p (value_type (first), value_type (second)))
1128               error (_("Incompatible types on DWARF stack"));
1129
1130             switch (op)
1131               {
1132               case DW_OP_and:
1133                 dwarf_require_integral (value_type (first));
1134                 dwarf_require_integral (value_type (second));
1135                 result_val = value_binop (first, second, BINOP_BITWISE_AND);
1136                 break;
1137               case DW_OP_div:
1138                 result_val = value_binop (first, second, BINOP_DIV);
1139                 break;
1140               case DW_OP_minus:
1141                 result_val = value_binop (first, second, BINOP_SUB);
1142                 break;
1143               case DW_OP_mod:
1144                 {
1145                   int cast_back = 0;
1146                   struct type *orig_type = value_type (first);
1147
1148                   /* We have to special-case "old-style" untyped values
1149                      -- these must have mod computed using unsigned
1150                      math.  */
1151                   if (orig_type == address_type)
1152                     {
1153                       struct type *utype
1154                         = get_unsigned_type (ctx->gdbarch, orig_type);
1155
1156                       cast_back = 1;
1157                       first = value_cast (utype, first);
1158                       second = value_cast (utype, second);
1159                     }
1160                   /* Note that value_binop doesn't handle float or
1161                      decimal float here.  This seems unimportant.  */
1162                   result_val = value_binop (first, second, BINOP_MOD);
1163                   if (cast_back)
1164                     result_val = value_cast (orig_type, result_val);
1165                 }
1166                 break;
1167               case DW_OP_mul:
1168                 result_val = value_binop (first, second, BINOP_MUL);
1169                 break;
1170               case DW_OP_or:
1171                 dwarf_require_integral (value_type (first));
1172                 dwarf_require_integral (value_type (second));
1173                 result_val = value_binop (first, second, BINOP_BITWISE_IOR);
1174                 break;
1175               case DW_OP_plus:
1176                 result_val = value_binop (first, second, BINOP_ADD);
1177                 break;
1178               case DW_OP_shl:
1179                 dwarf_require_integral (value_type (first));
1180                 dwarf_require_integral (value_type (second));
1181                 result_val = value_binop (first, second, BINOP_LSH);
1182                 break;
1183               case DW_OP_shr:
1184                 dwarf_require_integral (value_type (first));
1185                 dwarf_require_integral (value_type (second));
1186                 if (!TYPE_UNSIGNED (value_type (first)))
1187                   {
1188                     struct type *utype
1189                       = get_unsigned_type (ctx->gdbarch, value_type (first));
1190
1191                     first = value_cast (utype, first);
1192                   }
1193
1194                 result_val = value_binop (first, second, BINOP_RSH);
1195                 /* Make sure we wind up with the same type we started
1196                    with.  */
1197                 if (value_type (result_val) != value_type (second))
1198                   result_val = value_cast (value_type (second), result_val);
1199                 break;
1200               case DW_OP_shra:
1201                 dwarf_require_integral (value_type (first));
1202                 dwarf_require_integral (value_type (second));
1203                 if (TYPE_UNSIGNED (value_type (first)))
1204                   {
1205                     struct type *stype
1206                       = get_signed_type (ctx->gdbarch, value_type (first));
1207
1208                     first = value_cast (stype, first);
1209                   }
1210
1211                 result_val = value_binop (first, second, BINOP_RSH);
1212                 /* Make sure we wind up with the same type we started
1213                    with.  */
1214                 if (value_type (result_val) != value_type (second))
1215                   result_val = value_cast (value_type (second), result_val);
1216                 break;
1217               case DW_OP_xor:
1218                 dwarf_require_integral (value_type (first));
1219                 dwarf_require_integral (value_type (second));
1220                 result_val = value_binop (first, second, BINOP_BITWISE_XOR);
1221                 break;
1222               case DW_OP_le:
1223                 /* A <= B is !(B < A).  */
1224                 result = ! value_less (second, first);
1225                 result_val = value_from_ulongest (address_type, result);
1226                 break;
1227               case DW_OP_ge:
1228                 /* A >= B is !(A < B).  */
1229                 result = ! value_less (first, second);
1230                 result_val = value_from_ulongest (address_type, result);
1231                 break;
1232               case DW_OP_eq:
1233                 result = value_equal (first, second);
1234                 result_val = value_from_ulongest (address_type, result);
1235                 break;
1236               case DW_OP_lt:
1237                 result = value_less (first, second);
1238                 result_val = value_from_ulongest (address_type, result);
1239                 break;
1240               case DW_OP_gt:
1241                 /* A > B is B < A.  */
1242                 result = value_less (second, first);
1243                 result_val = value_from_ulongest (address_type, result);
1244                 break;
1245               case DW_OP_ne:
1246                 result = ! value_equal (first, second);
1247                 result_val = value_from_ulongest (address_type, result);
1248                 break;
1249               default:
1250                 internal_error (__FILE__, __LINE__,
1251                                 _("Can't be reached."));
1252               }
1253           }
1254           break;
1255
1256         case DW_OP_call_frame_cfa:
1257           result = (ctx->funcs->get_frame_cfa) (ctx->baton);
1258           result_val = value_from_ulongest (address_type, result);
1259           in_stack_memory = 1;
1260           break;
1261
1262         case DW_OP_GNU_push_tls_address:
1263           /* Variable is at a constant offset in the thread-local
1264           storage block into the objfile for the current thread and
1265           the dynamic linker module containing this expression.  Here
1266           we return returns the offset from that base.  The top of the
1267           stack has the offset from the beginning of the thread
1268           control block at which the variable is located.  Nothing
1269           should follow this operator, so the top of stack would be
1270           returned.  */
1271           result = value_as_long (dwarf_expr_fetch (ctx, 0));
1272           dwarf_expr_pop (ctx);
1273           result = (ctx->funcs->get_tls_address) (ctx->baton, result);
1274           result_val = value_from_ulongest (address_type, result);
1275           break;
1276
1277         case DW_OP_skip:
1278           offset = extract_signed_integer (op_ptr, 2, byte_order);
1279           op_ptr += 2;
1280           op_ptr += offset;
1281           goto no_push;
1282
1283         case DW_OP_bra:
1284           {
1285             struct value *val;
1286
1287             offset = extract_signed_integer (op_ptr, 2, byte_order);
1288             op_ptr += 2;
1289             val = dwarf_expr_fetch (ctx, 0);
1290             dwarf_require_integral (value_type (val));
1291             if (value_as_long (val) != 0)
1292               op_ptr += offset;
1293             dwarf_expr_pop (ctx);
1294           }
1295           goto no_push;
1296
1297         case DW_OP_nop:
1298           goto no_push;
1299
1300         case DW_OP_piece:
1301           {
1302             ULONGEST size;
1303
1304             /* Record the piece.  */
1305             op_ptr = read_uleb128 (op_ptr, op_end, &size);
1306             add_piece (ctx, 8 * size, 0);
1307
1308             /* Pop off the address/regnum, and reset the location
1309                type.  */
1310             if (ctx->location != DWARF_VALUE_LITERAL
1311                 && ctx->location != DWARF_VALUE_OPTIMIZED_OUT)
1312               dwarf_expr_pop (ctx);
1313             ctx->location = DWARF_VALUE_MEMORY;
1314           }
1315           goto no_push;
1316
1317         case DW_OP_bit_piece:
1318           {
1319             ULONGEST size, offset;
1320
1321             /* Record the piece.  */
1322             op_ptr = read_uleb128 (op_ptr, op_end, &size);
1323             op_ptr = read_uleb128 (op_ptr, op_end, &offset);
1324             add_piece (ctx, size, offset);
1325
1326             /* Pop off the address/regnum, and reset the location
1327                type.  */
1328             if (ctx->location != DWARF_VALUE_LITERAL
1329                 && ctx->location != DWARF_VALUE_OPTIMIZED_OUT)
1330               dwarf_expr_pop (ctx);
1331             ctx->location = DWARF_VALUE_MEMORY;
1332           }
1333           goto no_push;
1334
1335         case DW_OP_GNU_uninit:
1336           if (op_ptr != op_end)
1337             error (_("DWARF-2 expression error: DW_OP_GNU_uninit must always "
1338                    "be the very last op."));
1339
1340           ctx->initialized = 0;
1341           goto no_push;
1342
1343         case DW_OP_call2:
1344           {
1345             cu_offset offset;
1346
1347             offset.cu_off = extract_unsigned_integer (op_ptr, 2, byte_order);
1348             op_ptr += 2;
1349             ctx->funcs->dwarf_call (ctx, offset);
1350           }
1351           goto no_push;
1352
1353         case DW_OP_call4:
1354           {
1355             cu_offset offset;
1356
1357             offset.cu_off = extract_unsigned_integer (op_ptr, 4, byte_order);
1358             op_ptr += 4;
1359             ctx->funcs->dwarf_call (ctx, offset);
1360           }
1361           goto no_push;
1362
1363         case DW_OP_GNU_entry_value:
1364           {
1365             ULONGEST len;
1366             int dwarf_reg;
1367             CORE_ADDR deref_size;
1368
1369             op_ptr = read_uleb128 (op_ptr, op_end, &len);
1370             if (op_ptr + len > op_end)
1371               error (_("DW_OP_GNU_entry_value: too few bytes available."));
1372
1373             dwarf_reg = dwarf_block_to_dwarf_reg (op_ptr, op_ptr + len);
1374             if (dwarf_reg != -1)
1375               {
1376                 op_ptr += len;
1377                 ctx->funcs->push_dwarf_reg_entry_value (ctx, dwarf_reg,
1378                                                         0 /* unused */,
1379                                                         -1 /* deref_size */);
1380                 goto no_push;
1381               }
1382
1383             dwarf_reg = dwarf_block_to_dwarf_reg_deref (op_ptr, op_ptr + len,
1384                                                         &deref_size);
1385             if (dwarf_reg != -1)
1386               {
1387                 if (deref_size == -1)
1388                   deref_size = ctx->addr_size;
1389                 op_ptr += len;
1390                 ctx->funcs->push_dwarf_reg_entry_value (ctx, dwarf_reg,
1391                                                         0 /* unused */,
1392                                                         deref_size);
1393                 goto no_push;
1394               }
1395
1396             error (_("DWARF-2 expression error: DW_OP_GNU_entry_value is "
1397                      "supported only for single DW_OP_reg* "
1398                      "or for DW_OP_breg*(0)+DW_OP_deref*"));
1399           }
1400
1401         case DW_OP_GNU_const_type:
1402           {
1403             cu_offset type_die;
1404             int n;
1405             const gdb_byte *data;
1406             struct type *type;
1407
1408             op_ptr = read_uleb128 (op_ptr, op_end, &uoffset);
1409             type_die.cu_off = uoffset;
1410             n = *op_ptr++;
1411             data = op_ptr;
1412             op_ptr += n;
1413
1414             type = dwarf_get_base_type (ctx, type_die, n);
1415             result_val = value_from_contents (type, data);
1416           }
1417           break;
1418
1419         case DW_OP_GNU_regval_type:
1420           {
1421             cu_offset type_die;
1422             struct type *type;
1423
1424             op_ptr = read_uleb128 (op_ptr, op_end, &reg);
1425             op_ptr = read_uleb128 (op_ptr, op_end, &uoffset);
1426             type_die.cu_off = uoffset;
1427
1428             type = dwarf_get_base_type (ctx, type_die, 0);
1429             result = (ctx->funcs->read_reg) (ctx->baton, reg);
1430             result_val = value_from_ulongest (address_type, result);
1431             result_val = value_from_contents (type,
1432                                               value_contents_all (result_val));
1433           }
1434           break;
1435
1436         case DW_OP_GNU_convert:
1437         case DW_OP_GNU_reinterpret:
1438           {
1439             cu_offset type_die;
1440             struct type *type;
1441
1442             op_ptr = read_uleb128 (op_ptr, op_end, &uoffset);
1443             type_die.cu_off = uoffset;
1444
1445             if (type_die.cu_off == 0)
1446               type = address_type;
1447             else
1448               type = dwarf_get_base_type (ctx, type_die, 0);
1449
1450             result_val = dwarf_expr_fetch (ctx, 0);
1451             dwarf_expr_pop (ctx);
1452
1453             if (op == DW_OP_GNU_convert)
1454               result_val = value_cast (type, result_val);
1455             else if (type == value_type (result_val))
1456               {
1457                 /* Nothing.  */
1458               }
1459             else if (TYPE_LENGTH (type)
1460                      != TYPE_LENGTH (value_type (result_val)))
1461               error (_("DW_OP_GNU_reinterpret has wrong size"));
1462             else
1463               result_val
1464                 = value_from_contents (type,
1465                                        value_contents_all (result_val));
1466           }
1467           break;
1468
1469         default:
1470           error (_("Unhandled dwarf expression opcode 0x%x"), op);
1471         }
1472
1473       /* Most things push a result value.  */
1474       gdb_assert (result_val != NULL);
1475       dwarf_expr_push (ctx, result_val, in_stack_memory);
1476     no_push:
1477       ;
1478     }
1479
1480   /* To simplify our main caller, if the result is an implicit
1481      pointer, then make a pieced value.  This is ok because we can't
1482      have implicit pointers in contexts where pieces are invalid.  */
1483   if (ctx->location == DWARF_VALUE_IMPLICIT_POINTER)
1484     add_piece (ctx, 8 * ctx->addr_size, 0);
1485
1486 abort_expression:
1487   ctx->recursion_depth--;
1488   gdb_assert (ctx->recursion_depth >= 0);
1489 }
1490
1491 /* Stub dwarf_expr_context_funcs.get_frame_base implementation.  */
1492
1493 void
1494 ctx_no_get_frame_base (void *baton, const gdb_byte **start, size_t *length)
1495 {
1496   error (_("%s is invalid in this context"), "DW_OP_fbreg");
1497 }
1498
1499 /* Stub dwarf_expr_context_funcs.get_frame_cfa implementation.  */
1500
1501 CORE_ADDR
1502 ctx_no_get_frame_cfa (void *baton)
1503 {
1504   error (_("%s is invalid in this context"), "DW_OP_call_frame_cfa");
1505 }
1506
1507 /* Stub dwarf_expr_context_funcs.get_frame_pc implementation.  */
1508
1509 CORE_ADDR
1510 ctx_no_get_frame_pc (void *baton)
1511 {
1512   error (_("%s is invalid in this context"), "DW_OP_GNU_implicit_pointer");
1513 }
1514
1515 /* Stub dwarf_expr_context_funcs.get_tls_address implementation.  */
1516
1517 CORE_ADDR
1518 ctx_no_get_tls_address (void *baton, CORE_ADDR offset)
1519 {
1520   error (_("%s is invalid in this context"), "DW_OP_GNU_push_tls_address");
1521 }
1522
1523 /* Stub dwarf_expr_context_funcs.dwarf_call implementation.  */
1524
1525 void
1526 ctx_no_dwarf_call (struct dwarf_expr_context *ctx, cu_offset die_offset)
1527 {
1528   error (_("%s is invalid in this context"), "DW_OP_call*");
1529 }
1530
1531 /* Stub dwarf_expr_context_funcs.get_base_type implementation.  */
1532
1533 struct type *
1534 ctx_no_get_base_type (struct dwarf_expr_context *ctx, cu_offset die)
1535 {
1536   error (_("Support for typed DWARF is not supported in this context"));
1537 }
1538
1539 /* Stub dwarf_expr_context_funcs.push_dwarf_block_entry_value
1540    implementation.  */
1541
1542 void
1543 ctx_no_push_dwarf_reg_entry_value (struct dwarf_expr_context *ctx,
1544                                    int dwarf_reg, CORE_ADDR fb_offset,
1545                                    int deref_size)
1546 {
1547   internal_error (__FILE__, __LINE__,
1548                   _("Support for DW_OP_GNU_entry_value is unimplemented"));
1549 }
1550
1551 /* Stub dwarf_expr_context_funcs.get_addr_index implementation.  */
1552
1553 CORE_ADDR
1554 ctx_no_get_addr_index (void *baton, unsigned int index)
1555 {
1556   error (_("%s is invalid in this context"), "DW_OP_GNU_addr_index");
1557 }
1558
1559 /* Provide a prototype to silence -Wmissing-prototypes.  */
1560 extern initialize_file_ftype _initialize_dwarf2expr;
1561
1562 void
1563 _initialize_dwarf2expr (void)
1564 {
1565   dwarf_arch_cookie
1566     = gdbarch_data_register_post_init (dwarf_gdbarch_types_init);
1567 }