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 /* Helper to read a uleb128 value or throw an error.  */
 373
 374 const gdb_byte *
 375 safe_read_uleb128 (const gdb_byte *buf, const gdb_byte *buf_end,
 376                    uint64_t *r)
 377 {
 378   buf = gdb_read_uleb128 (buf, buf_end, r);
 379   if (buf == NULL)
 380     error (_("DWARF expression error: ran off end of buffer reading uleb128 value"));
 381   return buf;
 382 }
 383
 384 /* Helper to read a sleb128 value or throw an error.  */
 385
 386 const gdb_byte *
 387 safe_read_sleb128 (const gdb_byte *buf, const gdb_byte *buf_end,
 388                    int64_t *r)
 389 {
 390   buf = gdb_read_sleb128 (buf, buf_end, r);
 391   if (buf == NULL)
 392     error (_("DWARF expression error: ran off end of buffer reading sleb128 value"));
 393   return buf;
 394 }
 395
 396 const gdb_byte *
 397 safe_skip_leb128 (const gdb_byte *buf, const gdb_byte *buf_end)
 398 {
 399   buf = gdb_skip_leb128 (buf, buf_end);
 400   if (buf == NULL)
 401     error (_("DWARF expression error: ran off end of buffer reading leb128 value"));
 402   return buf;
 403 }
 404 \f
 405
 406 /* Check that the current operator is either at the end of an
 407    expression, or that it is followed by a composition operator.  */
 408
 409 void
 410 dwarf_expr_require_composition (const gdb_byte *op_ptr, const gdb_byte *op_end,
 411                                 const char *op_name)
 412 {
 413   /* It seems like DW_OP_GNU_uninit should be handled here.  However,
 414      it doesn't seem to make sense for DW_OP_*_value, and it was not
 415      checked at the other place that this function is called.  */
 416   if (op_ptr != op_end && *op_ptr != DW_OP_piece && *op_ptr != DW_OP_bit_piece)
 417     error (_("DWARF-2 expression error: `%s' operations must be "
 418              "used either alone or in conjunction with DW_OP_piece "
 419              "or DW_OP_bit_piece."),
 420            op_name);
 421 }
 422
 423 /* Return true iff the types T1 and T2 are "the same".  This only does
 424    checks that might reasonably be needed to compare DWARF base
 425    types.  */
 426
 427 static int
 428 base_types_equal_p (struct type *t1, struct type *t2)
 429 {
 430   if (TYPE_CODE (t1) != TYPE_CODE (t2))
 431     return 0;
 432   if (TYPE_UNSIGNED (t1) != TYPE_UNSIGNED (t2))
 433     return 0;
 434   return TYPE_LENGTH (t1) == TYPE_LENGTH (t2);
 435 }
 436
 437 /* A convenience function to call get_base_type on CTX and return the
 438    result.  DIE is the DIE whose type we need.  SIZE is non-zero if
 439    this function should verify that the resulting type has the correct
 440    size.  */
 441
 442 static struct type *
 443 dwarf_get_base_type (struct dwarf_expr_context *ctx, cu_offset die, int size)
 444 {
 445   struct type *result;
 446
 447   if (ctx->funcs->get_base_type)
 448     {
 449       result = ctx->funcs->get_base_type (ctx, die);
 450       if (result == NULL)
 451         error (_("Could not find type for DW_OP_GNU_const_type"));
 452       if (size != 0 && TYPE_LENGTH (result) != size)
 453         error (_("DW_OP_GNU_const_type has different sizes for type and data"));
 454     }
 455   else
 456     /* Anything will do.  */
 457     result = builtin_type (ctx->gdbarch)->builtin_int;
 458
 459   return result;
 460 }
 461
 462 /* If <BUF..BUF_END] contains DW_FORM_block* with single DW_OP_reg* return the
 463    DWARF register number.  Otherwise return -1.  */
 464
 465 int
 466 dwarf_block_to_dwarf_reg (const gdb_byte *buf, const gdb_byte *buf_end)
 467 {
 468   uint64_t dwarf_reg;
 469
 470   if (buf_end <= buf)
 471     return -1;
 472   if (*buf >= DW_OP_reg0 && *buf <= DW_OP_reg31)
 473     {
 474       if (buf_end - buf != 1)
 475         return -1;
 476       return *buf - DW_OP_reg0;
 477     }
 478
 479   if (*buf == DW_OP_GNU_regval_type)
 480     {
 481       buf++;
 482       buf = gdb_read_uleb128 (buf, buf_end, &dwarf_reg);
 483       if (buf == NULL)
 484         return -1;
 485       buf = gdb_skip_leb128 (buf, buf_end);
 486       if (buf == NULL)
 487         return -1;
 488     }
 489   else if (*buf == DW_OP_regx)
 490     {
 491       buf++;
 492       buf = gdb_read_uleb128 (buf, buf_end, &dwarf_reg);
 493       if (buf == NULL)
 494         return -1;
 495     }
 496   else
 497     return -1;
 498   if (buf != buf_end || (int) dwarf_reg != dwarf_reg)
 499     return -1;
 500   return dwarf_reg;
 501 }
 502
 503 /* If <BUF..BUF_END] contains DW_FORM_block* with just DW_OP_breg*(0) and
 504    DW_OP_deref* return the DWARF register number.  Otherwise return -1.
 505    DEREF_SIZE_RETURN contains -1 for DW_OP_deref; otherwise it contains the
 506    size from DW_OP_deref_size.  */
 507
 508 int
 509 dwarf_block_to_dwarf_reg_deref (const gdb_byte *buf, const gdb_byte *buf_end,
 510                                 CORE_ADDR *deref_size_return)
 511 {
 512   uint64_t dwarf_reg;
 513   int64_t offset;
 514
 515   if (buf_end <= buf)
 516     return -1;
 517
 518   if (*buf >= DW_OP_breg0 && *buf <= DW_OP_breg31)
 519     {
 520       dwarf_reg = *buf - DW_OP_breg0;
 521       buf++;
 522       if (buf >= buf_end)
 523         return -1;
 524     }
 525   else if (*buf == DW_OP_bregx)
 526     {
 527       buf++;
 528       buf = gdb_read_uleb128 (buf, buf_end, &dwarf_reg);
 529       if (buf == NULL)
 530         return -1;
 531       if ((int) dwarf_reg != dwarf_reg)
 532        return -1;
 533     }
 534   else
 535     return -1;
 536
 537   buf = gdb_read_sleb128 (buf, buf_end, &offset);
 538   if (buf == NULL)
 539     return -1;
 540   if (offset != 0)
 541     return -1;
 542
 543   if (*buf == DW_OP_deref)
 544     {
 545       buf++;
 546       *deref_size_return = -1;
 547     }
 548   else if (*buf == DW_OP_deref_size)
 549     {
 550       buf++;
 551       if (buf >= buf_end)
 552        return -1;
 553       *deref_size_return = *buf++;
 554     }
 555   else
 556     return -1;
 557
 558   if (buf != buf_end)
 559     return -1;
 560
 561   return dwarf_reg;
 562 }
 563
 564 /* If <BUF..BUF_END] contains DW_FORM_block* with single DW_OP_fbreg(X) fill
 565    in FB_OFFSET_RETURN with the X offset and return 1.  Otherwise return 0.  */
 566
 567 int
 568 dwarf_block_to_fb_offset (const gdb_byte *buf, const gdb_byte *buf_end,
 569                           CORE_ADDR *fb_offset_return)
 570 {
 571   int64_t fb_offset;
 572
 573   if (buf_end <= buf)
 574     return 0;
 575
 576   if (*buf != DW_OP_fbreg)
 577     return 0;
 578   buf++;
 579
 580   buf = gdb_read_sleb128 (buf, buf_end, &fb_offset);
 581   if (buf == NULL)
 582     return 0;
 583   *fb_offset_return = fb_offset;
 584   if (buf != buf_end || fb_offset != (LONGEST) *fb_offset_return)
 585     return 0;
 586
 587   return 1;
 588 }
 589
 590 /* If <BUF..BUF_END] contains DW_FORM_block* with single DW_OP_bregSP(X) fill
 591    in SP_OFFSET_RETURN with the X offset and return 1.  Otherwise return 0.
 592    The matched SP register number depends on GDBARCH.  */
 593
 594 int
 595 dwarf_block_to_sp_offset (struct gdbarch *gdbarch, const gdb_byte *buf,
 596                           const gdb_byte *buf_end, CORE_ADDR *sp_offset_return)
 597 {
 598   uint64_t dwarf_reg;
 599   int64_t sp_offset;
 600
 601   if (buf_end <= buf)
 602     return 0;
 603   if (*buf >= DW_OP_breg0 && *buf <= DW_OP_breg31)
 604     {
 605       dwarf_reg = *buf - DW_OP_breg0;
 606       buf++;
 607     }
 608   else
 609     {
 610       if (*buf != DW_OP_bregx)
 611        return 0;
 612       buf++;
 613       buf = gdb_read_uleb128 (buf, buf_end, &dwarf_reg);
 614       if (buf == NULL)
 615         return 0;
 616     }
 617
 618   if (gdbarch_dwarf2_reg_to_regnum (gdbarch, dwarf_reg)
 619       != gdbarch_sp_regnum (gdbarch))
 620     return 0;
 621
 622   buf = gdb_read_sleb128 (buf, buf_end, &sp_offset);
 623   if (buf == NULL)
 624     return 0;
 625   *sp_offset_return = sp_offset;
 626   if (buf != buf_end || sp_offset != (LONGEST) *sp_offset_return)
 627     return 0;
 628
 629   return 1;
 630 }
 631
 632 /* The engine for the expression evaluator.  Using the context in CTX,
 633    evaluate the expression between OP_PTR and OP_END.  */
 634
 635 static void
 636 execute_stack_op (struct dwarf_expr_context *ctx,
 637                   const gdb_byte *op_ptr, const gdb_byte *op_end)
 638 {
 639   enum bfd_endian byte_order = gdbarch_byte_order (ctx->gdbarch);
 640   /* Old-style "untyped" DWARF values need special treatment in a
 641      couple of places, specifically DW_OP_mod and DW_OP_shr.  We need
 642      a special type for these values so we can distinguish them from
 643      values that have an explicit type, because explicitly-typed
 644      values do not need special treatment.  This special type must be
 645      different (in the `==' sense) from any base type coming from the
 646      CU.  */
 647   struct type *address_type = dwarf_expr_address_type (ctx);
 648
 649   ctx->location = DWARF_VALUE_MEMORY;
 650   ctx->initialized = 1;  /* Default is initialized.  */
 651
 652   if (ctx->recursion_depth > ctx->max_recursion_depth)
 653     error (_("DWARF-2 expression error: Loop detected (%d)."),
 654            ctx->recursion_depth);
 655   ctx->recursion_depth++;
 656
 657   while (op_ptr < op_end)
 658     {
 659       enum dwarf_location_atom op = *op_ptr++;
 660       ULONGEST result;
 661       /* Assume the value is not in stack memory.
 662          Code that knows otherwise sets this to 1.
 663          Some arithmetic on stack addresses can probably be assumed to still
 664          be a stack address, but we skip this complication for now.
 665          This is just an optimization, so it's always ok to punt
 666          and leave this as 0.  */
 667       int in_stack_memory = 0;
 668       uint64_t uoffset, reg;
 669       int64_t offset;
 670       struct value *result_val = NULL;
 671
 672       /* The DWARF expression might have a bug causing an infinite
 673          loop.  In that case, quitting is the only way out.  */
 674       QUIT;
 675
 676       switch (op)
 677         {
 678         case DW_OP_lit0:
 679         case DW_OP_lit1:
 680         case DW_OP_lit2:
 681         case DW_OP_lit3:
 682         case DW_OP_lit4:
 683         case DW_OP_lit5:
 684         case DW_OP_lit6:
 685         case DW_OP_lit7:
 686         case DW_OP_lit8:
 687         case DW_OP_lit9:
 688         case DW_OP_lit10:
 689         case DW_OP_lit11:
 690         case DW_OP_lit12:
 691         case DW_OP_lit13:
 692         case DW_OP_lit14:
 693         case DW_OP_lit15:
 694         case DW_OP_lit16:
 695         case DW_OP_lit17:
 696         case DW_OP_lit18:
 697         case DW_OP_lit19:
 698         case DW_OP_lit20:
 699         case DW_OP_lit21:
 700         case DW_OP_lit22:
 701         case DW_OP_lit23:
 702         case DW_OP_lit24:
 703         case DW_OP_lit25:
 704         case DW_OP_lit26:
 705         case DW_OP_lit27:
 706         case DW_OP_lit28:
 707         case DW_OP_lit29:
 708         case DW_OP_lit30:
 709         case DW_OP_lit31:
 710           result = op - DW_OP_lit0;
 711           result_val = value_from_ulongest (address_type, result);
 712           break;
 713
 714         case DW_OP_addr:
 715           result = extract_unsigned_integer (op_ptr,
 716                                              ctx->addr_size, byte_order);
 717           op_ptr += ctx->addr_size;
 718           /* Some versions of GCC emit DW_OP_addr before
 719              DW_OP_GNU_push_tls_address.  In this case the value is an
 720              index, not an address.  We don't support things like
 721              branching between the address and the TLS op.  */
 722           if (op_ptr >= op_end || *op_ptr != DW_OP_GNU_push_tls_address)
 723             result += ctx->offset;
 724           result_val = value_from_ulongest (address_type, result);
 725           break;
 726
 727         case DW_OP_GNU_addr_index:
 728           op_ptr = safe_read_uleb128 (op_ptr, op_end, &uoffset);
 729           result = (ctx->funcs->get_addr_index) (ctx->baton, uoffset);
 730           result_val = value_from_ulongest (address_type, result);
 731           break;
 732
 733         case DW_OP_const1u:
 734           result = extract_unsigned_integer (op_ptr, 1, byte_order);
 735           result_val = value_from_ulongest (address_type, result);
 736           op_ptr += 1;
 737           break;
 738         case DW_OP_const1s:
 739           result = extract_signed_integer (op_ptr, 1, byte_order);
 740           result_val = value_from_ulongest (address_type, result);
 741           op_ptr += 1;
 742           break;
 743         case DW_OP_const2u:
 744           result = extract_unsigned_integer (op_ptr, 2, byte_order);
 745           result_val = value_from_ulongest (address_type, result);
 746           op_ptr += 2;
 747           break;
 748         case DW_OP_const2s:
 749           result = extract_signed_integer (op_ptr, 2, byte_order);
 750           result_val = value_from_ulongest (address_type, result);
 751           op_ptr += 2;
 752           break;
 753         case DW_OP_const4u:
 754           result = extract_unsigned_integer (op_ptr, 4, byte_order);
 755           result_val = value_from_ulongest (address_type, result);
 756           op_ptr += 4;
 757           break;
 758         case DW_OP_const4s:
 759           result = extract_signed_integer (op_ptr, 4, byte_order);
 760           result_val = value_from_ulongest (address_type, result);
 761           op_ptr += 4;
 762           break;
 763         case DW_OP_const8u:
 764           result = extract_unsigned_integer (op_ptr, 8, byte_order);
 765           result_val = value_from_ulongest (address_type, result);
 766           op_ptr += 8;
 767           break;
 768         case DW_OP_const8s:
 769           result = extract_signed_integer (op_ptr, 8, byte_order);
 770           result_val = value_from_ulongest (address_type, result);
 771           op_ptr += 8;
 772           break;
 773         case DW_OP_constu:
 774           op_ptr = safe_read_uleb128 (op_ptr, op_end, &uoffset);
 775           result = uoffset;
 776           result_val = value_from_ulongest (address_type, result);
 777           break;
 778         case DW_OP_consts:
 779           op_ptr = safe_read_sleb128 (op_ptr, op_end, &offset);
 780           result = offset;
 781           result_val = value_from_ulongest (address_type, result);
 782           break;
 783
 784         /* The DW_OP_reg operations are required to occur alone in
 785            location expressions.  */
 786         case DW_OP_reg0:
 787         case DW_OP_reg1:
 788         case DW_OP_reg2:
 789         case DW_OP_reg3:
 790         case DW_OP_reg4:
 791         case DW_OP_reg5:
 792         case DW_OP_reg6:
 793         case DW_OP_reg7:
 794         case DW_OP_reg8:
 795         case DW_OP_reg9:
 796         case DW_OP_reg10:
 797         case DW_OP_reg11:
 798         case DW_OP_reg12:
 799         case DW_OP_reg13:
 800         case DW_OP_reg14:
 801         case DW_OP_reg15:
 802         case DW_OP_reg16:
 803         case DW_OP_reg17:
 804         case DW_OP_reg18:
 805         case DW_OP_reg19:
 806         case DW_OP_reg20:
 807         case DW_OP_reg21:
 808         case DW_OP_reg22:
 809         case DW_OP_reg23:
 810         case DW_OP_reg24:
 811         case DW_OP_reg25:
 812         case DW_OP_reg26:
 813         case DW_OP_reg27:
 814         case DW_OP_reg28:
 815         case DW_OP_reg29:
 816         case DW_OP_reg30:
 817         case DW_OP_reg31:
 818           if (op_ptr != op_end
 819               && *op_ptr != DW_OP_piece
 820               && *op_ptr != DW_OP_bit_piece
 821               && *op_ptr != DW_OP_GNU_uninit)
 822             error (_("DWARF-2 expression error: DW_OP_reg operations must be "
 823                      "used either alone or in conjunction with DW_OP_piece "
 824                      "or DW_OP_bit_piece."));
 825
 826           result = op - DW_OP_reg0;
 827           result_val = value_from_ulongest (address_type, result);
 828           ctx->location = DWARF_VALUE_REGISTER;
 829           break;
 830
 831         case DW_OP_regx:
 832           op_ptr = safe_read_uleb128 (op_ptr, op_end, &reg);
 833           dwarf_expr_require_composition (op_ptr, op_end, "DW_OP_regx");
 834
 835           result = reg;
 836           result_val = value_from_ulongest (address_type, result);
 837           ctx->location = DWARF_VALUE_REGISTER;
 838           break;
 839
 840         case DW_OP_implicit_value:
 841           {
 842             uint64_t len;
 843
 844             op_ptr = safe_read_uleb128 (op_ptr, op_end, &len);
 845             if (op_ptr + len > op_end)
 846               error (_("DW_OP_implicit_value: too few bytes available."));
 847             ctx->len = len;
 848             ctx->data = op_ptr;
 849             ctx->location = DWARF_VALUE_LITERAL;
 850             op_ptr += len;
 851             dwarf_expr_require_composition (op_ptr, op_end,
 852                                             "DW_OP_implicit_value");
 853           }
 854           goto no_push;
 855
 856         case DW_OP_stack_value:
 857           ctx->location = DWARF_VALUE_STACK;
 858           dwarf_expr_require_composition (op_ptr, op_end, "DW_OP_stack_value");
 859           goto no_push;
 860
 861         case DW_OP_GNU_implicit_pointer:
 862           {
 863             int64_t len;
 864
 865             if (ctx->ref_addr_size == -1)
 866               error (_("DWARF-2 expression error: DW_OP_GNU_implicit_pointer "
 867                        "is not allowed in frame context"));
 868
 869             /* The referred-to DIE of cu_offset kind.  */
 870             ctx->len = extract_unsigned_integer (op_ptr, ctx->ref_addr_size,
 871                                                  byte_order);
 872             op_ptr += ctx->ref_addr_size;
 873
 874             /* The byte offset into the data.  */
 875             op_ptr = safe_read_sleb128 (op_ptr, op_end, &len);
 876             result = (ULONGEST) len;
 877             result_val = value_from_ulongest (address_type, result);
 878
 879             ctx->location = DWARF_VALUE_IMPLICIT_POINTER;
 880             dwarf_expr_require_composition (op_ptr, op_end,
 881                                             "DW_OP_GNU_implicit_pointer");
 882           }
 883           break;
 884
 885         case DW_OP_breg0:
 886         case DW_OP_breg1:
 887         case DW_OP_breg2:
 888         case DW_OP_breg3:
 889         case DW_OP_breg4:
 890         case DW_OP_breg5:
 891         case DW_OP_breg6:
 892         case DW_OP_breg7:
 893         case DW_OP_breg8:
 894         case DW_OP_breg9:
 895         case DW_OP_breg10:
 896         case DW_OP_breg11:
 897         case DW_OP_breg12:
 898         case DW_OP_breg13:
 899         case DW_OP_breg14:
 900         case DW_OP_breg15:
 901         case DW_OP_breg16:
 902         case DW_OP_breg17:
 903         case DW_OP_breg18:
 904         case DW_OP_breg19:
 905         case DW_OP_breg20:
 906         case DW_OP_breg21:
 907         case DW_OP_breg22:
 908         case DW_OP_breg23:
 909         case DW_OP_breg24:
 910         case DW_OP_breg25:
 911         case DW_OP_breg26:
 912         case DW_OP_breg27:
 913         case DW_OP_breg28:
 914         case DW_OP_breg29:
 915         case DW_OP_breg30:
 916         case DW_OP_breg31:
 917           {
 918             op_ptr = safe_read_sleb128 (op_ptr, op_end, &offset);
 919             result = (ctx->funcs->read_reg) (ctx->baton, op - DW_OP_breg0);
 920             result += offset;
 921             result_val = value_from_ulongest (address_type, result);
 922           }
 923           break;
 924         case DW_OP_bregx:
 925           {
 926             op_ptr = safe_read_uleb128 (op_ptr, op_end, &reg);
 927             op_ptr = safe_read_sleb128 (op_ptr, op_end, &offset);
 928             result = (ctx->funcs->read_reg) (ctx->baton, reg);
 929             result += offset;
 930             result_val = value_from_ulongest (address_type, result);
 931           }
 932           break;
 933         case DW_OP_fbreg:
 934           {
 935             const gdb_byte *datastart;
 936             size_t datalen;
 937             unsigned int before_stack_len;
 938
 939             op_ptr = safe_read_sleb128 (op_ptr, op_end, &offset);
 940             /* Rather than create a whole new context, we simply
 941                record the stack length before execution, then reset it
 942                afterwards, effectively erasing whatever the recursive
 943                call put there.  */
 944             before_stack_len = ctx->stack_len;
 945             /* FIXME: cagney/2003-03-26: This code should be using
 946                get_frame_base_address(), and then implement a dwarf2
 947                specific this_base method.  */
 948             (ctx->funcs->get_frame_base) (ctx->baton, &datastart, &datalen);
 949             dwarf_expr_eval (ctx, datastart, datalen);
 950             if (ctx->location == DWARF_VALUE_MEMORY)
 951               result = dwarf_expr_fetch_address (ctx, 0);
 952             else if (ctx->location == DWARF_VALUE_REGISTER)
 953               result = (ctx->funcs->read_reg) (ctx->baton,
 954                                      value_as_long (dwarf_expr_fetch (ctx, 0)));
 955             else
 956               error (_("Not implemented: computing frame "
 957                        "base using explicit value operator"));
 958             result = result + offset;
 959             result_val = value_from_ulongest (address_type, result);
 960             in_stack_memory = 1;
 961             ctx->stack_len = before_stack_len;
 962             ctx->location = DWARF_VALUE_MEMORY;
 963           }
 964           break;
 965
 966         case DW_OP_dup:
 967           result_val = dwarf_expr_fetch (ctx, 0);
 968           in_stack_memory = dwarf_expr_fetch_in_stack_memory (ctx, 0);
 969           break;
 970
 971         case DW_OP_drop:
 972           dwarf_expr_pop (ctx);
 973           goto no_push;
 974
 975         case DW_OP_pick:
 976           offset = *op_ptr++;
 977           result_val = dwarf_expr_fetch (ctx, offset);
 978           in_stack_memory = dwarf_expr_fetch_in_stack_memory (ctx, offset);
 979           break;
 980
 981         case DW_OP_swap:
 982           {
 983             struct dwarf_stack_value t1, t2;
 984
 985             if (ctx->stack_len < 2)
 986                error (_("Not enough elements for "
 987                         "DW_OP_swap.  Need 2, have %d."),
 988                       ctx->stack_len);
 989             t1 = ctx->stack[ctx->stack_len - 1];
 990             t2 = ctx->stack[ctx->stack_len - 2];
 991             ctx->stack[ctx->stack_len - 1] = t2;
 992             ctx->stack[ctx->stack_len - 2] = t1;
 993             goto no_push;
 994           }
 995
 996         case DW_OP_over:
 997           result_val = dwarf_expr_fetch (ctx, 1);
 998           in_stack_memory = dwarf_expr_fetch_in_stack_memory (ctx, 1);
 999           break;
1000
1001         case DW_OP_rot:
1002           {
1003             struct dwarf_stack_value t1, t2, t3;
1004
1005             if (ctx->stack_len < 3)
1006                error (_("Not enough elements for "
1007                         "DW_OP_rot.  Need 3, have %d."),
1008                       ctx->stack_len);
1009             t1 = ctx->stack[ctx->stack_len - 1];
1010             t2 = ctx->stack[ctx->stack_len - 2];
1011             t3 = ctx->stack[ctx->stack_len - 3];
1012             ctx->stack[ctx->stack_len - 1] = t2;
1013             ctx->stack[ctx->stack_len - 2] = t3;
1014             ctx->stack[ctx->stack_len - 3] = t1;
1015             goto no_push;
1016           }
1017
1018         case DW_OP_deref:
1019         case DW_OP_deref_size:
1020         case DW_OP_GNU_deref_type:
1021           {
1022             int addr_size = (op == DW_OP_deref ? ctx->addr_size : *op_ptr++);
1023             gdb_byte *buf = alloca (addr_size);
1024             CORE_ADDR addr = dwarf_expr_fetch_address (ctx, 0);
1025             struct type *type;
1026
1027             dwarf_expr_pop (ctx);
1028
1029             if (op == DW_OP_GNU_deref_type)
1030               {
1031                 cu_offset type_die;
1032
1033                 op_ptr = safe_read_uleb128 (op_ptr, op_end, &uoffset);
1034                 type_die.cu_off = uoffset;
1035                 type = dwarf_get_base_type (ctx, type_die, 0);
1036               }
1037             else
1038               type = address_type;
1039
1040             (ctx->funcs->read_mem) (ctx->baton, buf, addr, addr_size);
1041
1042             /* If the size of the object read from memory is different
1043                from the type length, we need to zero-extend it.  */
1044             if (TYPE_LENGTH (type) != addr_size)
1045               {
1046                 ULONGEST result =
1047                   extract_unsigned_integer (buf, addr_size, byte_order);
1048
1049                 buf = alloca (TYPE_LENGTH (type));
1050                 store_unsigned_integer (buf, TYPE_LENGTH (type),
1051                                         byte_order, result);
1052               }
1053
1054             result_val = value_from_contents_and_address (type, buf, addr);
1055             break;
1056           }
1057
1058         case DW_OP_abs:
1059         case DW_OP_neg:
1060         case DW_OP_not:
1061         case DW_OP_plus_uconst:
1062           {
1063             /* Unary operations.  */
1064             result_val = dwarf_expr_fetch (ctx, 0);
1065             dwarf_expr_pop (ctx);
1066
1067             switch (op)
1068               {
1069               case DW_OP_abs:
1070                 if (value_less (result_val,
1071                                 value_zero (value_type (result_val), not_lval)))
1072                   result_val = value_neg (result_val);
1073                 break;
1074               case DW_OP_neg:
1075                 result_val = value_neg (result_val);
1076                 break;
1077               case DW_OP_not:
1078                 dwarf_require_integral (value_type (result_val));
1079                 result_val = value_complement (result_val);
1080                 break;
1081               case DW_OP_plus_uconst:
1082                 dwarf_require_integral (value_type (result_val));
1083                 result = value_as_long (result_val);
1084                 op_ptr = safe_read_uleb128 (op_ptr, op_end, &reg);
1085                 result += reg;
1086                 result_val = value_from_ulongest (address_type, result);
1087                 break;
1088               }
1089           }
1090           break;
1091
1092         case DW_OP_and:
1093         case DW_OP_div:
1094         case DW_OP_minus:
1095         case DW_OP_mod:
1096         case DW_OP_mul:
1097         case DW_OP_or:
1098         case DW_OP_plus:
1099         case DW_OP_shl:
1100         case DW_OP_shr:
1101         case DW_OP_shra:
1102         case DW_OP_xor:
1103         case DW_OP_le:
1104         case DW_OP_ge:
1105         case DW_OP_eq:
1106         case DW_OP_lt:
1107         case DW_OP_gt:
1108         case DW_OP_ne:
1109           {
1110             /* Binary operations.  */
1111             struct value *first, *second;
1112
1113             second = dwarf_expr_fetch (ctx, 0);
1114             dwarf_expr_pop (ctx);
1115
1116             first = dwarf_expr_fetch (ctx, 0);
1117             dwarf_expr_pop (ctx);
1118
1119             if (! base_types_equal_p (value_type (first), value_type (second)))
1120               error (_("Incompatible types on DWARF stack"));
1121
1122             switch (op)
1123               {
1124               case DW_OP_and:
1125                 dwarf_require_integral (value_type (first));
1126                 dwarf_require_integral (value_type (second));
1127                 result_val = value_binop (first, second, BINOP_BITWISE_AND);
1128                 break;
1129               case DW_OP_div:
1130                 result_val = value_binop (first, second, BINOP_DIV);
1131                 break;
1132               case DW_OP_minus:
1133                 result_val = value_binop (first, second, BINOP_SUB);
1134                 break;
1135               case DW_OP_mod:
1136                 {
1137                   int cast_back = 0;
1138                   struct type *orig_type = value_type (first);
1139
1140                   /* We have to special-case "old-style" untyped values
1141                      -- these must have mod computed using unsigned
1142                      math.  */
1143                   if (orig_type == address_type)
1144                     {
1145                       struct type *utype
1146                         = get_unsigned_type (ctx->gdbarch, orig_type);
1147
1148                       cast_back = 1;
1149                       first = value_cast (utype, first);
1150                       second = value_cast (utype, second);
1151                     }
1152                   /* Note that value_binop doesn't handle float or
1153                      decimal float here.  This seems unimportant.  */
1154                   result_val = value_binop (first, second, BINOP_MOD);
1155                   if (cast_back)
1156                     result_val = value_cast (orig_type, result_val);
1157                 }
1158                 break;
1159               case DW_OP_mul:
1160                 result_val = value_binop (first, second, BINOP_MUL);
1161                 break;
1162               case DW_OP_or:
1163                 dwarf_require_integral (value_type (first));
1164                 dwarf_require_integral (value_type (second));
1165                 result_val = value_binop (first, second, BINOP_BITWISE_IOR);
1166                 break;
1167               case DW_OP_plus:
1168                 result_val = value_binop (first, second, BINOP_ADD);
1169                 break;
1170               case DW_OP_shl:
1171                 dwarf_require_integral (value_type (first));
1172                 dwarf_require_integral (value_type (second));
1173                 result_val = value_binop (first, second, BINOP_LSH);
1174                 break;
1175               case DW_OP_shr:
1176                 dwarf_require_integral (value_type (first));
1177                 dwarf_require_integral (value_type (second));
1178                 if (!TYPE_UNSIGNED (value_type (first)))
1179                   {
1180                     struct type *utype
1181                       = get_unsigned_type (ctx->gdbarch, value_type (first));
1182
1183                     first = value_cast (utype, first);
1184                   }
1185
1186                 result_val = value_binop (first, second, BINOP_RSH);
1187                 /* Make sure we wind up with the same type we started
1188                    with.  */
1189                 if (value_type (result_val) != value_type (second))
1190                   result_val = value_cast (value_type (second), result_val);
1191                 break;
1192               case DW_OP_shra:
1193                 dwarf_require_integral (value_type (first));
1194                 dwarf_require_integral (value_type (second));
1195                 if (TYPE_UNSIGNED (value_type (first)))
1196                   {
1197                     struct type *stype
1198                       = get_signed_type (ctx->gdbarch, value_type (first));
1199
1200                     first = value_cast (stype, first);
1201                   }
1202
1203                 result_val = value_binop (first, second, BINOP_RSH);
1204                 /* Make sure we wind up with the same type we started
1205                    with.  */
1206                 if (value_type (result_val) != value_type (second))
1207                   result_val = value_cast (value_type (second), result_val);
1208                 break;
1209               case DW_OP_xor:
1210                 dwarf_require_integral (value_type (first));
1211                 dwarf_require_integral (value_type (second));
1212                 result_val = value_binop (first, second, BINOP_BITWISE_XOR);
1213                 break;
1214               case DW_OP_le:
1215                 /* A <= B is !(B < A).  */
1216                 result = ! value_less (second, first);
1217                 result_val = value_from_ulongest (address_type, result);
1218                 break;
1219               case DW_OP_ge:
1220                 /* A >= B is !(A < B).  */
1221                 result = ! value_less (first, second);
1222                 result_val = value_from_ulongest (address_type, result);
1223                 break;
1224               case DW_OP_eq:
1225                 result = value_equal (first, second);
1226                 result_val = value_from_ulongest (address_type, result);
1227                 break;
1228               case DW_OP_lt:
1229                 result = value_less (first, second);
1230                 result_val = value_from_ulongest (address_type, result);
1231                 break;
1232               case DW_OP_gt:
1233                 /* A > B is B < A.  */
1234                 result = value_less (second, first);
1235                 result_val = value_from_ulongest (address_type, result);
1236                 break;
1237               case DW_OP_ne:
1238                 result = ! value_equal (first, second);
1239                 result_val = value_from_ulongest (address_type, result);
1240                 break;
1241               default:
1242                 internal_error (__FILE__, __LINE__,
1243                                 _("Can't be reached."));
1244               }
1245           }
1246           break;
1247
1248         case DW_OP_call_frame_cfa:
1249           result = (ctx->funcs->get_frame_cfa) (ctx->baton);
1250           result_val = value_from_ulongest (address_type, result);
1251           in_stack_memory = 1;
1252           break;
1253
1254         case DW_OP_GNU_push_tls_address:
1255           /* Variable is at a constant offset in the thread-local
1256           storage block into the objfile for the current thread and
1257           the dynamic linker module containing this expression.  Here
1258           we return returns the offset from that base.  The top of the
1259           stack has the offset from the beginning of the thread
1260           control block at which the variable is located.  Nothing
1261           should follow this operator, so the top of stack would be
1262           returned.  */
1263           result = value_as_long (dwarf_expr_fetch (ctx, 0));
1264           dwarf_expr_pop (ctx);
1265           result = (ctx->funcs->get_tls_address) (ctx->baton, result);
1266           result_val = value_from_ulongest (address_type, result);
1267           break;
1268
1269         case DW_OP_skip:
1270           offset = extract_signed_integer (op_ptr, 2, byte_order);
1271           op_ptr += 2;
1272           op_ptr += offset;
1273           goto no_push;
1274
1275         case DW_OP_bra:
1276           {
1277             struct value *val;
1278
1279             offset = extract_signed_integer (op_ptr, 2, byte_order);
1280             op_ptr += 2;
1281             val = dwarf_expr_fetch (ctx, 0);
1282             dwarf_require_integral (value_type (val));
1283             if (value_as_long (val) != 0)
1284               op_ptr += offset;
1285             dwarf_expr_pop (ctx);
1286           }
1287           goto no_push;
1288
1289         case DW_OP_nop:
1290           goto no_push;
1291
1292         case DW_OP_piece:
1293           {
1294             uint64_t size;
1295
1296             /* Record the piece.  */
1297             op_ptr = safe_read_uleb128 (op_ptr, op_end, &size);
1298             add_piece (ctx, 8 * size, 0);
1299
1300             /* Pop off the address/regnum, and reset the location
1301                type.  */
1302             if (ctx->location != DWARF_VALUE_LITERAL
1303                 && ctx->location != DWARF_VALUE_OPTIMIZED_OUT)
1304               dwarf_expr_pop (ctx);
1305             ctx->location = DWARF_VALUE_MEMORY;
1306           }
1307           goto no_push;
1308
1309         case DW_OP_bit_piece:
1310           {
1311             uint64_t size, offset;
1312
1313             /* Record the piece.  */
1314             op_ptr = safe_read_uleb128 (op_ptr, op_end, &size);
1315             op_ptr = safe_read_uleb128 (op_ptr, op_end, &offset);
1316             add_piece (ctx, size, offset);
1317
1318             /* Pop off the address/regnum, and reset the location
1319                type.  */
1320             if (ctx->location != DWARF_VALUE_LITERAL
1321                 && ctx->location != DWARF_VALUE_OPTIMIZED_OUT)
1322               dwarf_expr_pop (ctx);
1323             ctx->location = DWARF_VALUE_MEMORY;
1324           }
1325           goto no_push;
1326
1327         case DW_OP_GNU_uninit:
1328           if (op_ptr != op_end)
1329             error (_("DWARF-2 expression error: DW_OP_GNU_uninit must always "
1330                    "be the very last op."));
1331
1332           ctx->initialized = 0;
1333           goto no_push;
1334
1335         case DW_OP_call2:
1336           {
1337             cu_offset offset;
1338
1339             offset.cu_off = extract_unsigned_integer (op_ptr, 2, byte_order);
1340             op_ptr += 2;
1341             ctx->funcs->dwarf_call (ctx, offset);
1342           }
1343           goto no_push;
1344
1345         case DW_OP_call4:
1346           {
1347             cu_offset offset;
1348
1349             offset.cu_off = extract_unsigned_integer (op_ptr, 4, byte_order);
1350             op_ptr += 4;
1351             ctx->funcs->dwarf_call (ctx, offset);
1352           }
1353           goto no_push;
1354
1355         case DW_OP_GNU_entry_value:
1356           {
1357             uint64_t len;
1358             CORE_ADDR deref_size;
1359             union call_site_parameter_u kind_u;
1360
1361             op_ptr = safe_read_uleb128 (op_ptr, op_end, &len);
1362             if (op_ptr + len > op_end)
1363               error (_("DW_OP_GNU_entry_value: too few bytes available."));
1364
1365             kind_u.dwarf_reg = dwarf_block_to_dwarf_reg (op_ptr, op_ptr + len);
1366             if (kind_u.dwarf_reg != -1)
1367               {
1368                 op_ptr += len;
1369                 ctx->funcs->push_dwarf_reg_entry_value (ctx,
1370                                                   CALL_SITE_PARAMETER_DWARF_REG,
1371                                                         kind_u,
1372                                                         -1 /* deref_size */);
1373                 goto no_push;
1374               }
1375
1376             kind_u.dwarf_reg = dwarf_block_to_dwarf_reg_deref (op_ptr,
1377                                                                op_ptr + len,
1378                                                                &deref_size);
1379             if (kind_u.dwarf_reg != -1)
1380               {
1381                 if (deref_size == -1)
1382                   deref_size = ctx->addr_size;
1383                 op_ptr += len;
1384                 ctx->funcs->push_dwarf_reg_entry_value (ctx,
1385                                                   CALL_SITE_PARAMETER_DWARF_REG,
1386                                                         kind_u, deref_size);
1387                 goto no_push;
1388               }
1389
1390             error (_("DWARF-2 expression error: DW_OP_GNU_entry_value is "
1391                      "supported only for single DW_OP_reg* "
1392                      "or for DW_OP_breg*(0)+DW_OP_deref*"));
1393           }
1394
1395         case DW_OP_GNU_parameter_ref:
1396           {
1397             union call_site_parameter_u kind_u;
1398
1399             kind_u.param_offset.cu_off = extract_unsigned_integer (op_ptr, 4,
1400                                                                    byte_order);
1401             op_ptr += 4;
1402             ctx->funcs->push_dwarf_reg_entry_value (ctx,
1403                                                CALL_SITE_PARAMETER_PARAM_OFFSET,
1404                                                     kind_u,
1405                                                     -1 /* deref_size */);
1406           }
1407           goto no_push;
1408
1409         case DW_OP_GNU_const_type:
1410           {
1411             cu_offset type_die;
1412             int n;
1413             const gdb_byte *data;
1414             struct type *type;
1415
1416             op_ptr = safe_read_uleb128 (op_ptr, op_end, &uoffset);
1417             type_die.cu_off = uoffset;
1418             n = *op_ptr++;
1419             data = op_ptr;
1420             op_ptr += n;
1421
1422             type = dwarf_get_base_type (ctx, type_die, n);
1423             result_val = value_from_contents (type, data);
1424           }
1425           break;
1426
1427         case DW_OP_GNU_regval_type:
1428           {
1429             cu_offset type_die;
1430             struct type *type;
1431
1432             op_ptr = safe_read_uleb128 (op_ptr, op_end, &reg);
1433             op_ptr = safe_read_uleb128 (op_ptr, op_end, &uoffset);
1434             type_die.cu_off = uoffset;
1435
1436             type = dwarf_get_base_type (ctx, type_die, 0);
1437             result = (ctx->funcs->read_reg) (ctx->baton, reg);
1438             result_val = value_from_ulongest (address_type, result);
1439             result_val = value_from_contents (type,
1440                                               value_contents_all (result_val));
1441           }
1442           break;
1443
1444         case DW_OP_GNU_convert:
1445         case DW_OP_GNU_reinterpret:
1446           {
1447             cu_offset type_die;
1448             struct type *type;
1449
1450             op_ptr = safe_read_uleb128 (op_ptr, op_end, &uoffset);
1451             type_die.cu_off = uoffset;
1452
1453             if (type_die.cu_off == 0)
1454               type = address_type;
1455             else
1456               type = dwarf_get_base_type (ctx, type_die, 0);
1457
1458             result_val = dwarf_expr_fetch (ctx, 0);
1459             dwarf_expr_pop (ctx);
1460
1461             if (op == DW_OP_GNU_convert)
1462               result_val = value_cast (type, result_val);
1463             else if (type == value_type (result_val))
1464               {
1465                 /* Nothing.  */
1466               }
1467             else if (TYPE_LENGTH (type)
1468                      != TYPE_LENGTH (value_type (result_val)))
1469               error (_("DW_OP_GNU_reinterpret has wrong size"));
1470             else
1471               result_val
1472                 = value_from_contents (type,
1473                                        value_contents_all (result_val));
1474           }
1475           break;
1476
1477         default:
1478           error (_("Unhandled dwarf expression opcode 0x%x"), op);
1479         }
1480
1481       /* Most things push a result value.  */
1482       gdb_assert (result_val != NULL);
1483       dwarf_expr_push (ctx, result_val, in_stack_memory);
1484     no_push:
1485       ;
1486     }
1487
1488   /* To simplify our main caller, if the result is an implicit
1489      pointer, then make a pieced value.  This is ok because we can't
1490      have implicit pointers in contexts where pieces are invalid.  */
1491   if (ctx->location == DWARF_VALUE_IMPLICIT_POINTER)
1492     add_piece (ctx, 8 * ctx->addr_size, 0);
1493
1494 abort_expression:
1495   ctx->recursion_depth--;
1496   gdb_assert (ctx->recursion_depth >= 0);
1497 }
1498
1499 /* Stub dwarf_expr_context_funcs.get_frame_base implementation.  */
1500
1501 void
1502 ctx_no_get_frame_base (void *baton, const gdb_byte **start, size_t *length)
1503 {
1504   error (_("%s is invalid in this context"), "DW_OP_fbreg");
1505 }
1506
1507 /* Stub dwarf_expr_context_funcs.get_frame_cfa implementation.  */
1508
1509 CORE_ADDR
1510 ctx_no_get_frame_cfa (void *baton)
1511 {
1512   error (_("%s is invalid in this context"), "DW_OP_call_frame_cfa");
1513 }
1514
1515 /* Stub dwarf_expr_context_funcs.get_frame_pc implementation.  */
1516
1517 CORE_ADDR
1518 ctx_no_get_frame_pc (void *baton)
1519 {
1520   error (_("%s is invalid in this context"), "DW_OP_GNU_implicit_pointer");
1521 }
1522
1523 /* Stub dwarf_expr_context_funcs.get_tls_address implementation.  */
1524
1525 CORE_ADDR
1526 ctx_no_get_tls_address (void *baton, CORE_ADDR offset)
1527 {
1528   error (_("%s is invalid in this context"), "DW_OP_GNU_push_tls_address");
1529 }
1530
1531 /* Stub dwarf_expr_context_funcs.dwarf_call implementation.  */
1532
1533 void
1534 ctx_no_dwarf_call (struct dwarf_expr_context *ctx, cu_offset die_offset)
1535 {
1536   error (_("%s is invalid in this context"), "DW_OP_call*");
1537 }
1538
1539 /* Stub dwarf_expr_context_funcs.get_base_type implementation.  */
1540
1541 struct type *
1542 ctx_no_get_base_type (struct dwarf_expr_context *ctx, cu_offset die)
1543 {
1544   error (_("Support for typed DWARF is not supported in this context"));
1545 }
1546
1547 /* Stub dwarf_expr_context_funcs.push_dwarf_block_entry_value
1548    implementation.  */
1549
1550 void
1551 ctx_no_push_dwarf_reg_entry_value (struct dwarf_expr_context *ctx,
1552                                    enum call_site_parameter_kind kind,
1553                                    union call_site_parameter_u kind_u,
1554                                    int deref_size)
1555 {
1556   internal_error (__FILE__, __LINE__,
1557                   _("Support for DW_OP_GNU_entry_value is unimplemented"));
1558 }
1559
1560 /* Stub dwarf_expr_context_funcs.get_addr_index implementation.  */
1561
1562 CORE_ADDR
1563 ctx_no_get_addr_index (void *baton, unsigned int index)
1564 {
1565   error (_("%s is invalid in this context"), "DW_OP_GNU_addr_index");
1566 }
1567
1568 /* Provide a prototype to silence -Wmissing-prototypes.  */
1569 extern initialize_file_ftype _initialize_dwarf2expr;
1570
1571 void
1572 _initialize_dwarf2expr (void)
1573 {
1574   dwarf_arch_cookie
1575     = gdbarch_data_register_post_init (dwarf_gdbarch_types_init);
1576 }