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_const1u:
 736           result = extract_unsigned_integer (op_ptr, 1, byte_order);
 737           result_val = value_from_ulongest (address_type, result);
 738           op_ptr += 1;
 739           break;
 740         case DW_OP_const1s:
 741           result = extract_signed_integer (op_ptr, 1, byte_order);
 742           result_val = value_from_ulongest (address_type, result);
 743           op_ptr += 1;
 744           break;
 745         case DW_OP_const2u:
 746           result = extract_unsigned_integer (op_ptr, 2, byte_order);
 747           result_val = value_from_ulongest (address_type, result);
 748           op_ptr += 2;
 749           break;
 750         case DW_OP_const2s:
 751           result = extract_signed_integer (op_ptr, 2, byte_order);
 752           result_val = value_from_ulongest (address_type, result);
 753           op_ptr += 2;
 754           break;
 755         case DW_OP_const4u:
 756           result = extract_unsigned_integer (op_ptr, 4, byte_order);
 757           result_val = value_from_ulongest (address_type, result);
 758           op_ptr += 4;
 759           break;
 760         case DW_OP_const4s:
 761           result = extract_signed_integer (op_ptr, 4, byte_order);
 762           result_val = value_from_ulongest (address_type, result);
 763           op_ptr += 4;
 764           break;
 765         case DW_OP_const8u:
 766           result = extract_unsigned_integer (op_ptr, 8, byte_order);
 767           result_val = value_from_ulongest (address_type, result);
 768           op_ptr += 8;
 769           break;
 770         case DW_OP_const8s:
 771           result = extract_signed_integer (op_ptr, 8, byte_order);
 772           result_val = value_from_ulongest (address_type, result);
 773           op_ptr += 8;
 774           break;
 775         case DW_OP_constu:
 776           op_ptr = read_uleb128 (op_ptr, op_end, &uoffset);
 777           result = uoffset;
 778           result_val = value_from_ulongest (address_type, result);
 779           break;
 780         case DW_OP_consts:
 781           op_ptr = read_sleb128 (op_ptr, op_end, &offset);
 782           result = offset;
 783           result_val = value_from_ulongest (address_type, result);
 784           break;
 785
 786         /* The DW_OP_reg operations are required to occur alone in
 787            location expressions.  */
 788         case DW_OP_reg0:
 789         case DW_OP_reg1:
 790         case DW_OP_reg2:
 791         case DW_OP_reg3:
 792         case DW_OP_reg4:
 793         case DW_OP_reg5:
 794         case DW_OP_reg6:
 795         case DW_OP_reg7:
 796         case DW_OP_reg8:
 797         case DW_OP_reg9:
 798         case DW_OP_reg10:
 799         case DW_OP_reg11:
 800         case DW_OP_reg12:
 801         case DW_OP_reg13:
 802         case DW_OP_reg14:
 803         case DW_OP_reg15:
 804         case DW_OP_reg16:
 805         case DW_OP_reg17:
 806         case DW_OP_reg18:
 807         case DW_OP_reg19:
 808         case DW_OP_reg20:
 809         case DW_OP_reg21:
 810         case DW_OP_reg22:
 811         case DW_OP_reg23:
 812         case DW_OP_reg24:
 813         case DW_OP_reg25:
 814         case DW_OP_reg26:
 815         case DW_OP_reg27:
 816         case DW_OP_reg28:
 817         case DW_OP_reg29:
 818         case DW_OP_reg30:
 819         case DW_OP_reg31:
 820           if (op_ptr != op_end
 821               && *op_ptr != DW_OP_piece
 822               && *op_ptr != DW_OP_bit_piece
 823               && *op_ptr != DW_OP_GNU_uninit)
 824             error (_("DWARF-2 expression error: DW_OP_reg operations must be "
 825                      "used either alone or in conjunction with DW_OP_piece "
 826                      "or DW_OP_bit_piece."));
 827
 828           result = op - DW_OP_reg0;
 829           result_val = value_from_ulongest (address_type, result);
 830           ctx->location = DWARF_VALUE_REGISTER;
 831           break;
 832
 833         case DW_OP_regx:
 834           op_ptr = read_uleb128 (op_ptr, op_end, &reg);
 835           dwarf_expr_require_composition (op_ptr, op_end, "DW_OP_regx");
 836
 837           result = reg;
 838           result_val = value_from_ulongest (address_type, result);
 839           ctx->location = DWARF_VALUE_REGISTER;
 840           break;
 841
 842         case DW_OP_implicit_value:
 843           {
 844             ULONGEST len;
 845
 846             op_ptr = read_uleb128 (op_ptr, op_end, &len);
 847             if (op_ptr + len > op_end)
 848               error (_("DW_OP_implicit_value: too few bytes available."));
 849             ctx->len = len;
 850             ctx->data = op_ptr;
 851             ctx->location = DWARF_VALUE_LITERAL;
 852             op_ptr += len;
 853             dwarf_expr_require_composition (op_ptr, op_end,
 854                                             "DW_OP_implicit_value");
 855           }
 856           goto no_push;
 857
 858         case DW_OP_stack_value:
 859           ctx->location = DWARF_VALUE_STACK;
 860           dwarf_expr_require_composition (op_ptr, op_end, "DW_OP_stack_value");
 861           goto no_push;
 862
 863         case DW_OP_GNU_implicit_pointer:
 864           {
 865             ULONGEST die;
 866             LONGEST len;
 867
 868             if (ctx->ref_addr_size == -1)
 869               error (_("DWARF-2 expression error: DW_OP_GNU_implicit_pointer "
 870                        "is not allowed in frame context"));
 871
 872             /* The referred-to DIE of cu_offset kind.  */
 873             ctx->len = extract_unsigned_integer (op_ptr, ctx->ref_addr_size,
 874                                                  byte_order);
 875             op_ptr += ctx->ref_addr_size;
 876
 877             /* The byte offset into the data.  */
 878             op_ptr = read_sleb128 (op_ptr, op_end, &len);
 879             result = (ULONGEST) len;
 880             result_val = value_from_ulongest (address_type, result);
 881
 882             ctx->location = DWARF_VALUE_IMPLICIT_POINTER;
 883             dwarf_expr_require_composition (op_ptr, op_end,
 884                                             "DW_OP_GNU_implicit_pointer");
 885           }
 886           break;
 887
 888         case DW_OP_breg0:
 889         case DW_OP_breg1:
 890         case DW_OP_breg2:
 891         case DW_OP_breg3:
 892         case DW_OP_breg4:
 893         case DW_OP_breg5:
 894         case DW_OP_breg6:
 895         case DW_OP_breg7:
 896         case DW_OP_breg8:
 897         case DW_OP_breg9:
 898         case DW_OP_breg10:
 899         case DW_OP_breg11:
 900         case DW_OP_breg12:
 901         case DW_OP_breg13:
 902         case DW_OP_breg14:
 903         case DW_OP_breg15:
 904         case DW_OP_breg16:
 905         case DW_OP_breg17:
 906         case DW_OP_breg18:
 907         case DW_OP_breg19:
 908         case DW_OP_breg20:
 909         case DW_OP_breg21:
 910         case DW_OP_breg22:
 911         case DW_OP_breg23:
 912         case DW_OP_breg24:
 913         case DW_OP_breg25:
 914         case DW_OP_breg26:
 915         case DW_OP_breg27:
 916         case DW_OP_breg28:
 917         case DW_OP_breg29:
 918         case DW_OP_breg30:
 919         case DW_OP_breg31:
 920           {
 921             op_ptr = read_sleb128 (op_ptr, op_end, &offset);
 922             result = (ctx->funcs->read_reg) (ctx->baton, op - DW_OP_breg0);
 923             result += offset;
 924             result_val = value_from_ulongest (address_type, result);
 925           }
 926           break;
 927         case DW_OP_bregx:
 928           {
 929             op_ptr = read_uleb128 (op_ptr, op_end, &reg);
 930             op_ptr = read_sleb128 (op_ptr, op_end, &offset);
 931             result = (ctx->funcs->read_reg) (ctx->baton, reg);
 932             result += offset;
 933             result_val = value_from_ulongest (address_type, result);
 934           }
 935           break;
 936         case DW_OP_fbreg:
 937           {
 938             const gdb_byte *datastart;
 939             size_t datalen;
 940             unsigned int before_stack_len;
 941
 942             op_ptr = read_sleb128 (op_ptr, op_end, &offset);
 943             /* Rather than create a whole new context, we simply
 944                record the stack length before execution, then reset it
 945                afterwards, effectively erasing whatever the recursive
 946                call put there.  */
 947             before_stack_len = ctx->stack_len;
 948             /* FIXME: cagney/2003-03-26: This code should be using
 949                get_frame_base_address(), and then implement a dwarf2
 950                specific this_base method.  */
 951             (ctx->funcs->get_frame_base) (ctx->baton, &datastart, &datalen);
 952             dwarf_expr_eval (ctx, datastart, datalen);
 953             if (ctx->location == DWARF_VALUE_MEMORY)
 954               result = dwarf_expr_fetch_address (ctx, 0);
 955             else if (ctx->location == DWARF_VALUE_REGISTER)
 956               result = (ctx->funcs->read_reg) (ctx->baton,
 957                                      value_as_long (dwarf_expr_fetch (ctx, 0)));
 958             else
 959               error (_("Not implemented: computing frame "
 960                        "base using explicit value operator"));
 961             result = result + offset;
 962             result_val = value_from_ulongest (address_type, result);
 963             in_stack_memory = 1;
 964             ctx->stack_len = before_stack_len;
 965             ctx->location = DWARF_VALUE_MEMORY;
 966           }
 967           break;
 968
 969         case DW_OP_dup:
 970           result_val = dwarf_expr_fetch (ctx, 0);
 971           in_stack_memory = dwarf_expr_fetch_in_stack_memory (ctx, 0);
 972           break;
 973
 974         case DW_OP_drop:
 975           dwarf_expr_pop (ctx);
 976           goto no_push;
 977
 978         case DW_OP_pick:
 979           offset = *op_ptr++;
 980           result_val = dwarf_expr_fetch (ctx, offset);
 981           in_stack_memory = dwarf_expr_fetch_in_stack_memory (ctx, offset);
 982           break;
 983
 984         case DW_OP_swap:
 985           {
 986             struct dwarf_stack_value t1, t2;
 987
 988             if (ctx->stack_len < 2)
 989                error (_("Not enough elements for "
 990                         "DW_OP_swap.  Need 2, have %d."),
 991                       ctx->stack_len);
 992             t1 = ctx->stack[ctx->stack_len - 1];
 993             t2 = ctx->stack[ctx->stack_len - 2];
 994             ctx->stack[ctx->stack_len - 1] = t2;
 995             ctx->stack[ctx->stack_len - 2] = t1;
 996             goto no_push;
 997           }
 998
 999         case DW_OP_over:
1000           result_val = dwarf_expr_fetch (ctx, 1);
1001           in_stack_memory = dwarf_expr_fetch_in_stack_memory (ctx, 1);
1002           break;
1003
1004         case DW_OP_rot:
1005           {
1006             struct dwarf_stack_value t1, t2, t3;
1007
1008             if (ctx->stack_len < 3)
1009                error (_("Not enough elements for "
1010                         "DW_OP_rot.  Need 3, have %d."),
1011                       ctx->stack_len);
1012             t1 = ctx->stack[ctx->stack_len - 1];
1013             t2 = ctx->stack[ctx->stack_len - 2];
1014             t3 = ctx->stack[ctx->stack_len - 3];
1015             ctx->stack[ctx->stack_len - 1] = t2;
1016             ctx->stack[ctx->stack_len - 2] = t3;
1017             ctx->stack[ctx->stack_len - 3] = t1;
1018             goto no_push;
1019           }
1020
1021         case DW_OP_deref:
1022         case DW_OP_deref_size:
1023         case DW_OP_GNU_deref_type:
1024           {
1025             int addr_size = (op == DW_OP_deref ? ctx->addr_size : *op_ptr++);
1026             gdb_byte *buf = alloca (addr_size);
1027             CORE_ADDR addr = dwarf_expr_fetch_address (ctx, 0);
1028             struct type *type;
1029
1030             dwarf_expr_pop (ctx);
1031
1032             if (op == DW_OP_GNU_deref_type)
1033               {
1034                 cu_offset type_die;
1035
1036                 op_ptr = read_uleb128 (op_ptr, op_end, &uoffset);
1037                 type_die.cu_off = uoffset;
1038                 type = dwarf_get_base_type (ctx, type_die, 0);
1039               }
1040             else
1041               type = address_type;
1042
1043             (ctx->funcs->read_mem) (ctx->baton, buf, addr, addr_size);
1044
1045             /* If the size of the object read from memory is different
1046                from the type length, we need to zero-extend it.  */
1047             if (TYPE_LENGTH (type) != addr_size)
1048               {
1049                 ULONGEST result =
1050                   extract_unsigned_integer (buf, addr_size, byte_order);
1051
1052                 buf = alloca (TYPE_LENGTH (type));
1053                 store_unsigned_integer (buf, TYPE_LENGTH (type),
1054                                         byte_order, result);
1055               }
1056
1057             result_val = value_from_contents_and_address (type, buf, addr);
1058             break;
1059           }
1060
1061         case DW_OP_abs:
1062         case DW_OP_neg:
1063         case DW_OP_not:
1064         case DW_OP_plus_uconst:
1065           {
1066             /* Unary operations.  */
1067             result_val = dwarf_expr_fetch (ctx, 0);
1068             dwarf_expr_pop (ctx);
1069
1070             switch (op)
1071               {
1072               case DW_OP_abs:
1073                 if (value_less (result_val,
1074                                 value_zero (value_type (result_val), not_lval)))
1075                   result_val = value_neg (result_val);
1076                 break;
1077               case DW_OP_neg:
1078                 result_val = value_neg (result_val);
1079                 break;
1080               case DW_OP_not:
1081                 dwarf_require_integral (value_type (result_val));
1082                 result_val = value_complement (result_val);
1083                 break;
1084               case DW_OP_plus_uconst:
1085                 dwarf_require_integral (value_type (result_val));
1086                 result = value_as_long (result_val);
1087                 op_ptr = read_uleb128 (op_ptr, op_end, &reg);
1088                 result += reg;
1089                 result_val = value_from_ulongest (address_type, result);
1090                 break;
1091               }
1092           }
1093           break;
1094
1095         case DW_OP_and:
1096         case DW_OP_div:
1097         case DW_OP_minus:
1098         case DW_OP_mod:
1099         case DW_OP_mul:
1100         case DW_OP_or:
1101         case DW_OP_plus:
1102         case DW_OP_shl:
1103         case DW_OP_shr:
1104         case DW_OP_shra:
1105         case DW_OP_xor:
1106         case DW_OP_le:
1107         case DW_OP_ge:
1108         case DW_OP_eq:
1109         case DW_OP_lt:
1110         case DW_OP_gt:
1111         case DW_OP_ne:
1112           {
1113             /* Binary operations.  */
1114             struct value *first, *second;
1115
1116             second = dwarf_expr_fetch (ctx, 0);
1117             dwarf_expr_pop (ctx);
1118
1119             first = dwarf_expr_fetch (ctx, 0);
1120             dwarf_expr_pop (ctx);
1121
1122             if (! base_types_equal_p (value_type (first), value_type (second)))
1123               error (_("Incompatible types on DWARF stack"));
1124
1125             switch (op)
1126               {
1127               case DW_OP_and:
1128                 dwarf_require_integral (value_type (first));
1129                 dwarf_require_integral (value_type (second));
1130                 result_val = value_binop (first, second, BINOP_BITWISE_AND);
1131                 break;
1132               case DW_OP_div:
1133                 result_val = value_binop (first, second, BINOP_DIV);
1134                 break;
1135               case DW_OP_minus:
1136                 result_val = value_binop (first, second, BINOP_SUB);
1137                 break;
1138               case DW_OP_mod:
1139                 {
1140                   int cast_back = 0;
1141                   struct type *orig_type = value_type (first);
1142
1143                   /* We have to special-case "old-style" untyped values
1144                      -- these must have mod computed using unsigned
1145                      math.  */
1146                   if (orig_type == address_type)
1147                     {
1148                       struct type *utype
1149                         = get_unsigned_type (ctx->gdbarch, orig_type);
1150
1151                       cast_back = 1;
1152                       first = value_cast (utype, first);
1153                       second = value_cast (utype, second);
1154                     }
1155                   /* Note that value_binop doesn't handle float or
1156                      decimal float here.  This seems unimportant.  */
1157                   result_val = value_binop (first, second, BINOP_MOD);
1158                   if (cast_back)
1159                     result_val = value_cast (orig_type, result_val);
1160                 }
1161                 break;
1162               case DW_OP_mul:
1163                 result_val = value_binop (first, second, BINOP_MUL);
1164                 break;
1165               case DW_OP_or:
1166                 dwarf_require_integral (value_type (first));
1167                 dwarf_require_integral (value_type (second));
1168                 result_val = value_binop (first, second, BINOP_BITWISE_IOR);
1169                 break;
1170               case DW_OP_plus:
1171                 result_val = value_binop (first, second, BINOP_ADD);
1172                 break;
1173               case DW_OP_shl:
1174                 dwarf_require_integral (value_type (first));
1175                 dwarf_require_integral (value_type (second));
1176                 result_val = value_binop (first, second, BINOP_LSH);
1177                 break;
1178               case DW_OP_shr:
1179                 dwarf_require_integral (value_type (first));
1180                 dwarf_require_integral (value_type (second));
1181                 if (!TYPE_UNSIGNED (value_type (first)))
1182                   {
1183                     struct type *utype
1184                       = get_unsigned_type (ctx->gdbarch, value_type (first));
1185
1186                     first = value_cast (utype, first);
1187                   }
1188
1189                 result_val = value_binop (first, second, BINOP_RSH);
1190                 /* Make sure we wind up with the same type we started
1191                    with.  */
1192                 if (value_type (result_val) != value_type (second))
1193                   result_val = value_cast (value_type (second), result_val);
1194                 break;
1195               case DW_OP_shra:
1196                 dwarf_require_integral (value_type (first));
1197                 dwarf_require_integral (value_type (second));
1198                 if (TYPE_UNSIGNED (value_type (first)))
1199                   {
1200                     struct type *stype
1201                       = get_signed_type (ctx->gdbarch, value_type (first));
1202
1203                     first = value_cast (stype, first);
1204                   }
1205
1206                 result_val = value_binop (first, second, BINOP_RSH);
1207                 /* Make sure we wind up with the same type we started
1208                    with.  */
1209                 if (value_type (result_val) != value_type (second))
1210                   result_val = value_cast (value_type (second), result_val);
1211                 break;
1212               case DW_OP_xor:
1213                 dwarf_require_integral (value_type (first));
1214                 dwarf_require_integral (value_type (second));
1215                 result_val = value_binop (first, second, BINOP_BITWISE_XOR);
1216                 break;
1217               case DW_OP_le:
1218                 /* A <= B is !(B < A).  */
1219                 result = ! value_less (second, first);
1220                 result_val = value_from_ulongest (address_type, result);
1221                 break;
1222               case DW_OP_ge:
1223                 /* A >= B is !(A < B).  */
1224                 result = ! value_less (first, second);
1225                 result_val = value_from_ulongest (address_type, result);
1226                 break;
1227               case DW_OP_eq:
1228                 result = value_equal (first, second);
1229                 result_val = value_from_ulongest (address_type, result);
1230                 break;
1231               case DW_OP_lt:
1232                 result = value_less (first, second);
1233                 result_val = value_from_ulongest (address_type, result);
1234                 break;
1235               case DW_OP_gt:
1236                 /* A > B is B < A.  */
1237                 result = value_less (second, first);
1238                 result_val = value_from_ulongest (address_type, result);
1239                 break;
1240               case DW_OP_ne:
1241                 result = ! value_equal (first, second);
1242                 result_val = value_from_ulongest (address_type, result);
1243                 break;
1244               default:
1245                 internal_error (__FILE__, __LINE__,
1246                                 _("Can't be reached."));
1247               }
1248           }
1249           break;
1250
1251         case DW_OP_call_frame_cfa:
1252           result = (ctx->funcs->get_frame_cfa) (ctx->baton);
1253           result_val = value_from_ulongest (address_type, result);
1254           in_stack_memory = 1;
1255           break;
1256
1257         case DW_OP_GNU_push_tls_address:
1258           /* Variable is at a constant offset in the thread-local
1259           storage block into the objfile for the current thread and
1260           the dynamic linker module containing this expression.  Here
1261           we return returns the offset from that base.  The top of the
1262           stack has the offset from the beginning of the thread
1263           control block at which the variable is located.  Nothing
1264           should follow this operator, so the top of stack would be
1265           returned.  */
1266           result = value_as_long (dwarf_expr_fetch (ctx, 0));
1267           dwarf_expr_pop (ctx);
1268           result = (ctx->funcs->get_tls_address) (ctx->baton, result);
1269           result_val = value_from_ulongest (address_type, result);
1270           break;
1271
1272         case DW_OP_skip:
1273           offset = extract_signed_integer (op_ptr, 2, byte_order);
1274           op_ptr += 2;
1275           op_ptr += offset;
1276           goto no_push;
1277
1278         case DW_OP_bra:
1279           {
1280             struct value *val;
1281
1282             offset = extract_signed_integer (op_ptr, 2, byte_order);
1283             op_ptr += 2;
1284             val = dwarf_expr_fetch (ctx, 0);
1285             dwarf_require_integral (value_type (val));
1286             if (value_as_long (val) != 0)
1287               op_ptr += offset;
1288             dwarf_expr_pop (ctx);
1289           }
1290           goto no_push;
1291
1292         case DW_OP_nop:
1293           goto no_push;
1294
1295         case DW_OP_piece:
1296           {
1297             ULONGEST size;
1298
1299             /* Record the piece.  */
1300             op_ptr = read_uleb128 (op_ptr, op_end, &size);
1301             add_piece (ctx, 8 * size, 0);
1302
1303             /* Pop off the address/regnum, and reset the location
1304                type.  */
1305             if (ctx->location != DWARF_VALUE_LITERAL
1306                 && ctx->location != DWARF_VALUE_OPTIMIZED_OUT)
1307               dwarf_expr_pop (ctx);
1308             ctx->location = DWARF_VALUE_MEMORY;
1309           }
1310           goto no_push;
1311
1312         case DW_OP_bit_piece:
1313           {
1314             ULONGEST size, offset;
1315
1316             /* Record the piece.  */
1317             op_ptr = read_uleb128 (op_ptr, op_end, &size);
1318             op_ptr = read_uleb128 (op_ptr, op_end, &offset);
1319             add_piece (ctx, size, offset);
1320
1321             /* Pop off the address/regnum, and reset the location
1322                type.  */
1323             if (ctx->location != DWARF_VALUE_LITERAL
1324                 && ctx->location != DWARF_VALUE_OPTIMIZED_OUT)
1325               dwarf_expr_pop (ctx);
1326             ctx->location = DWARF_VALUE_MEMORY;
1327           }
1328           goto no_push;
1329
1330         case DW_OP_GNU_uninit:
1331           if (op_ptr != op_end)
1332             error (_("DWARF-2 expression error: DW_OP_GNU_uninit must always "
1333                    "be the very last op."));
1334
1335           ctx->initialized = 0;
1336           goto no_push;
1337
1338         case DW_OP_call2:
1339           {
1340             cu_offset offset;
1341
1342             offset.cu_off = extract_unsigned_integer (op_ptr, 2, byte_order);
1343             op_ptr += 2;
1344             ctx->funcs->dwarf_call (ctx, offset);
1345           }
1346           goto no_push;
1347
1348         case DW_OP_call4:
1349           {
1350             cu_offset offset;
1351
1352             offset.cu_off = extract_unsigned_integer (op_ptr, 4, byte_order);
1353             op_ptr += 4;
1354             ctx->funcs->dwarf_call (ctx, offset);
1355           }
1356           goto no_push;
1357
1358         case DW_OP_GNU_entry_value:
1359           {
1360             ULONGEST len;
1361             int dwarf_reg;
1362             CORE_ADDR deref_size;
1363
1364             op_ptr = read_uleb128 (op_ptr, op_end, &len);
1365             if (op_ptr + len > op_end)
1366               error (_("DW_OP_GNU_entry_value: too few bytes available."));
1367
1368             dwarf_reg = dwarf_block_to_dwarf_reg (op_ptr, op_ptr + len);
1369             if (dwarf_reg != -1)
1370               {
1371                 op_ptr += len;
1372                 ctx->funcs->push_dwarf_reg_entry_value (ctx, dwarf_reg,
1373                                                         0 /* unused */,
1374                                                         -1 /* deref_size */);
1375                 goto no_push;
1376               }
1377
1378             dwarf_reg = dwarf_block_to_dwarf_reg_deref (op_ptr, op_ptr + len,
1379                                                         &deref_size);
1380             if (dwarf_reg != -1)
1381               {
1382                 if (deref_size == -1)
1383                   deref_size = ctx->addr_size;
1384                 op_ptr += len;
1385                 ctx->funcs->push_dwarf_reg_entry_value (ctx, dwarf_reg,
1386                                                         0 /* unused */,
1387                                                         deref_size);
1388                 goto no_push;
1389               }
1390
1391             error (_("DWARF-2 expression error: DW_OP_GNU_entry_value is "
1392                      "supported only for single DW_OP_reg* "
1393                      "or for DW_OP_breg*(0)+DW_OP_deref*"));
1394           }
1395
1396         case DW_OP_GNU_const_type:
1397           {
1398             cu_offset type_die;
1399             int n;
1400             const gdb_byte *data;
1401             struct type *type;
1402
1403             op_ptr = read_uleb128 (op_ptr, op_end, &uoffset);
1404             type_die.cu_off = uoffset;
1405             n = *op_ptr++;
1406             data = op_ptr;
1407             op_ptr += n;
1408
1409             type = dwarf_get_base_type (ctx, type_die, n);
1410             result_val = value_from_contents (type, data);
1411           }
1412           break;
1413
1414         case DW_OP_GNU_regval_type:
1415           {
1416             cu_offset type_die;
1417             struct type *type;
1418
1419             op_ptr = read_uleb128 (op_ptr, op_end, &reg);
1420             op_ptr = read_uleb128 (op_ptr, op_end, &uoffset);
1421             type_die.cu_off = uoffset;
1422
1423             type = dwarf_get_base_type (ctx, type_die, 0);
1424             result = (ctx->funcs->read_reg) (ctx->baton, reg);
1425             result_val = value_from_ulongest (address_type, result);
1426             result_val = value_from_contents (type,
1427                                               value_contents_all (result_val));
1428           }
1429           break;
1430
1431         case DW_OP_GNU_convert:
1432         case DW_OP_GNU_reinterpret:
1433           {
1434             cu_offset type_die;
1435             struct type *type;
1436
1437             op_ptr = read_uleb128 (op_ptr, op_end, &uoffset);
1438             type_die.cu_off = uoffset;
1439
1440             if (type_die.cu_off == 0)
1441               type = address_type;
1442             else
1443               type = dwarf_get_base_type (ctx, type_die, 0);
1444
1445             result_val = dwarf_expr_fetch (ctx, 0);
1446             dwarf_expr_pop (ctx);
1447
1448             if (op == DW_OP_GNU_convert)
1449               result_val = value_cast (type, result_val);
1450             else if (type == value_type (result_val))
1451               {
1452                 /* Nothing.  */
1453               }
1454             else if (TYPE_LENGTH (type)
1455                      != TYPE_LENGTH (value_type (result_val)))
1456               error (_("DW_OP_GNU_reinterpret has wrong size"));
1457             else
1458               result_val
1459                 = value_from_contents (type,
1460                                        value_contents_all (result_val));
1461           }
1462           break;
1463
1464         default:
1465           error (_("Unhandled dwarf expression opcode 0x%x"), op);
1466         }
1467
1468       /* Most things push a result value.  */
1469       gdb_assert (result_val != NULL);
1470       dwarf_expr_push (ctx, result_val, in_stack_memory);
1471     no_push:
1472       ;
1473     }
1474
1475   /* To simplify our main caller, if the result is an implicit
1476      pointer, then make a pieced value.  This is ok because we can't
1477      have implicit pointers in contexts where pieces are invalid.  */
1478   if (ctx->location == DWARF_VALUE_IMPLICIT_POINTER)
1479     add_piece (ctx, 8 * ctx->addr_size, 0);
1480
1481 abort_expression:
1482   ctx->recursion_depth--;
1483   gdb_assert (ctx->recursion_depth >= 0);
1484 }
1485
1486 /* Stub dwarf_expr_context_funcs.get_frame_base implementation.  */
1487
1488 void
1489 ctx_no_get_frame_base (void *baton, const gdb_byte **start, size_t *length)
1490 {
1491   error (_("%s is invalid in this context"), "DW_OP_fbreg");
1492 }
1493
1494 /* Stub dwarf_expr_context_funcs.get_frame_cfa implementation.  */
1495
1496 CORE_ADDR
1497 ctx_no_get_frame_cfa (void *baton)
1498 {
1499   error (_("%s is invalid in this context"), "DW_OP_call_frame_cfa");
1500 }
1501
1502 /* Stub dwarf_expr_context_funcs.get_frame_pc implementation.  */
1503
1504 CORE_ADDR
1505 ctx_no_get_frame_pc (void *baton)
1506 {
1507   error (_("%s is invalid in this context"), "DW_OP_GNU_implicit_pointer");
1508 }
1509
1510 /* Stub dwarf_expr_context_funcs.get_tls_address implementation.  */
1511
1512 CORE_ADDR
1513 ctx_no_get_tls_address (void *baton, CORE_ADDR offset)
1514 {
1515   error (_("%s is invalid in this context"), "DW_OP_GNU_push_tls_address");
1516 }
1517
1518 /* Stub dwarf_expr_context_funcs.dwarf_call implementation.  */
1519
1520 void
1521 ctx_no_dwarf_call (struct dwarf_expr_context *ctx, cu_offset die_offset)
1522 {
1523   error (_("%s is invalid in this context"), "DW_OP_call*");
1524 }
1525
1526 /* Stub dwarf_expr_context_funcs.get_base_type implementation.  */
1527
1528 struct type *
1529 ctx_no_get_base_type (struct dwarf_expr_context *ctx, cu_offset die)
1530 {
1531   error (_("Support for typed DWARF is not supported in this context"));
1532 }
1533
1534 /* Stub dwarf_expr_context_funcs.push_dwarf_block_entry_value
1535    implementation.  */
1536
1537 void
1538 ctx_no_push_dwarf_reg_entry_value (struct dwarf_expr_context *ctx,
1539                                    int dwarf_reg, CORE_ADDR fb_offset,
1540                                    int deref_size)
1541 {
1542   internal_error (__FILE__, __LINE__,
1543                   _("Support for DW_OP_GNU_entry_value is unimplemented"));
1544 }
1545
1546 /* Provide a prototype to silence -Wmissing-prototypes.  */
1547 extern initialize_file_ftype _initialize_dwarf2expr;
1548
1549 void
1550 _initialize_dwarf2expr (void)
1551 {
1552   dwarf_arch_cookie
1553     = gdbarch_data_register_post_init (dwarf_gdbarch_types_init);
1554 }