gdb/dwarf2expr.c

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