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 DW_OP_rot. Need 3, have %d."),
 675                       ctx->stack_len);
 676             t1 = ctx->stack[ctx->stack_len - 1];
 677             t2 = ctx->stack[ctx->stack_len - 2];
 678             t3 = ctx->stack[ctx->stack_len - 3];
 679             ctx->stack[ctx->stack_len - 1] = t2;
 680             ctx->stack[ctx->stack_len - 2] = t3;
 681             ctx->stack[ctx->stack_len - 3] = t1;
 682             goto no_push;
 683           }
 684
 685         case DW_OP_deref:
 686         case DW_OP_deref_size:
 687           {
 688             int addr_size = (op == DW_OP_deref ? ctx->addr_size : *op_ptr++);
 689             gdb_byte *buf = alloca (addr_size);
 690             CORE_ADDR addr = dwarf_expr_fetch_address (ctx, 0);
 691             dwarf_expr_pop (ctx);
 692
 693             (ctx->read_mem) (ctx->baton, buf, addr, addr_size);
 694             result = extract_unsigned_integer (buf, addr_size, byte_order);
 695             break;
 696           }
 697
 698         case DW_OP_abs:
 699         case DW_OP_neg:
 700         case DW_OP_not:
 701         case DW_OP_plus_uconst:
 702           /* Unary operations.  */
 703           result = dwarf_expr_fetch (ctx, 0);
 704           dwarf_expr_pop (ctx);
 705
 706           switch (op)
 707             {
 708             case DW_OP_abs:
 709               if (sign_ext (result) < 0)
 710                 result = -result;
 711               break;
 712             case DW_OP_neg:
 713               result = -result;
 714               break;
 715             case DW_OP_not:
 716               result = ~result;
 717               break;
 718             case DW_OP_plus_uconst:
 719               op_ptr = read_uleb128 (op_ptr, op_end, &reg);
 720               result += reg;
 721               break;
 722             }
 723           break;
 724
 725         case DW_OP_and:
 726         case DW_OP_div:
 727         case DW_OP_minus:
 728         case DW_OP_mod:
 729         case DW_OP_mul:
 730         case DW_OP_or:
 731         case DW_OP_plus:
 732         case DW_OP_shl:
 733         case DW_OP_shr:
 734         case DW_OP_shra:
 735         case DW_OP_xor:
 736         case DW_OP_le:
 737         case DW_OP_ge:
 738         case DW_OP_eq:
 739         case DW_OP_lt:
 740         case DW_OP_gt:
 741         case DW_OP_ne:
 742           {
 743             /* Binary operations.  */
 744             ULONGEST first, second;
 745
 746             second = dwarf_expr_fetch (ctx, 0);
 747             dwarf_expr_pop (ctx);
 748
 749             first = dwarf_expr_fetch (ctx, 0);
 750             dwarf_expr_pop (ctx);
 751
 752             switch (op)
 753               {
 754               case DW_OP_and:
 755                 result = first & second;
 756                 break;
 757               case DW_OP_div:
 758                 if (!second)
 759                   error (_("Division by zero"));
 760                 result = sign_ext (first) / sign_ext (second);
 761                 break;
 762               case DW_OP_minus:
 763                 result = first - second;
 764                 break;
 765               case DW_OP_mod:
 766                 if (!second)
 767                   error (_("Division by zero"));
 768                 result = first % second;
 769                 break;
 770               case DW_OP_mul:
 771                 result = first * second;
 772                 break;
 773               case DW_OP_or:
 774                 result = first | second;
 775                 break;
 776               case DW_OP_plus:
 777                 result = first + second;
 778                 break;
 779               case DW_OP_shl:
 780                 result = first << second;
 781                 break;
 782               case DW_OP_shr:
 783                 result = first >> second;
 784                 break;
 785               case DW_OP_shra:
 786                 result = sign_ext (first) >> second;
 787                 break;
 788               case DW_OP_xor:
 789                 result = first ^ second;
 790                 break;
 791               case DW_OP_le:
 792                 result = sign_ext (first) <= sign_ext (second);
 793                 break;
 794               case DW_OP_ge:
 795                 result = sign_ext (first) >= sign_ext (second);
 796                 break;
 797               case DW_OP_eq:
 798                 result = sign_ext (first) == sign_ext (second);
 799                 break;
 800               case DW_OP_lt:
 801                 result = sign_ext (first) < sign_ext (second);
 802                 break;
 803               case DW_OP_gt:
 804                 result = sign_ext (first) > sign_ext (second);
 805                 break;
 806               case DW_OP_ne:
 807                 result = sign_ext (first) != sign_ext (second);
 808                 break;
 809               default:
 810                 internal_error (__FILE__, __LINE__,
 811                                 _("Can't be reached."));
 812               }
 813           }
 814           break;
 815
 816         case DW_OP_call_frame_cfa:
 817           result = (ctx->get_frame_cfa) (ctx->baton);
 818           in_stack_memory = 1;
 819           break;
 820
 821         case DW_OP_GNU_push_tls_address:
 822           /* Variable is at a constant offset in the thread-local
 823           storage block into the objfile for the current thread and
 824           the dynamic linker module containing this expression. Here
 825           we return returns the offset from that base.  The top of the
 826           stack has the offset from the beginning of the thread
 827           control block at which the variable is located.  Nothing
 828           should follow this operator, so the top of stack would be
 829           returned.  */
 830           result = dwarf_expr_fetch (ctx, 0);
 831           dwarf_expr_pop (ctx);
 832           result = (ctx->get_tls_address) (ctx->baton, result);
 833           break;
 834
 835         case DW_OP_skip:
 836           offset = extract_signed_integer (op_ptr, 2, byte_order);
 837           op_ptr += 2;
 838           op_ptr += offset;
 839           goto no_push;
 840
 841         case DW_OP_bra:
 842           offset = extract_signed_integer (op_ptr, 2, byte_order);
 843           op_ptr += 2;
 844           if (dwarf_expr_fetch (ctx, 0) != 0)
 845             op_ptr += offset;
 846           dwarf_expr_pop (ctx);
 847           goto no_push;
 848
 849         case DW_OP_nop:
 850           goto no_push;
 851
 852         case DW_OP_piece:
 853           {
 854             ULONGEST size;
 855
 856             /* Record the piece.  */
 857             op_ptr = read_uleb128 (op_ptr, op_end, &size);
 858             add_piece (ctx, 8 * size, 0);
 859
 860             /* Pop off the address/regnum, and reset the location
 861                type.  */
 862             if (ctx->location != DWARF_VALUE_LITERAL
 863                 && ctx->location != DWARF_VALUE_OPTIMIZED_OUT)
 864               dwarf_expr_pop (ctx);
 865             ctx->location = DWARF_VALUE_MEMORY;
 866           }
 867           goto no_push;
 868
 869         case DW_OP_bit_piece:
 870           {
 871             ULONGEST size, offset;
 872
 873             /* Record the piece.  */
 874             op_ptr = read_uleb128 (op_ptr, op_end, &size);
 875             op_ptr = read_uleb128 (op_ptr, op_end, &offset);
 876             add_piece (ctx, size, offset);
 877
 878             /* Pop off the address/regnum, and reset the location
 879                type.  */
 880             if (ctx->location != DWARF_VALUE_LITERAL
 881                 && ctx->location != DWARF_VALUE_OPTIMIZED_OUT)
 882               dwarf_expr_pop (ctx);
 883             ctx->location = DWARF_VALUE_MEMORY;
 884           }
 885           goto no_push;
 886
 887         case DW_OP_GNU_uninit:
 888           if (op_ptr != op_end)
 889             error (_("DWARF-2 expression error: DW_OP_GNU_uninit must always "
 890                    "be the very last op."));
 891
 892           ctx->initialized = 0;
 893           goto no_push;
 894
 895         case DW_OP_call2:
 896           result = extract_unsigned_integer (op_ptr, 2, byte_order);
 897           op_ptr += 2;
 898           ctx->dwarf_call (ctx, result);
 899           goto no_push;
 900
 901         case DW_OP_call4:
 902           result = extract_unsigned_integer (op_ptr, 4, byte_order);
 903           op_ptr += 4;
 904           ctx->dwarf_call (ctx, result);
 905           goto no_push;
 906
 907         default:
 908           error (_("Unhandled dwarf expression opcode 0x%x"), op);
 909         }
 910
 911       /* Most things push a result value.  */
 912       dwarf_expr_push (ctx, result, in_stack_memory);
 913     no_push:;
 914     }
 915
 916   /* To simplify our main caller, if the result is an implicit
 917      pointer, then make a pieced value.  This is ok because we can't
 918      have implicit pointers in contexts where pieces are invalid.  */
 919   if (ctx->location == DWARF_VALUE_IMPLICIT_POINTER)
 920     add_piece (ctx, 8 * ctx->addr_size, 0);
 921
 922   ctx->recursion_depth--;
 923   gdb_assert (ctx->recursion_depth >= 0);
 924 #undef sign_ext
 925 }