gdb/dwarf2expr.c

   1 /* DWARF 2 Expression Evaluator.
   2
   3    Copyright (C) 2001, 2002, 2003, 2005, 2007, 2008, 2009, 2010, 2011
   4    Free Software Foundation, 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 /* Create a new context for the expression evaluator.  */
  38
  39 struct dwarf_expr_context *
  40 new_dwarf_expr_context (void)
  41 {
  42   struct dwarf_expr_context *retval;
  43
  44   retval = xcalloc (1, sizeof (struct dwarf_expr_context));
  45   retval->stack_len = 0;
  46   retval->stack_allocated = 10;
  47   retval->stack = xmalloc (retval->stack_allocated
  48                            * sizeof (struct dwarf_stack_value));
  49   retval->num_pieces = 0;
  50   retval->pieces = 0;
  51   retval->max_recursion_depth = 0x100;
  52   return retval;
  53 }
  54
  55 /* Release the memory allocated to CTX.  */
  56
  57 void
  58 free_dwarf_expr_context (struct dwarf_expr_context *ctx)
  59 {
  60   xfree (ctx->stack);
  61   xfree (ctx->pieces);
  62   xfree (ctx);
  63 }
  64
  65 /* Helper for make_cleanup_free_dwarf_expr_context.  */
  66
  67 static void
  68 free_dwarf_expr_context_cleanup (void *arg)
  69 {
  70   free_dwarf_expr_context (arg);
  71 }
  72
  73 /* Return a cleanup that calls free_dwarf_expr_context.  */
  74
  75 struct cleanup *
  76 make_cleanup_free_dwarf_expr_context (struct dwarf_expr_context *ctx)
  77 {
  78   return make_cleanup (free_dwarf_expr_context_cleanup, ctx);
  79 }
  80
  81 /* Expand the memory allocated to CTX's stack to contain at least
  82    NEED more elements than are currently used.  */
  83
  84 static void
  85 dwarf_expr_grow_stack (struct dwarf_expr_context *ctx, size_t need)
  86 {
  87   if (ctx->stack_len + need > ctx->stack_allocated)
  88     {
  89       size_t newlen = ctx->stack_len + need + 10;
  90
  91       ctx->stack = xrealloc (ctx->stack,
  92                              newlen * sizeof (struct dwarf_stack_value));
  93       ctx->stack_allocated = newlen;
  94     }
  95 }
  96
  97 /* Push VALUE onto CTX's stack.  */
  98
  99 void
 100 dwarf_expr_push (struct dwarf_expr_context *ctx, ULONGEST value,
 101                  int in_stack_memory)
 102 {
 103   struct dwarf_stack_value *v;
 104
 105   /* We keep all stack elements within the range defined by the
 106      DWARF address size.  */
 107   if (ctx->addr_size < sizeof (ULONGEST))
 108     value &= ((ULONGEST) 1 << (ctx->addr_size * HOST_CHAR_BIT)) - 1;
 109
 110   dwarf_expr_grow_stack (ctx, 1);
 111   v = &ctx->stack[ctx->stack_len++];
 112   v->value = value;
 113   v->in_stack_memory = in_stack_memory;
 114 }
 115
 116 /* Pop the top item off of CTX's stack.  */
 117
 118 void
 119 dwarf_expr_pop (struct dwarf_expr_context *ctx)
 120 {
 121   if (ctx->stack_len <= 0)
 122     error (_("dwarf expression stack underflow"));
 123   ctx->stack_len--;
 124 }
 125
 126 /* Retrieve the N'th item on CTX's stack.  */
 127
 128 ULONGEST
 129 dwarf_expr_fetch (struct dwarf_expr_context *ctx, int n)
 130 {
 131   if (ctx->stack_len <= n)
 132      error (_("Asked for position %d of stack, "
 133               "stack only has %d elements on it."),
 134             n, ctx->stack_len);
 135   return ctx->stack[ctx->stack_len - (1 + n)].value;
 136
 137 }
 138
 139 /* Retrieve the N'th item on CTX's stack, converted to an address.  */
 140
 141 CORE_ADDR
 142 dwarf_expr_fetch_address (struct dwarf_expr_context *ctx, int n)
 143 {
 144   ULONGEST result = dwarf_expr_fetch (ctx, n);
 145
 146   /* For most architectures, calling extract_unsigned_integer() alone
 147      is sufficient for extracting an address.  However, some
 148      architectures (e.g. MIPS) use signed addresses and using
 149      extract_unsigned_integer() will not produce a correct
 150      result.  Make sure we invoke gdbarch_integer_to_address()
 151      for those architectures which require it.  */
 152   if (gdbarch_integer_to_address_p (ctx->gdbarch))
 153     {
 154       enum bfd_endian byte_order = gdbarch_byte_order (ctx->gdbarch);
 155       gdb_byte *buf = alloca (ctx->addr_size);
 156       struct type *int_type;
 157
 158       switch (ctx->addr_size)
 159         {
 160         case 2:
 161           int_type = builtin_type (ctx->gdbarch)->builtin_uint16;
 162           break;
 163         case 4:
 164           int_type = builtin_type (ctx->gdbarch)->builtin_uint32;
 165           break;
 166         case 8:
 167           int_type = builtin_type (ctx->gdbarch)->builtin_uint64;
 168           break;
 169         default:
 170           internal_error (__FILE__, __LINE__,
 171                           _("Unsupported address size.\n"));
 172         }
 173
 174       store_unsigned_integer (buf, ctx->addr_size, byte_order, result);
 175       return gdbarch_integer_to_address (ctx->gdbarch, int_type, buf);
 176     }
 177
 178   return (CORE_ADDR) result;
 179 }
 180
 181 /* Retrieve the in_stack_memory flag of the N'th item on CTX's stack.  */
 182
 183 int
 184 dwarf_expr_fetch_in_stack_memory (struct dwarf_expr_context *ctx, int n)
 185 {
 186   if (ctx->stack_len <= n)
 187      error (_("Asked for position %d of stack, "
 188               "stack only has %d elements on it."),
 189             n, ctx->stack_len);
 190   return ctx->stack[ctx->stack_len - (1 + n)].in_stack_memory;
 191
 192 }
 193
 194 /* Return true if the expression stack is empty.  */
 195
 196 static int
 197 dwarf_expr_stack_empty_p (struct dwarf_expr_context *ctx)
 198 {
 199   return ctx->stack_len == 0;
 200 }
 201
 202 /* Add a new piece to CTX's piece list.  */
 203 static void
 204 add_piece (struct dwarf_expr_context *ctx, ULONGEST size, ULONGEST offset)
 205 {
 206   struct dwarf_expr_piece *p;
 207
 208   ctx->num_pieces++;
 209
 210   ctx->pieces = xrealloc (ctx->pieces,
 211                           (ctx->num_pieces
 212                            * sizeof (struct dwarf_expr_piece)));
 213
 214   p = &ctx->pieces[ctx->num_pieces - 1];
 215   p->location = ctx->location;
 216   p->size = size;
 217   p->offset = offset;
 218
 219   if (p->location == DWARF_VALUE_LITERAL)
 220     {
 221       p->v.literal.data = ctx->data;
 222       p->v.literal.length = ctx->len;
 223     }
 224   else if (dwarf_expr_stack_empty_p (ctx))
 225     {
 226       p->location = DWARF_VALUE_OPTIMIZED_OUT;
 227       /* Also reset the context's location, for our callers.  This is
 228          a somewhat strange approach, but this lets us avoid setting
 229          the location to DWARF_VALUE_MEMORY in all the individual
 230          cases in the evaluator.  */
 231       ctx->location = DWARF_VALUE_OPTIMIZED_OUT;
 232     }
 233   else if (p->location == DWARF_VALUE_MEMORY)
 234     {
 235       p->v.mem.addr = dwarf_expr_fetch_address (ctx, 0);
 236       p->v.mem.in_stack_memory = dwarf_expr_fetch_in_stack_memory (ctx, 0);
 237     }
 238   else if (p->location == DWARF_VALUE_IMPLICIT_POINTER)
 239     {
 240       p->v.ptr.die = ctx->len;
 241       p->v.ptr.offset = (LONGEST) dwarf_expr_fetch (ctx, 0);
 242     }
 243   else
 244     {
 245       p->v.value = dwarf_expr_fetch (ctx, 0);
 246     }
 247 }
 248
 249 /* Evaluate the expression at ADDR (LEN bytes long) using the context
 250    CTX.  */
 251
 252 void
 253 dwarf_expr_eval (struct dwarf_expr_context *ctx, const gdb_byte *addr,
 254                  size_t len)
 255 {
 256   int old_recursion_depth = ctx->recursion_depth;
 257
 258   execute_stack_op (ctx, addr, addr + len);
 259
 260   /* CTX RECURSION_DEPTH becomes invalid if an exception was thrown here.  */
 261
 262   gdb_assert (ctx->recursion_depth == old_recursion_depth);
 263 }
 264
 265 /* Decode the unsigned LEB128 constant at BUF into the variable pointed to
 266    by R, and return the new value of BUF.  Verify that it doesn't extend
 267    past BUF_END.  */
 268
 269 const gdb_byte *
 270 read_uleb128 (const gdb_byte *buf, const gdb_byte *buf_end, ULONGEST * r)
 271 {
 272   unsigned shift = 0;
 273   ULONGEST result = 0;
 274   gdb_byte byte;
 275
 276   while (1)
 277     {
 278       if (buf >= buf_end)
 279         error (_("read_uleb128: Corrupted DWARF expression."));
 280
 281       byte = *buf++;
 282       result |= (byte & 0x7f) << shift;
 283       if ((byte & 0x80) == 0)
 284         break;
 285       shift += 7;
 286     }
 287   *r = result;
 288   return buf;
 289 }
 290
 291 /* Decode the signed LEB128 constant at BUF into the variable pointed to
 292    by R, and return the new value of BUF.  Verify that it doesn't extend
 293    past BUF_END.  */
 294
 295 const gdb_byte *
 296 read_sleb128 (const gdb_byte *buf, const gdb_byte *buf_end, LONGEST * r)
 297 {
 298   unsigned shift = 0;
 299   LONGEST result = 0;
 300   gdb_byte byte;
 301
 302   while (1)
 303     {
 304       if (buf >= buf_end)
 305         error (_("read_sleb128: Corrupted DWARF expression."));
 306
 307       byte = *buf++;
 308       result |= (byte & 0x7f) << shift;
 309       shift += 7;
 310       if ((byte & 0x80) == 0)
 311         break;
 312     }
 313   if (shift < (sizeof (*r) * 8) && (byte & 0x40) != 0)
 314     result |= -(1 << shift);
 315
 316   *r = result;
 317   return buf;
 318 }
 319 \f
 320
 321 /* Check that the current operator is either at the end of an
 322    expression, or that it is followed by a composition operator.  */
 323
 324 void
 325 dwarf_expr_require_composition (const gdb_byte *op_ptr, const gdb_byte *op_end,
 326                                 const char *op_name)
 327 {
 328   /* It seems like DW_OP_GNU_uninit should be handled here.  However,
 329      it doesn't seem to make sense for DW_OP_*_value, and it was not
 330      checked at the other place that this function is called.  */
 331   if (op_ptr != op_end && *op_ptr != DW_OP_piece && *op_ptr != DW_OP_bit_piece)
 332     error (_("DWARF-2 expression error: `%s' operations must be "
 333              "used either alone or in conjuction with DW_OP_piece "
 334              "or DW_OP_bit_piece."),
 335            op_name);
 336 }
 337
 338 /* The engine for the expression evaluator.  Using the context in CTX,
 339    evaluate the expression between OP_PTR and OP_END.  */
 340
 341 static void
 342 execute_stack_op (struct dwarf_expr_context *ctx,
 343                   const gdb_byte *op_ptr, const gdb_byte *op_end)
 344 {
 345 #define sign_ext(x) ((LONGEST) (((x) ^ sign_bit) - sign_bit))
 346   ULONGEST sign_bit = (ctx->addr_size >= sizeof (ULONGEST) ? 0
 347                        : ((ULONGEST) 1) << (ctx->addr_size * 8 - 1));
 348   enum bfd_endian byte_order = gdbarch_byte_order (ctx->gdbarch);
 349
 350   ctx->location = DWARF_VALUE_MEMORY;
 351   ctx->initialized = 1;  /* Default is initialized.  */
 352
 353   if (ctx->recursion_depth > ctx->max_recursion_depth)
 354     error (_("DWARF-2 expression error: Loop detected (%d)."),
 355            ctx->recursion_depth);
 356   ctx->recursion_depth++;
 357
 358   while (op_ptr < op_end)
 359     {
 360       enum dwarf_location_atom op = *op_ptr++;
 361       ULONGEST result;
 362       /* Assume the value is not in stack memory.
 363          Code that knows otherwise sets this to 1.
 364          Some arithmetic on stack addresses can probably be assumed to still
 365          be a stack address, but we skip this complication for now.
 366          This is just an optimization, so it's always ok to punt
 367          and leave this as 0.  */
 368       int in_stack_memory = 0;
 369       ULONGEST uoffset, reg;
 370       LONGEST offset;
 371
 372       switch (op)
 373         {
 374         case DW_OP_lit0:
 375         case DW_OP_lit1:
 376         case DW_OP_lit2:
 377         case DW_OP_lit3:
 378         case DW_OP_lit4:
 379         case DW_OP_lit5:
 380         case DW_OP_lit6:
 381         case DW_OP_lit7:
 382         case DW_OP_lit8:
 383         case DW_OP_lit9:
 384         case DW_OP_lit10:
 385         case DW_OP_lit11:
 386         case DW_OP_lit12:
 387         case DW_OP_lit13:
 388         case DW_OP_lit14:
 389         case DW_OP_lit15:
 390         case DW_OP_lit16:
 391         case DW_OP_lit17:
 392         case DW_OP_lit18:
 393         case DW_OP_lit19:
 394         case DW_OP_lit20:
 395         case DW_OP_lit21:
 396         case DW_OP_lit22:
 397         case DW_OP_lit23:
 398         case DW_OP_lit24:
 399         case DW_OP_lit25:
 400         case DW_OP_lit26:
 401         case DW_OP_lit27:
 402         case DW_OP_lit28:
 403         case DW_OP_lit29:
 404         case DW_OP_lit30:
 405         case DW_OP_lit31:
 406           result = op - DW_OP_lit0;
 407           break;
 408
 409         case DW_OP_addr:
 410           result = extract_unsigned_integer (op_ptr,
 411                                              ctx->addr_size, byte_order);
 412           op_ptr += ctx->addr_size;
 413           /* Some versions of GCC emit DW_OP_addr before
 414              DW_OP_GNU_push_tls_address.  In this case the value is an
 415              index, not an address.  We don't support things like
 416              branching between the address and the TLS op.  */
 417           if (op_ptr >= op_end || *op_ptr != DW_OP_GNU_push_tls_address)
 418             result += ctx->offset;
 419           break;
 420
 421         case DW_OP_const1u:
 422           result = extract_unsigned_integer (op_ptr, 1, byte_order);
 423           op_ptr += 1;
 424           break;
 425         case DW_OP_const1s:
 426           result = extract_signed_integer (op_ptr, 1, byte_order);
 427           op_ptr += 1;
 428           break;
 429         case DW_OP_const2u:
 430           result = extract_unsigned_integer (op_ptr, 2, byte_order);
 431           op_ptr += 2;
 432           break;
 433         case DW_OP_const2s:
 434           result = extract_signed_integer (op_ptr, 2, byte_order);
 435           op_ptr += 2;
 436           break;
 437         case DW_OP_const4u:
 438           result = extract_unsigned_integer (op_ptr, 4, byte_order);
 439           op_ptr += 4;
 440           break;
 441         case DW_OP_const4s:
 442           result = extract_signed_integer (op_ptr, 4, byte_order);
 443           op_ptr += 4;
 444           break;
 445         case DW_OP_const8u:
 446           result = extract_unsigned_integer (op_ptr, 8, byte_order);
 447           op_ptr += 8;
 448           break;
 449         case DW_OP_const8s:
 450           result = extract_signed_integer (op_ptr, 8, byte_order);
 451           op_ptr += 8;
 452           break;
 453         case DW_OP_constu:
 454           op_ptr = read_uleb128 (op_ptr, op_end, &uoffset);
 455           result = uoffset;
 456           break;
 457         case DW_OP_consts:
 458           op_ptr = read_sleb128 (op_ptr, op_end, &offset);
 459           result = offset;
 460           break;
 461
 462         /* The DW_OP_reg operations are required to occur alone in
 463            location expressions.  */
 464         case DW_OP_reg0:
 465         case DW_OP_reg1:
 466         case DW_OP_reg2:
 467         case DW_OP_reg3:
 468         case DW_OP_reg4:
 469         case DW_OP_reg5:
 470         case DW_OP_reg6:
 471         case DW_OP_reg7:
 472         case DW_OP_reg8:
 473         case DW_OP_reg9:
 474         case DW_OP_reg10:
 475         case DW_OP_reg11:
 476         case DW_OP_reg12:
 477         case DW_OP_reg13:
 478         case DW_OP_reg14:
 479         case DW_OP_reg15:
 480         case DW_OP_reg16:
 481         case DW_OP_reg17:
 482         case DW_OP_reg18:
 483         case DW_OP_reg19:
 484         case DW_OP_reg20:
 485         case DW_OP_reg21:
 486         case DW_OP_reg22:
 487         case DW_OP_reg23:
 488         case DW_OP_reg24:
 489         case DW_OP_reg25:
 490         case DW_OP_reg26:
 491         case DW_OP_reg27:
 492         case DW_OP_reg28:
 493         case DW_OP_reg29:
 494         case DW_OP_reg30:
 495         case DW_OP_reg31:
 496           if (op_ptr != op_end
 497               && *op_ptr != DW_OP_piece
 498               && *op_ptr != DW_OP_bit_piece
 499               && *op_ptr != DW_OP_GNU_uninit)
 500             error (_("DWARF-2 expression error: DW_OP_reg operations must be "
 501                      "used either alone or in conjuction with DW_OP_piece "
 502                      "or DW_OP_bit_piece."));
 503
 504           result = op - DW_OP_reg0;
 505           ctx->location = DWARF_VALUE_REGISTER;
 506           break;
 507
 508         case DW_OP_regx:
 509           op_ptr = read_uleb128 (op_ptr, op_end, &reg);
 510           dwarf_expr_require_composition (op_ptr, op_end, "DW_OP_regx");
 511
 512           result = reg;
 513           ctx->location = DWARF_VALUE_REGISTER;
 514           break;
 515
 516         case DW_OP_implicit_value:
 517           {
 518             ULONGEST len;
 519
 520             op_ptr = read_uleb128 (op_ptr, op_end, &len);
 521             if (op_ptr + len > op_end)
 522               error (_("DW_OP_implicit_value: too few bytes available."));
 523             ctx->len = len;
 524             ctx->data = op_ptr;
 525             ctx->location = DWARF_VALUE_LITERAL;
 526             op_ptr += len;
 527             dwarf_expr_require_composition (op_ptr, op_end,
 528                                             "DW_OP_implicit_value");
 529           }
 530           goto no_push;
 531
 532         case DW_OP_stack_value:
 533           ctx->location = DWARF_VALUE_STACK;
 534           dwarf_expr_require_composition (op_ptr, op_end, "DW_OP_stack_value");
 535           goto no_push;
 536
 537         case DW_OP_GNU_implicit_pointer:
 538           {
 539             ULONGEST die;
 540             LONGEST len;
 541
 542             /* The referred-to DIE.  */
 543             ctx->len = extract_unsigned_integer (op_ptr, ctx->addr_size,
 544                                                  byte_order);
 545             op_ptr += ctx->addr_size;
 546
 547             /* The byte offset into the data.  */
 548             op_ptr = read_sleb128 (op_ptr, op_end, &len);
 549             result = (ULONGEST) len;
 550
 551             ctx->location = DWARF_VALUE_IMPLICIT_POINTER;
 552             dwarf_expr_require_composition (op_ptr, op_end,
 553                                             "DW_OP_GNU_implicit_pointer");
 554           }
 555           break;
 556
 557         case DW_OP_breg0:
 558         case DW_OP_breg1:
 559         case DW_OP_breg2:
 560         case DW_OP_breg3:
 561         case DW_OP_breg4:
 562         case DW_OP_breg5:
 563         case DW_OP_breg6:
 564         case DW_OP_breg7:
 565         case DW_OP_breg8:
 566         case DW_OP_breg9:
 567         case DW_OP_breg10:
 568         case DW_OP_breg11:
 569         case DW_OP_breg12:
 570         case DW_OP_breg13:
 571         case DW_OP_breg14:
 572         case DW_OP_breg15:
 573         case DW_OP_breg16:
 574         case DW_OP_breg17:
 575         case DW_OP_breg18:
 576         case DW_OP_breg19:
 577         case DW_OP_breg20:
 578         case DW_OP_breg21:
 579         case DW_OP_breg22:
 580         case DW_OP_breg23:
 581         case DW_OP_breg24:
 582         case DW_OP_breg25:
 583         case DW_OP_breg26:
 584         case DW_OP_breg27:
 585         case DW_OP_breg28:
 586         case DW_OP_breg29:
 587         case DW_OP_breg30:
 588         case DW_OP_breg31:
 589           {
 590             op_ptr = read_sleb128 (op_ptr, op_end, &offset);
 591             result = (ctx->read_reg) (ctx->baton, op - DW_OP_breg0);
 592             result += offset;
 593           }
 594           break;
 595         case DW_OP_bregx:
 596           {
 597             op_ptr = read_uleb128 (op_ptr, op_end, &reg);
 598             op_ptr = read_sleb128 (op_ptr, op_end, &offset);
 599             result = (ctx->read_reg) (ctx->baton, reg);
 600             result += offset;
 601           }
 602           break;
 603         case DW_OP_fbreg:
 604           {
 605             const gdb_byte *datastart;
 606             size_t datalen;
 607             unsigned int before_stack_len;
 608
 609             op_ptr = read_sleb128 (op_ptr, op_end, &offset);
 610             /* Rather than create a whole new context, we simply
 611                record the stack length before execution, then reset it
 612                afterwards, effectively erasing whatever the recursive
 613                call put there.  */
 614             before_stack_len = ctx->stack_len;
 615             /* FIXME: cagney/2003-03-26: This code should be using
 616                get_frame_base_address(), and then implement a dwarf2
 617                specific this_base method.  */
 618             (ctx->get_frame_base) (ctx->baton, &datastart, &datalen);
 619             dwarf_expr_eval (ctx, datastart, datalen);
 620             if (ctx->location == DWARF_VALUE_MEMORY)
 621               result = dwarf_expr_fetch_address (ctx, 0);
 622             else if (ctx->location == DWARF_VALUE_REGISTER)
 623               result = (ctx->read_reg) (ctx->baton, dwarf_expr_fetch (ctx, 0));
 624             else
 625               error (_("Not implemented: computing frame "
 626                        "base using explicit value operator"));
 627             result = result + offset;
 628             in_stack_memory = 1;
 629             ctx->stack_len = before_stack_len;
 630             ctx->location = DWARF_VALUE_MEMORY;
 631           }
 632           break;
 633
 634         case DW_OP_dup:
 635           result = dwarf_expr_fetch (ctx, 0);
 636           in_stack_memory = dwarf_expr_fetch_in_stack_memory (ctx, 0);
 637           break;
 638
 639         case DW_OP_drop:
 640           dwarf_expr_pop (ctx);
 641           goto no_push;
 642
 643         case DW_OP_pick:
 644           offset = *op_ptr++;
 645           result = dwarf_expr_fetch (ctx, offset);
 646           in_stack_memory = dwarf_expr_fetch_in_stack_memory (ctx, offset);
 647           break;
 648
 649         case DW_OP_swap:
 650           {
 651             struct dwarf_stack_value t1, t2;
 652
 653             if (ctx->stack_len < 2)
 654                error (_("Not enough elements for "
 655                         "DW_OP_swap.  Need 2, have %d."),
 656                       ctx->stack_len);
 657             t1 = ctx->stack[ctx->stack_len - 1];
 658             t2 = ctx->stack[ctx->stack_len - 2];
 659             ctx->stack[ctx->stack_len - 1] = t2;
 660             ctx->stack[ctx->stack_len - 2] = t1;
 661             goto no_push;
 662           }
 663
 664         case DW_OP_over:
 665           result = dwarf_expr_fetch (ctx, 1);
 666           in_stack_memory = dwarf_expr_fetch_in_stack_memory (ctx, 1);
 667           break;
 668
 669         case DW_OP_rot:
 670           {
 671             struct dwarf_stack_value t1, t2, t3;
 672
 673             if (ctx->stack_len < 3)
 674                error (_("Not enough elements for "
 675                         "DW_OP_rot.  Need 3, have %d."),
 676                       ctx->stack_len);
 677             t1 = ctx->stack[ctx->stack_len - 1];
 678             t2 = ctx->stack[ctx->stack_len - 2];
 679             t3 = ctx->stack[ctx->stack_len - 3];
 680             ctx->stack[ctx->stack_len - 1] = t2;
 681             ctx->stack[ctx->stack_len - 2] = t3;
 682             ctx->stack[ctx->stack_len - 3] = t1;
 683             goto no_push;
 684           }
 685
 686         case DW_OP_deref:
 687         case DW_OP_deref_size:
 688           {
 689             int addr_size = (op == DW_OP_deref ? ctx->addr_size : *op_ptr++);
 690             gdb_byte *buf = alloca (addr_size);
 691             CORE_ADDR addr = dwarf_expr_fetch_address (ctx, 0);
 692             dwarf_expr_pop (ctx);
 693
 694             (ctx->read_mem) (ctx->baton, buf, addr, addr_size);
 695             result = extract_unsigned_integer (buf, addr_size, byte_order);
 696             break;
 697           }
 698
 699         case DW_OP_abs:
 700         case DW_OP_neg:
 701         case DW_OP_not:
 702         case DW_OP_plus_uconst:
 703           /* Unary operations.  */
 704           result = dwarf_expr_fetch (ctx, 0);
 705           dwarf_expr_pop (ctx);
 706
 707           switch (op)
 708             {
 709             case DW_OP_abs:
 710               if (sign_ext (result) < 0)
 711                 result = -result;
 712               break;
 713             case DW_OP_neg:
 714               result = -result;
 715               break;
 716             case DW_OP_not:
 717               result = ~result;
 718               break;
 719             case DW_OP_plus_uconst:
 720               op_ptr = read_uleb128 (op_ptr, op_end, &reg);
 721               result += reg;
 722               break;
 723             }
 724           break;
 725
 726         case DW_OP_and:
 727         case DW_OP_div:
 728         case DW_OP_minus:
 729         case DW_OP_mod:
 730         case DW_OP_mul:
 731         case DW_OP_or:
 732         case DW_OP_plus:
 733         case DW_OP_shl:
 734         case DW_OP_shr:
 735         case DW_OP_shra:
 736         case DW_OP_xor:
 737         case DW_OP_le:
 738         case DW_OP_ge:
 739         case DW_OP_eq:
 740         case DW_OP_lt:
 741         case DW_OP_gt:
 742         case DW_OP_ne:
 743           {
 744             /* Binary operations.  */
 745             ULONGEST first, second;
 746
 747             second = dwarf_expr_fetch (ctx, 0);
 748             dwarf_expr_pop (ctx);
 749
 750             first = dwarf_expr_fetch (ctx, 0);
 751             dwarf_expr_pop (ctx);
 752
 753             switch (op)
 754               {
 755               case DW_OP_and:
 756                 result = first & second;
 757                 break;
 758               case DW_OP_div:
 759                 if (!second)
 760                   error (_("Division by zero"));
 761                 result = sign_ext (first) / sign_ext (second);
 762                 break;
 763               case DW_OP_minus:
 764                 result = first - second;
 765                 break;
 766               case DW_OP_mod:
 767                 if (!second)
 768                   error (_("Division by zero"));
 769                 result = first % second;
 770                 break;
 771               case DW_OP_mul:
 772                 result = first * second;
 773                 break;
 774               case DW_OP_or:
 775                 result = first | second;
 776                 break;
 777               case DW_OP_plus:
 778                 result = first + second;
 779                 break;
 780               case DW_OP_shl:
 781                 result = first << second;
 782                 break;
 783               case DW_OP_shr:
 784                 result = first >> second;
 785                 break;
 786               case DW_OP_shra:
 787                 result = sign_ext (first) >> second;
 788                 break;
 789               case DW_OP_xor:
 790                 result = first ^ second;
 791                 break;
 792               case DW_OP_le:
 793                 result = sign_ext (first) <= sign_ext (second);
 794                 break;
 795               case DW_OP_ge:
 796                 result = sign_ext (first) >= sign_ext (second);
 797                 break;
 798               case DW_OP_eq:
 799                 result = sign_ext (first) == sign_ext (second);
 800                 break;
 801               case DW_OP_lt:
 802                 result = sign_ext (first) < sign_ext (second);
 803                 break;
 804               case DW_OP_gt:
 805                 result = sign_ext (first) > sign_ext (second);
 806                 break;
 807               case DW_OP_ne:
 808                 result = sign_ext (first) != sign_ext (second);
 809                 break;
 810               default:
 811                 internal_error (__FILE__, __LINE__,
 812                                 _("Can't be reached."));
 813               }
 814           }
 815           break;
 816
 817         case DW_OP_call_frame_cfa:
 818           result = (ctx->get_frame_cfa) (ctx->baton);
 819           in_stack_memory = 1;
 820           break;
 821
 822         case DW_OP_GNU_push_tls_address:
 823           /* Variable is at a constant offset in the thread-local
 824           storage block into the objfile for the current thread and
 825           the dynamic linker module containing this expression.  Here
 826           we return returns the offset from that base.  The top of the
 827           stack has the offset from the beginning of the thread
 828           control block at which the variable is located.  Nothing
 829           should follow this operator, so the top of stack would be
 830           returned.  */
 831           result = dwarf_expr_fetch (ctx, 0);
 832           dwarf_expr_pop (ctx);
 833           result = (ctx->get_tls_address) (ctx->baton, result);
 834           break;
 835
 836         case DW_OP_skip:
 837           offset = extract_signed_integer (op_ptr, 2, byte_order);
 838           op_ptr += 2;
 839           op_ptr += offset;
 840           goto no_push;
 841
 842         case DW_OP_bra:
 843           offset = extract_signed_integer (op_ptr, 2, byte_order);
 844           op_ptr += 2;
 845           if (dwarf_expr_fetch (ctx, 0) != 0)
 846             op_ptr += offset;
 847           dwarf_expr_pop (ctx);
 848           goto no_push;
 849
 850         case DW_OP_nop:
 851           goto no_push;
 852
 853         case DW_OP_piece:
 854           {
 855             ULONGEST size;
 856
 857             /* Record the piece.  */
 858             op_ptr = read_uleb128 (op_ptr, op_end, &size);
 859             add_piece (ctx, 8 * size, 0);
 860
 861             /* Pop off the address/regnum, and reset the location
 862                type.  */
 863             if (ctx->location != DWARF_VALUE_LITERAL
 864                 && ctx->location != DWARF_VALUE_OPTIMIZED_OUT)
 865               dwarf_expr_pop (ctx);
 866             ctx->location = DWARF_VALUE_MEMORY;
 867           }
 868           goto no_push;
 869
 870         case DW_OP_bit_piece:
 871           {
 872             ULONGEST size, offset;
 873
 874             /* Record the piece.  */
 875             op_ptr = read_uleb128 (op_ptr, op_end, &size);
 876             op_ptr = read_uleb128 (op_ptr, op_end, &offset);
 877             add_piece (ctx, size, offset);
 878
 879             /* Pop off the address/regnum, and reset the location
 880                type.  */
 881             if (ctx->location != DWARF_VALUE_LITERAL
 882                 && ctx->location != DWARF_VALUE_OPTIMIZED_OUT)
 883               dwarf_expr_pop (ctx);
 884             ctx->location = DWARF_VALUE_MEMORY;
 885           }
 886           goto no_push;
 887
 888         case DW_OP_GNU_uninit:
 889           if (op_ptr != op_end)
 890             error (_("DWARF-2 expression error: DW_OP_GNU_uninit must always "
 891                    "be the very last op."));
 892
 893           ctx->initialized = 0;
 894           goto no_push;
 895
 896         case DW_OP_call2:
 897           result = extract_unsigned_integer (op_ptr, 2, byte_order);
 898           op_ptr += 2;
 899           ctx->dwarf_call (ctx, result);
 900           goto no_push;
 901
 902         case DW_OP_call4:
 903           result = extract_unsigned_integer (op_ptr, 4, byte_order);
 904           op_ptr += 4;
 905           ctx->dwarf_call (ctx, result);
 906           goto no_push;
 907
 908         default:
 909           error (_("Unhandled dwarf expression opcode 0x%x"), op);
 910         }
 911
 912       /* Most things push a result value.  */
 913       dwarf_expr_push (ctx, result, in_stack_memory);
 914     no_push:;
 915     }
 916
 917   /* To simplify our main caller, if the result is an implicit
 918      pointer, then make a pieced value.  This is ok because we can't
 919      have implicit pointers in contexts where pieces are invalid.  */
 920   if (ctx->location == DWARF_VALUE_IMPLICIT_POINTER)
 921     add_piece (ctx, 8 * ctx->addr_size, 0);
 922
 923   ctx->recursion_depth--;
 924   gdb_assert (ctx->recursion_depth >= 0);
 925 #undef sign_ext
 926 }