contrib/gdb/gdb/dwarf2expr.c

   1 /* Dwarf2 Expression Evaluator
   2    Copyright 2001, 2002, 2003 Free Software Foundation, Inc.
   3    Contributed by Daniel Berlin (dan@dberlin.org)
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 59 Temple Place - Suite 330,
  20    Boston, MA 02111-1307, USA.  */
  21
  22 #include "defs.h"
  23 #include "symtab.h"
  24 #include "gdbtypes.h"
  25 #include "value.h"
  26 #include "gdbcore.h"
  27 #include "elf/dwarf2.h"
  28 #include "dwarf2expr.h"
  29
  30 /* Local prototypes.  */
  31
  32 static void execute_stack_op (struct dwarf_expr_context *,
  33                               unsigned char *, unsigned char *);
  34
  35 /* Create a new context for the expression evaluator.  */
  36
  37 struct dwarf_expr_context *
  38 new_dwarf_expr_context (void)
  39 {
  40   struct dwarf_expr_context *retval;
  41   retval = xcalloc (1, sizeof (struct dwarf_expr_context));
  42   retval->stack_len = 0;
  43   retval->stack_allocated = 10;
  44   retval->stack = xmalloc (retval->stack_allocated * sizeof (CORE_ADDR));
  45   retval->num_pieces = 0;
  46   retval->pieces = 0;
  47   return retval;
  48 }
  49
  50 /* Release the memory allocated to CTX.  */
  51
  52 void
  53 free_dwarf_expr_context (struct dwarf_expr_context *ctx)
  54 {
  55   xfree (ctx->stack);
  56   xfree (ctx->pieces);
  57   xfree (ctx);
  58 }
  59
  60 /* Expand the memory allocated to CTX's stack to contain at least
  61    NEED more elements than are currently used.  */
  62
  63 static void
  64 dwarf_expr_grow_stack (struct dwarf_expr_context *ctx, size_t need)
  65 {
  66   if (ctx->stack_len + need > ctx->stack_allocated)
  67     {
  68       size_t newlen = ctx->stack_len + need + 10;
  69       ctx->stack = xrealloc (ctx->stack,
  70                              newlen * sizeof (CORE_ADDR));
  71       ctx->stack_allocated = newlen;
  72     }
  73 }
  74
  75 /* Push VALUE onto CTX's stack.  */
  76
  77 void
  78 dwarf_expr_push (struct dwarf_expr_context *ctx, CORE_ADDR value)
  79 {
  80   dwarf_expr_grow_stack (ctx, 1);
  81   ctx->stack[ctx->stack_len++] = value;
  82 }
  83
  84 /* Pop the top item off of CTX's stack.  */
  85
  86 void
  87 dwarf_expr_pop (struct dwarf_expr_context *ctx)
  88 {
  89   if (ctx->stack_len <= 0)
  90     error ("dwarf expression stack underflow");
  91   ctx->stack_len--;
  92 }
  93
  94 /* Retrieve the N'th item on CTX's stack.  */
  95
  96 CORE_ADDR
  97 dwarf_expr_fetch (struct dwarf_expr_context *ctx, int n)
  98 {
  99   if (ctx->stack_len < n)
 100      error ("Asked for position %d of stack, stack only has %d elements on it\n",
 101             n, ctx->stack_len);
 102   return ctx->stack[ctx->stack_len - (1 + n)];
 103
 104 }
 105
 106 /* Add a new piece to CTX's piece list.  */
 107 static void
 108 add_piece (struct dwarf_expr_context *ctx,
 109            int in_reg, CORE_ADDR value, ULONGEST size)
 110 {
 111   struct dwarf_expr_piece *p;
 112
 113   ctx->num_pieces++;
 114
 115   if (ctx->pieces)
 116     ctx->pieces = xrealloc (ctx->pieces,
 117                             (ctx->num_pieces
 118                              * sizeof (struct dwarf_expr_piece)));
 119   else
 120     ctx->pieces = xmalloc (ctx->num_pieces
 121                            * sizeof (struct dwarf_expr_piece));
 122
 123   p = &ctx->pieces[ctx->num_pieces - 1];
 124   p->in_reg = in_reg;
 125   p->value = value;
 126   p->size = size;
 127 }
 128
 129 /* Evaluate the expression at ADDR (LEN bytes long) using the context
 130    CTX.  */
 131
 132 void
 133 dwarf_expr_eval (struct dwarf_expr_context *ctx, unsigned char *addr,
 134                  size_t len)
 135 {
 136   execute_stack_op (ctx, addr, addr + len);
 137 }
 138
 139 /* Decode the unsigned LEB128 constant at BUF into the variable pointed to
 140    by R, and return the new value of BUF.  Verify that it doesn't extend
 141    past BUF_END.  */
 142
 143 unsigned char *
 144 read_uleb128 (unsigned char *buf, unsigned char *buf_end, ULONGEST * r)
 145 {
 146   unsigned shift = 0;
 147   ULONGEST result = 0;
 148   unsigned char byte;
 149
 150   while (1)
 151     {
 152       if (buf >= buf_end)
 153         error ("read_uleb128: Corrupted DWARF expression.");
 154
 155       byte = *buf++;
 156       result |= (byte & 0x7f) << shift;
 157       if ((byte & 0x80) == 0)
 158         break;
 159       shift += 7;
 160     }
 161   *r = result;
 162   return buf;
 163 }
 164
 165 /* Decode the signed LEB128 constant at BUF into the variable pointed to
 166    by R, and return the new value of BUF.  Verify that it doesn't extend
 167    past BUF_END.  */
 168
 169 unsigned char *
 170 read_sleb128 (unsigned char *buf, unsigned char *buf_end, LONGEST * r)
 171 {
 172   unsigned shift = 0;
 173   LONGEST result = 0;
 174   unsigned char byte;
 175
 176   while (1)
 177     {
 178       if (buf >= buf_end)
 179         error ("read_sleb128: Corrupted DWARF expression.");
 180
 181       byte = *buf++;
 182       result |= (byte & 0x7f) << shift;
 183       shift += 7;
 184       if ((byte & 0x80) == 0)
 185         break;
 186     }
 187   if (shift < (sizeof (*r) * 8) && (byte & 0x40) != 0)
 188     result |= -(1 << shift);
 189
 190   *r = result;
 191   return buf;
 192 }
 193
 194 /* Read an address from BUF, and verify that it doesn't extend past
 195    BUF_END.  The address is returned, and *BYTES_READ is set to the
 196    number of bytes read from BUF.  */
 197
 198 CORE_ADDR
 199 dwarf2_read_address (unsigned char *buf, unsigned char *buf_end, int *bytes_read)
 200 {
 201   CORE_ADDR result;
 202
 203   if (buf_end - buf < TARGET_ADDR_BIT / TARGET_CHAR_BIT)
 204     error ("dwarf2_read_address: Corrupted DWARF expression.");
 205
 206   *bytes_read = TARGET_ADDR_BIT / TARGET_CHAR_BIT;
 207   /* NOTE: cagney/2003-05-22: This extract is assuming that a DWARF 2
 208      address is always unsigned.  That may or may not be true.  */
 209   result = extract_unsigned_integer (buf, TARGET_ADDR_BIT / TARGET_CHAR_BIT);
 210   return result;
 211 }
 212
 213 /* Return the type of an address, for unsigned arithmetic.  */
 214
 215 static struct type *
 216 unsigned_address_type (void)
 217 {
 218   switch (TARGET_ADDR_BIT / TARGET_CHAR_BIT)
 219     {
 220     case 2:
 221       return builtin_type_uint16;
 222     case 4:
 223       return builtin_type_uint32;
 224     case 8:
 225       return builtin_type_uint64;
 226     default:
 227       internal_error (__FILE__, __LINE__,
 228                       "Unsupported address size.\n");
 229     }
 230 }
 231
 232 /* Return the type of an address, for signed arithmetic.  */
 233
 234 static struct type *
 235 signed_address_type (void)
 236 {
 237   switch (TARGET_ADDR_BIT / TARGET_CHAR_BIT)
 238     {
 239     case 2:
 240       return builtin_type_int16;
 241     case 4:
 242       return builtin_type_int32;
 243     case 8:
 244       return builtin_type_int64;
 245     default:
 246       internal_error (__FILE__, __LINE__,
 247                       "Unsupported address size.\n");
 248     }
 249 }
 250 \f
 251 /* The engine for the expression evaluator.  Using the context in CTX,
 252    evaluate the expression between OP_PTR and OP_END.  */
 253
 254 static void
 255 execute_stack_op (struct dwarf_expr_context *ctx, unsigned char *op_ptr,
 256                   unsigned char *op_end)
 257 {
 258   ctx->in_reg = 0;
 259   ctx->initialized = 1;  /* Default is initialized.  */
 260
 261   while (op_ptr < op_end)
 262     {
 263       enum dwarf_location_atom op = *op_ptr++;
 264       CORE_ADDR result;
 265       ULONGEST uoffset, reg;
 266       LONGEST offset;
 267       int bytes_read;
 268
 269       switch (op)
 270         {
 271         case DW_OP_lit0:
 272         case DW_OP_lit1:
 273         case DW_OP_lit2:
 274         case DW_OP_lit3:
 275         case DW_OP_lit4:
 276         case DW_OP_lit5:
 277         case DW_OP_lit6:
 278         case DW_OP_lit7:
 279         case DW_OP_lit8:
 280         case DW_OP_lit9:
 281         case DW_OP_lit10:
 282         case DW_OP_lit11:
 283         case DW_OP_lit12:
 284         case DW_OP_lit13:
 285         case DW_OP_lit14:
 286         case DW_OP_lit15:
 287         case DW_OP_lit16:
 288         case DW_OP_lit17:
 289         case DW_OP_lit18:
 290         case DW_OP_lit19:
 291         case DW_OP_lit20:
 292         case DW_OP_lit21:
 293         case DW_OP_lit22:
 294         case DW_OP_lit23:
 295         case DW_OP_lit24:
 296         case DW_OP_lit25:
 297         case DW_OP_lit26:
 298         case DW_OP_lit27:
 299         case DW_OP_lit28:
 300         case DW_OP_lit29:
 301         case DW_OP_lit30:
 302         case DW_OP_lit31:
 303           result = op - DW_OP_lit0;
 304           break;
 305
 306         case DW_OP_addr:
 307           result = dwarf2_read_address (op_ptr, op_end, &bytes_read);
 308           op_ptr += bytes_read;
 309           break;
 310
 311         case DW_OP_const1u:
 312           result = extract_unsigned_integer (op_ptr, 1);
 313           op_ptr += 1;
 314           break;
 315         case DW_OP_const1s:
 316           result = extract_signed_integer (op_ptr, 1);
 317           op_ptr += 1;
 318           break;
 319         case DW_OP_const2u:
 320           result = extract_unsigned_integer (op_ptr, 2);
 321           op_ptr += 2;
 322           break;
 323         case DW_OP_const2s:
 324           result = extract_signed_integer (op_ptr, 2);
 325           op_ptr += 2;
 326           break;
 327         case DW_OP_const4u:
 328           result = extract_unsigned_integer (op_ptr, 4);
 329           op_ptr += 4;
 330           break;
 331         case DW_OP_const4s:
 332           result = extract_signed_integer (op_ptr, 4);
 333           op_ptr += 4;
 334           break;
 335         case DW_OP_const8u:
 336           result = extract_unsigned_integer (op_ptr, 8);
 337           op_ptr += 8;
 338           break;
 339         case DW_OP_const8s:
 340           result = extract_signed_integer (op_ptr, 8);
 341           op_ptr += 8;
 342           break;
 343         case DW_OP_constu:
 344           op_ptr = read_uleb128 (op_ptr, op_end, &uoffset);
 345           result = uoffset;
 346           break;
 347         case DW_OP_consts:
 348           op_ptr = read_sleb128 (op_ptr, op_end, &offset);
 349           result = offset;
 350           break;
 351
 352         /* The DW_OP_reg operations are required to occur alone in
 353            location expressions.  */
 354         case DW_OP_reg0:
 355         case DW_OP_reg1:
 356         case DW_OP_reg2:
 357         case DW_OP_reg3:
 358         case DW_OP_reg4:
 359         case DW_OP_reg5:
 360         case DW_OP_reg6:
 361         case DW_OP_reg7:
 362         case DW_OP_reg8:
 363         case DW_OP_reg9:
 364         case DW_OP_reg10:
 365         case DW_OP_reg11:
 366         case DW_OP_reg12:
 367         case DW_OP_reg13:
 368         case DW_OP_reg14:
 369         case DW_OP_reg15:
 370         case DW_OP_reg16:
 371         case DW_OP_reg17:
 372         case DW_OP_reg18:
 373         case DW_OP_reg19:
 374         case DW_OP_reg20:
 375         case DW_OP_reg21:
 376         case DW_OP_reg22:
 377         case DW_OP_reg23:
 378         case DW_OP_reg24:
 379         case DW_OP_reg25:
 380         case DW_OP_reg26:
 381         case DW_OP_reg27:
 382         case DW_OP_reg28:
 383         case DW_OP_reg29:
 384         case DW_OP_reg30:
 385         case DW_OP_reg31:
 386           if (op_ptr != op_end
 387               && *op_ptr != DW_OP_piece
 388               && *op_ptr != DW_OP_bit_piece
 389               && *op_ptr != DW_OP_GNU_uninit)
 390             error (_("DWARF-2 expression error: DW_OP_reg operations must be "
 391                    "used either alone or in conjuction with DW_OP_piece."));
 392
 393           result = op - DW_OP_reg0;
 394           ctx->in_reg = 1;
 395
 396           break;
 397
 398         case DW_OP_regx:
 399           op_ptr = read_uleb128 (op_ptr, op_end, &reg);
 400           if (op_ptr != op_end && *op_ptr != DW_OP_piece)
 401             error ("DWARF-2 expression error: DW_OP_reg operations must be "
 402                    "used either alone or in conjuction with DW_OP_piece.");
 403
 404           result = reg;
 405           ctx->in_reg = 1;
 406           break;
 407
 408         case DW_OP_breg0:
 409         case DW_OP_breg1:
 410         case DW_OP_breg2:
 411         case DW_OP_breg3:
 412         case DW_OP_breg4:
 413         case DW_OP_breg5:
 414         case DW_OP_breg6:
 415         case DW_OP_breg7:
 416         case DW_OP_breg8:
 417         case DW_OP_breg9:
 418         case DW_OP_breg10:
 419         case DW_OP_breg11:
 420         case DW_OP_breg12:
 421         case DW_OP_breg13:
 422         case DW_OP_breg14:
 423         case DW_OP_breg15:
 424         case DW_OP_breg16:
 425         case DW_OP_breg17:
 426         case DW_OP_breg18:
 427         case DW_OP_breg19:
 428         case DW_OP_breg20:
 429         case DW_OP_breg21:
 430         case DW_OP_breg22:
 431         case DW_OP_breg23:
 432         case DW_OP_breg24:
 433         case DW_OP_breg25:
 434         case DW_OP_breg26:
 435         case DW_OP_breg27:
 436         case DW_OP_breg28:
 437         case DW_OP_breg29:
 438         case DW_OP_breg30:
 439         case DW_OP_breg31:
 440           {
 441             op_ptr = read_sleb128 (op_ptr, op_end, &offset);
 442             result = (ctx->read_reg) (ctx->baton, op - DW_OP_breg0);
 443             result += offset;
 444           }
 445           break;
 446         case DW_OP_bregx:
 447           {
 448             op_ptr = read_uleb128 (op_ptr, op_end, &reg);
 449             op_ptr = read_sleb128 (op_ptr, op_end, &offset);
 450             result = (ctx->read_reg) (ctx->baton, reg);
 451             result += offset;
 452           }
 453           break;
 454         case DW_OP_fbreg:
 455           {
 456             unsigned char *datastart;
 457             size_t datalen;
 458             unsigned int before_stack_len;
 459
 460             op_ptr = read_sleb128 (op_ptr, op_end, &offset);
 461             /* Rather than create a whole new context, we simply
 462                record the stack length before execution, then reset it
 463                afterwards, effectively erasing whatever the recursive
 464                call put there.  */
 465             before_stack_len = ctx->stack_len;
 466             /* FIXME: cagney/2003-03-26: This code should be using
 467                get_frame_base_address(), and then implement a dwarf2
 468                specific this_base method.  */
 469             (ctx->get_frame_base) (ctx->baton, &datastart, &datalen);
 470             dwarf_expr_eval (ctx, datastart, datalen);
 471             result = dwarf_expr_fetch (ctx, 0);
 472             if (ctx->in_reg)
 473               result = (ctx->read_reg) (ctx->baton, result);
 474             result = result + offset;
 475             ctx->stack_len = before_stack_len;
 476             ctx->in_reg = 0;
 477           }
 478           break;
 479         case DW_OP_dup:
 480           result = dwarf_expr_fetch (ctx, 0);
 481           break;
 482
 483         case DW_OP_drop:
 484           dwarf_expr_pop (ctx);
 485           goto no_push;
 486
 487         case DW_OP_pick:
 488           offset = *op_ptr++;
 489           result = dwarf_expr_fetch (ctx, offset);
 490           break;
 491
 492         case DW_OP_over:
 493           result = dwarf_expr_fetch (ctx, 1);
 494           break;
 495
 496         case DW_OP_rot:
 497           {
 498             CORE_ADDR t1, t2, t3;
 499
 500             if (ctx->stack_len < 3)
 501                error ("Not enough elements for DW_OP_rot. Need 3, have %d\n",
 502                       ctx->stack_len);
 503             t1 = ctx->stack[ctx->stack_len - 1];
 504             t2 = ctx->stack[ctx->stack_len - 2];
 505             t3 = ctx->stack[ctx->stack_len - 3];
 506             ctx->stack[ctx->stack_len - 1] = t2;
 507             ctx->stack[ctx->stack_len - 2] = t3;
 508             ctx->stack[ctx->stack_len - 3] = t1;
 509             goto no_push;
 510           }
 511
 512         case DW_OP_deref:
 513         case DW_OP_deref_size:
 514         case DW_OP_abs:
 515         case DW_OP_neg:
 516         case DW_OP_not:
 517         case DW_OP_plus_uconst:
 518           /* Unary operations.  */
 519           result = dwarf_expr_fetch (ctx, 0);
 520           dwarf_expr_pop (ctx);
 521
 522           switch (op)
 523             {
 524             case DW_OP_deref:
 525               {
 526                 char *buf = alloca (TARGET_ADDR_BIT / TARGET_CHAR_BIT);
 527                 int bytes_read;
 528
 529                 (ctx->read_mem) (ctx->baton, buf, result,
 530                                  TARGET_ADDR_BIT / TARGET_CHAR_BIT);
 531                 result = dwarf2_read_address (buf,
 532                                               buf + (TARGET_ADDR_BIT
 533                                                      / TARGET_CHAR_BIT),
 534                                               &bytes_read);
 535               }
 536               break;
 537
 538             case DW_OP_deref_size:
 539               {
 540                 char *buf = alloca (TARGET_ADDR_BIT / TARGET_CHAR_BIT);
 541                 int bytes_read;
 542
 543                 (ctx->read_mem) (ctx->baton, buf, result, *op_ptr++);
 544                 result = dwarf2_read_address (buf,
 545                                               buf + (TARGET_ADDR_BIT
 546                                                      / TARGET_CHAR_BIT),
 547                                               &bytes_read);
 548               }
 549               break;
 550
 551             case DW_OP_abs:
 552               if ((signed int) result < 0)
 553                 result = -result;
 554               break;
 555             case DW_OP_neg:
 556               result = -result;
 557               break;
 558             case DW_OP_not:
 559               result = ~result;
 560               break;
 561             case DW_OP_plus_uconst:
 562               op_ptr = read_uleb128 (op_ptr, op_end, &reg);
 563               result += reg;
 564               break;
 565             }
 566           break;
 567
 568         case DW_OP_and:
 569         case DW_OP_div:
 570         case DW_OP_minus:
 571         case DW_OP_mod:
 572         case DW_OP_mul:
 573         case DW_OP_or:
 574         case DW_OP_plus:
 575         case DW_OP_shl:
 576         case DW_OP_shr:
 577         case DW_OP_shra:
 578         case DW_OP_xor:
 579         case DW_OP_le:
 580         case DW_OP_ge:
 581         case DW_OP_eq:
 582         case DW_OP_lt:
 583         case DW_OP_gt:
 584         case DW_OP_ne:
 585           {
 586             /* Binary operations.  Use the value engine to do computations in
 587                the right width.  */
 588             CORE_ADDR first, second;
 589             enum exp_opcode binop;
 590             struct value *val1, *val2;
 591
 592             second = dwarf_expr_fetch (ctx, 0);
 593             dwarf_expr_pop (ctx);
 594
 595             first = dwarf_expr_fetch (ctx, 0);
 596             dwarf_expr_pop (ctx);
 597
 598             val1 = value_from_longest (unsigned_address_type (), first);
 599             val2 = value_from_longest (unsigned_address_type (), second);
 600
 601             switch (op)
 602               {
 603               case DW_OP_and:
 604                 binop = BINOP_BITWISE_AND;
 605                 break;
 606               case DW_OP_div:
 607                 binop = BINOP_DIV;
 608                 break;
 609               case DW_OP_minus:
 610                 binop = BINOP_SUB;
 611                 break;
 612               case DW_OP_mod:
 613                 binop = BINOP_MOD;
 614                 break;
 615               case DW_OP_mul:
 616                 binop = BINOP_MUL;
 617                 break;
 618               case DW_OP_or:
 619                 binop = BINOP_BITWISE_IOR;
 620                 break;
 621               case DW_OP_plus:
 622                 binop = BINOP_ADD;
 623                 break;
 624               case DW_OP_shl:
 625                 binop = BINOP_LSH;
 626                 break;
 627               case DW_OP_shr:
 628                 binop = BINOP_RSH;
 629                 break;
 630               case DW_OP_shra:
 631                 binop = BINOP_RSH;
 632                 val1 = value_from_longest (signed_address_type (), first);
 633                 break;
 634               case DW_OP_xor:
 635                 binop = BINOP_BITWISE_XOR;
 636                 break;
 637               case DW_OP_le:
 638                 binop = BINOP_LEQ;
 639                 break;
 640               case DW_OP_ge:
 641                 binop = BINOP_GEQ;
 642                 break;
 643               case DW_OP_eq:
 644                 binop = BINOP_EQUAL;
 645                 break;
 646               case DW_OP_lt:
 647                 binop = BINOP_LESS;
 648                 break;
 649               case DW_OP_gt:
 650                 binop = BINOP_GTR;
 651                 break;
 652               case DW_OP_ne:
 653                 binop = BINOP_NOTEQUAL;
 654                 break;
 655               default:
 656                 internal_error (__FILE__, __LINE__,
 657                                 "Can't be reached.");
 658               }
 659             result = value_as_long (value_binop (val1, val2, binop));
 660           }
 661           break;
 662
 663         case DW_OP_GNU_push_tls_address:
 664           /* Variable is at a constant offset in the thread-local
 665           storage block into the objfile for the current thread and
 666           the dynamic linker module containing this expression. Here
 667           we return returns the offset from that base.  The top of the
 668           stack has the offset from the beginning of the thread
 669           control block at which the variable is located.  Nothing
 670           should follow this operator, so the top of stack would be
 671           returned.  */
 672           result = dwarf_expr_fetch (ctx, 0);
 673           dwarf_expr_pop (ctx);
 674           result = (ctx->get_tls_address) (ctx->baton, result);
 675           break;
 676
 677         case DW_OP_skip:
 678           offset = extract_signed_integer (op_ptr, 2);
 679           op_ptr += 2;
 680           op_ptr += offset;
 681           goto no_push;
 682
 683         case DW_OP_bra:
 684           offset = extract_signed_integer (op_ptr, 2);
 685           op_ptr += 2;
 686           if (dwarf_expr_fetch (ctx, 0) != 0)
 687             op_ptr += offset;
 688           dwarf_expr_pop (ctx);
 689           goto no_push;
 690
 691         case DW_OP_nop:
 692           goto no_push;
 693
 694         case DW_OP_piece:
 695         {
 696           ULONGEST size;
 697           CORE_ADDR addr_or_regnum;
 698
 699           /* Record the piece.  */
 700           op_ptr = read_uleb128 (op_ptr, op_end, &size);
 701           addr_or_regnum = dwarf_expr_fetch (ctx, 0);
 702           add_piece (ctx, ctx->in_reg, addr_or_regnum, size);
 703
 704           /* Pop off the address/regnum, and clear the in_reg flag.  */
 705           dwarf_expr_pop (ctx);
 706           ctx->in_reg = 0;
 707         }
 708           goto no_push;
 709
 710        case DW_OP_GNU_uninit:
 711          if (op_ptr != op_end)
 712            error (_("DWARF-2 expression error: DW_OP_GNU_unint must always "
 713                   "be the very last op."));
 714
 715          ctx->initialized = 0;
 716          goto no_push;
 717
 718         default:
 719           error ("Unhandled dwarf expression opcode 0x%x", op);
 720         }
 721
 722       /* Most things push a result value.  */
 723       dwarf_expr_push (ctx, result);
 724     no_push:;
 725     }
 726 }