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 /* Cookie for gdbarch data.  */
  38
  39 static struct gdbarch_data *dwarf_arch_cookie;
  40
  41 /* This holds gdbarch-specific types used by the DWARF expression
  42    evaluator.  See comments in execute_stack_op.  */
  43
  44 struct dwarf_gdbarch_types
  45 {
  46   struct type *dw_types[3];
  47 };
  48
  49 /* Allocate and fill in dwarf_gdbarch_types for an arch.  */
  50
  51 static void *
  52 dwarf_gdbarch_types_init (struct gdbarch *gdbarch)
  53 {
  54   struct dwarf_gdbarch_types *types
  55     = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct dwarf_gdbarch_types);
  56
  57   /* The types themselves are lazily initialized.  */
  58
  59   return types;
  60 }
  61
  62 /* Return the type used for DWARF operations where the type is
  63    unspecified in the DWARF spec.  Only certain sizes are
  64    supported.  */
  65
  66 static struct type *
  67 dwarf_expr_address_type (struct dwarf_expr_context *ctx)
  68 {
  69   struct dwarf_gdbarch_types *types = gdbarch_data (ctx->gdbarch,
  70                                                     dwarf_arch_cookie);
  71   int ndx;
  72
  73   if (ctx->addr_size == 2)
  74     ndx = 0;
  75   else if (ctx->addr_size == 4)
  76     ndx = 1;
  77   else if (ctx->addr_size == 8)
  78     ndx = 2;
  79   else
  80     error (_("Unsupported address size in DWARF expressions: %d bits"),
  81            8 * ctx->addr_size);
  82
  83   if (types->dw_types[ndx] == NULL)
  84     types->dw_types[ndx]
  85       = arch_integer_type (ctx->gdbarch,
  86                            8 * ctx->addr_size,
  87                            0, "<signed DWARF address type>");
  88
  89   return types->dw_types[ndx];
  90 }
  91
  92 /* Create a new context for the expression evaluator.  */
  93
  94 struct dwarf_expr_context *
  95 new_dwarf_expr_context (void)
  96 {
  97   struct dwarf_expr_context *retval;
  98
  99   retval = xcalloc (1, sizeof (struct dwarf_expr_context));
 100   retval->stack_len = 0;
 101   retval->stack_allocated = 10;
 102   retval->stack = xmalloc (retval->stack_allocated
 103                            * sizeof (struct dwarf_stack_value));
 104   retval->num_pieces = 0;
 105   retval->pieces = 0;
 106   retval->max_recursion_depth = 0x100;
 107   return retval;
 108 }
 109
 110 /* Release the memory allocated to CTX.  */
 111
 112 void
 113 free_dwarf_expr_context (struct dwarf_expr_context *ctx)
 114 {
 115   xfree (ctx->stack);
 116   xfree (ctx->pieces);
 117   xfree (ctx);
 118 }
 119
 120 /* Helper for make_cleanup_free_dwarf_expr_context.  */
 121
 122 static void
 123 free_dwarf_expr_context_cleanup (void *arg)
 124 {
 125   free_dwarf_expr_context (arg);
 126 }
 127
 128 /* Return a cleanup that calls free_dwarf_expr_context.  */
 129
 130 struct cleanup *
 131 make_cleanup_free_dwarf_expr_context (struct dwarf_expr_context *ctx)
 132 {
 133   return make_cleanup (free_dwarf_expr_context_cleanup, ctx);
 134 }
 135
 136 /* Expand the memory allocated to CTX's stack to contain at least
 137    NEED more elements than are currently used.  */
 138
 139 static void
 140 dwarf_expr_grow_stack (struct dwarf_expr_context *ctx, size_t need)
 141 {
 142   if (ctx->stack_len + need > ctx->stack_allocated)
 143     {
 144       size_t newlen = ctx->stack_len + need + 10;
 145
 146       ctx->stack = xrealloc (ctx->stack,
 147                              newlen * sizeof (struct dwarf_stack_value));
 148       ctx->stack_allocated = newlen;
 149     }
 150 }
 151
 152 /* Push VALUE onto CTX's stack.  */
 153
 154 static void
 155 dwarf_expr_push (struct dwarf_expr_context *ctx, struct value *value,
 156                  int in_stack_memory)
 157 {
 158   struct dwarf_stack_value *v;
 159
 160   dwarf_expr_grow_stack (ctx, 1);
 161   v = &ctx->stack[ctx->stack_len++];
 162   v->value = value;
 163   v->in_stack_memory = in_stack_memory;
 164 }
 165
 166 /* Push VALUE onto CTX's stack.  */
 167
 168 void
 169 dwarf_expr_push_address (struct dwarf_expr_context *ctx, CORE_ADDR value,
 170                          int in_stack_memory)
 171 {
 172   dwarf_expr_push (ctx,
 173                    value_from_ulongest (dwarf_expr_address_type (ctx), value),
 174                    in_stack_memory);
 175 }
 176
 177 /* Pop the top item off of CTX's stack.  */
 178
 179 static void
 180 dwarf_expr_pop (struct dwarf_expr_context *ctx)
 181 {
 182   if (ctx->stack_len <= 0)
 183     error (_("dwarf expression stack underflow"));
 184   ctx->stack_len--;
 185 }
 186
 187 /* Retrieve the N'th item on CTX's stack.  */
 188
 189 struct value *
 190 dwarf_expr_fetch (struct dwarf_expr_context *ctx, int n)
 191 {
 192   if (ctx->stack_len <= n)
 193      error (_("Asked for position %d of stack, "
 194               "stack only has %d elements on it."),
 195             n, ctx->stack_len);
 196   return ctx->stack[ctx->stack_len - (1 + n)].value;
 197 }
 198
 199 /* Require that TYPE be an integral type; throw an exception if not.  */
 200
 201 static void
 202 dwarf_require_integral (struct type *type)
 203 {
 204   if (TYPE_CODE (type) != TYPE_CODE_INT
 205       && TYPE_CODE (type) != TYPE_CODE_CHAR
 206       && TYPE_CODE (type) != TYPE_CODE_BOOL)
 207     error (_("integral type expected in DWARF expression"));
 208 }
 209
 210 /* Return the unsigned form of TYPE.  TYPE is necessarily an integral
 211    type.  */
 212
 213 static struct type *
 214 get_unsigned_type (struct gdbarch *gdbarch, struct type *type)
 215 {
 216   switch (TYPE_LENGTH (type))
 217     {
 218     case 1:
 219       return builtin_type (gdbarch)->builtin_uint8;
 220     case 2:
 221       return builtin_type (gdbarch)->builtin_uint16;
 222     case 4:
 223       return builtin_type (gdbarch)->builtin_uint32;
 224     case 8:
 225       return builtin_type (gdbarch)->builtin_uint64;
 226     default:
 227       error (_("no unsigned variant found for type, while evaluating "
 228                "DWARF expression"));
 229     }
 230 }
 231
 232 /* Return the signed form of TYPE.  TYPE is necessarily an integral
 233    type.  */
 234
 235 static struct type *
 236 get_signed_type (struct gdbarch *gdbarch, struct type *type)
 237 {
 238   switch (TYPE_LENGTH (type))
 239     {
 240     case 1:
 241       return builtin_type (gdbarch)->builtin_int8;
 242     case 2:
 243       return builtin_type (gdbarch)->builtin_int16;
 244     case 4:
 245       return builtin_type (gdbarch)->builtin_int32;
 246     case 8:
 247       return builtin_type (gdbarch)->builtin_int64;
 248     default:
 249       error (_("no signed variant found for type, while evaluating "
 250                "DWARF expression"));
 251     }
 252 }
 253
 254 /* Retrieve the N'th item on CTX's stack, converted to an address.  */
 255
 256 CORE_ADDR
 257 dwarf_expr_fetch_address (struct dwarf_expr_context *ctx, int n)
 258 {
 259   struct value *result_val = dwarf_expr_fetch (ctx, n);
 260   enum bfd_endian byte_order = gdbarch_byte_order (ctx->gdbarch);
 261   ULONGEST result;
 262
 263   dwarf_require_integral (value_type (result_val));
 264   result = extract_unsigned_integer (value_contents (result_val),
 265                                      TYPE_LENGTH (value_type (result_val)),
 266                                      byte_order);
 267
 268   /* For most architectures, calling extract_unsigned_integer() alone
 269      is sufficient for extracting an address.  However, some
 270      architectures (e.g. MIPS) use signed addresses and using
 271      extract_unsigned_integer() will not produce a correct
 272      result.  Make sure we invoke gdbarch_integer_to_address()
 273      for those architectures which require it.  */
 274   if (gdbarch_integer_to_address_p (ctx->gdbarch))
 275     {
 276       gdb_byte *buf = alloca (ctx->addr_size);
 277       struct type *int_type = get_unsigned_type (ctx->gdbarch,
 278                                                  value_type (result_val));
 279
 280       store_unsigned_integer (buf, ctx->addr_size, byte_order, result);
 281       return gdbarch_integer_to_address (ctx->gdbarch, int_type, buf);
 282     }
 283
 284   return (CORE_ADDR) result;
 285 }
 286
 287 /* Retrieve the in_stack_memory flag of the N'th item on CTX's stack.  */
 288
 289 int
 290 dwarf_expr_fetch_in_stack_memory (struct dwarf_expr_context *ctx, int n)
 291 {
 292   if (ctx->stack_len <= n)
 293      error (_("Asked for position %d of stack, "
 294               "stack only has %d elements on it."),
 295             n, ctx->stack_len);
 296   return ctx->stack[ctx->stack_len - (1 + n)].in_stack_memory;
 297 }
 298
 299 /* Return true if the expression stack is empty.  */
 300
 301 static int
 302 dwarf_expr_stack_empty_p (struct dwarf_expr_context *ctx)
 303 {
 304   return ctx->stack_len == 0;
 305 }
 306
 307 /* Add a new piece to CTX's piece list.  */
 308 static void
 309 add_piece (struct dwarf_expr_context *ctx, ULONGEST size, ULONGEST offset)
 310 {
 311   struct dwarf_expr_piece *p;
 312
 313   ctx->num_pieces++;
 314
 315   ctx->pieces = xrealloc (ctx->pieces,
 316                           (ctx->num_pieces
 317                            * sizeof (struct dwarf_expr_piece)));
 318
 319   p = &ctx->pieces[ctx->num_pieces - 1];
 320   p->location = ctx->location;
 321   p->size = size;
 322   p->offset = offset;
 323
 324   if (p->location == DWARF_VALUE_LITERAL)
 325     {
 326       p->v.literal.data = ctx->data;
 327       p->v.literal.length = ctx->len;
 328     }
 329   else if (dwarf_expr_stack_empty_p (ctx))
 330     {
 331       p->location = DWARF_VALUE_OPTIMIZED_OUT;
 332       /* Also reset the context's location, for our callers.  This is
 333          a somewhat strange approach, but this lets us avoid setting
 334          the location to DWARF_VALUE_MEMORY in all the individual
 335          cases in the evaluator.  */
 336       ctx->location = DWARF_VALUE_OPTIMIZED_OUT;
 337     }
 338   else if (p->location == DWARF_VALUE_MEMORY)
 339     {
 340       p->v.mem.addr = dwarf_expr_fetch_address (ctx, 0);
 341       p->v.mem.in_stack_memory = dwarf_expr_fetch_in_stack_memory (ctx, 0);
 342     }
 343   else if (p->location == DWARF_VALUE_IMPLICIT_POINTER)
 344     {
 345       p->v.ptr.die = ctx->len;
 346       p->v.ptr.offset = value_as_long (dwarf_expr_fetch (ctx, 0));
 347     }
 348   else if (p->location == DWARF_VALUE_REGISTER)
 349     p->v.regno = value_as_long (dwarf_expr_fetch (ctx, 0));
 350   else
 351     {
 352       p->v.value = dwarf_expr_fetch (ctx, 0);
 353     }
 354 }
 355
 356 /* Evaluate the expression at ADDR (LEN bytes long) using the context
 357    CTX.  */
 358
 359 void
 360 dwarf_expr_eval (struct dwarf_expr_context *ctx, const gdb_byte *addr,
 361                  size_t len)
 362 {
 363   int old_recursion_depth = ctx->recursion_depth;
 364
 365   execute_stack_op (ctx, addr, addr + len);
 366
 367   /* CTX RECURSION_DEPTH becomes invalid if an exception was thrown here.  */
 368
 369   gdb_assert (ctx->recursion_depth == old_recursion_depth);
 370 }
 371
 372 /* Decode the unsigned LEB128 constant at BUF into the variable pointed to
 373    by R, and return the new value of BUF.  Verify that it doesn't extend
 374    past BUF_END.  */
 375
 376 const gdb_byte *
 377 read_uleb128 (const gdb_byte *buf, const gdb_byte *buf_end, ULONGEST * r)
 378 {
 379   unsigned shift = 0;
 380   ULONGEST result = 0;
 381   gdb_byte byte;
 382
 383   while (1)
 384     {
 385       if (buf >= buf_end)
 386         error (_("read_uleb128: Corrupted DWARF expression."));
 387
 388       byte = *buf++;
 389       result |= ((ULONGEST) (byte & 0x7f)) << shift;
 390       if ((byte & 0x80) == 0)
 391         break;
 392       shift += 7;
 393     }
 394   *r = result;
 395   return buf;
 396 }
 397
 398 /* Decode the signed LEB128 constant at BUF into the variable pointed to
 399    by R, and return the new value of BUF.  Verify that it doesn't extend
 400    past BUF_END.  */
 401
 402 const gdb_byte *
 403 read_sleb128 (const gdb_byte *buf, const gdb_byte *buf_end, LONGEST * r)
 404 {
 405   unsigned shift = 0;
 406   LONGEST result = 0;
 407   gdb_byte byte;
 408
 409   while (1)
 410     {
 411       if (buf >= buf_end)
 412         error (_("read_sleb128: Corrupted DWARF expression."));
 413
 414       byte = *buf++;
 415       result |= ((ULONGEST) (byte & 0x7f)) << shift;
 416       shift += 7;
 417       if ((byte & 0x80) == 0)
 418         break;
 419     }
 420   if (shift < (sizeof (*r) * 8) && (byte & 0x40) != 0)
 421     result |= -(1 << shift);
 422
 423   *r = result;
 424   return buf;
 425 }
 426 \f
 427
 428 /* Check that the current operator is either at the end of an
 429    expression, or that it is followed by a composition operator.  */
 430
 431 void
 432 dwarf_expr_require_composition (const gdb_byte *op_ptr, const gdb_byte *op_end,
 433                                 const char *op_name)
 434 {
 435   /* It seems like DW_OP_GNU_uninit should be handled here.  However,
 436      it doesn't seem to make sense for DW_OP_*_value, and it was not
 437      checked at the other place that this function is called.  */
 438   if (op_ptr != op_end && *op_ptr != DW_OP_piece && *op_ptr != DW_OP_bit_piece)
 439     error (_("DWARF-2 expression error: `%s' operations must be "
 440              "used either alone or in conjunction with DW_OP_piece "
 441              "or DW_OP_bit_piece."),
 442            op_name);
 443 }
 444
 445 /* Return true iff the types T1 and T2 are "the same".  This only does
 446    checks that might reasonably be needed to compare DWARF base
 447    types.  */
 448
 449 static int
 450 base_types_equal_p (struct type *t1, struct type *t2)
 451 {
 452   if (TYPE_CODE (t1) != TYPE_CODE (t2))
 453     return 0;
 454   if (TYPE_UNSIGNED (t1) != TYPE_UNSIGNED (t2))
 455     return 0;
 456   return TYPE_LENGTH (t1) == TYPE_LENGTH (t2);
 457 }
 458
 459 /* A convenience function to call get_base_type on CTX and return the
 460    result.  DIE is the DIE whose type we need.  SIZE is non-zero if
 461    this function should verify that the resulting type has the correct
 462    size.  */
 463
 464 static struct type *
 465 dwarf_get_base_type (struct dwarf_expr_context *ctx, ULONGEST die, int size)
 466 {
 467   struct type *result;
 468
 469   if (ctx->get_base_type)
 470     {
 471       result = ctx->get_base_type (ctx, die);
 472       if (result == NULL)
 473         error (_("Could not find type for DW_OP_GNU_const_type"));
 474       if (size != 0 && TYPE_LENGTH (result) != size)
 475         error (_("DW_OP_GNU_const_type has different sizes for type and data"));
 476     }
 477   else
 478     /* Anything will do.  */
 479     result = builtin_type (ctx->gdbarch)->builtin_int;
 480
 481   return result;
 482 }
 483
 484 /* The engine for the expression evaluator.  Using the context in CTX,
 485    evaluate the expression between OP_PTR and OP_END.  */
 486
 487 static void
 488 execute_stack_op (struct dwarf_expr_context *ctx,
 489                   const gdb_byte *op_ptr, const gdb_byte *op_end)
 490 {
 491   enum bfd_endian byte_order = gdbarch_byte_order (ctx->gdbarch);
 492   /* Old-style "untyped" DWARF values need special treatment in a
 493      couple of places, specifically DW_OP_mod and DW_OP_shr.  We need
 494      a special type for these values so we can distinguish them from
 495      values that have an explicit type, because explicitly-typed
 496      values do not need special treatment.  This special type must be
 497      different (in the `==' sense) from any base type coming from the
 498      CU.  */
 499   struct type *address_type = dwarf_expr_address_type (ctx);
 500
 501   ctx->location = DWARF_VALUE_MEMORY;
 502   ctx->initialized = 1;  /* Default is initialized.  */
 503
 504   if (ctx->recursion_depth > ctx->max_recursion_depth)
 505     error (_("DWARF-2 expression error: Loop detected (%d)."),
 506            ctx->recursion_depth);
 507   ctx->recursion_depth++;
 508
 509   while (op_ptr < op_end)
 510     {
 511       enum dwarf_location_atom op = *op_ptr++;
 512       ULONGEST result;
 513       /* Assume the value is not in stack memory.
 514          Code that knows otherwise sets this to 1.
 515          Some arithmetic on stack addresses can probably be assumed to still
 516          be a stack address, but we skip this complication for now.
 517          This is just an optimization, so it's always ok to punt
 518          and leave this as 0.  */
 519       int in_stack_memory = 0;
 520       ULONGEST uoffset, reg;
 521       LONGEST offset;
 522       struct value *result_val = NULL;
 523
 524       switch (op)
 525         {
 526         case DW_OP_lit0:
 527         case DW_OP_lit1:
 528         case DW_OP_lit2:
 529         case DW_OP_lit3:
 530         case DW_OP_lit4:
 531         case DW_OP_lit5:
 532         case DW_OP_lit6:
 533         case DW_OP_lit7:
 534         case DW_OP_lit8:
 535         case DW_OP_lit9:
 536         case DW_OP_lit10:
 537         case DW_OP_lit11:
 538         case DW_OP_lit12:
 539         case DW_OP_lit13:
 540         case DW_OP_lit14:
 541         case DW_OP_lit15:
 542         case DW_OP_lit16:
 543         case DW_OP_lit17:
 544         case DW_OP_lit18:
 545         case DW_OP_lit19:
 546         case DW_OP_lit20:
 547         case DW_OP_lit21:
 548         case DW_OP_lit22:
 549         case DW_OP_lit23:
 550         case DW_OP_lit24:
 551         case DW_OP_lit25:
 552         case DW_OP_lit26:
 553         case DW_OP_lit27:
 554         case DW_OP_lit28:
 555         case DW_OP_lit29:
 556         case DW_OP_lit30:
 557         case DW_OP_lit31:
 558           result = op - DW_OP_lit0;
 559           result_val = value_from_ulongest (address_type, result);
 560           break;
 561
 562         case DW_OP_addr:
 563           result = extract_unsigned_integer (op_ptr,
 564                                              ctx->addr_size, byte_order);
 565           op_ptr += ctx->addr_size;
 566           /* Some versions of GCC emit DW_OP_addr before
 567              DW_OP_GNU_push_tls_address.  In this case the value is an
 568              index, not an address.  We don't support things like
 569              branching between the address and the TLS op.  */
 570           if (op_ptr >= op_end || *op_ptr != DW_OP_GNU_push_tls_address)
 571             result += ctx->offset;
 572           result_val = value_from_ulongest (address_type, result);
 573           break;
 574
 575         case DW_OP_const1u:
 576           result = extract_unsigned_integer (op_ptr, 1, byte_order);
 577           result_val = value_from_ulongest (address_type, result);
 578           op_ptr += 1;
 579           break;
 580         case DW_OP_const1s:
 581           result = extract_signed_integer (op_ptr, 1, byte_order);
 582           result_val = value_from_ulongest (address_type, result);
 583           op_ptr += 1;
 584           break;
 585         case DW_OP_const2u:
 586           result = extract_unsigned_integer (op_ptr, 2, byte_order);
 587           result_val = value_from_ulongest (address_type, result);
 588           op_ptr += 2;
 589           break;
 590         case DW_OP_const2s:
 591           result = extract_signed_integer (op_ptr, 2, byte_order);
 592           result_val = value_from_ulongest (address_type, result);
 593           op_ptr += 2;
 594           break;
 595         case DW_OP_const4u:
 596           result = extract_unsigned_integer (op_ptr, 4, byte_order);
 597           result_val = value_from_ulongest (address_type, result);
 598           op_ptr += 4;
 599           break;
 600         case DW_OP_const4s:
 601           result = extract_signed_integer (op_ptr, 4, byte_order);
 602           result_val = value_from_ulongest (address_type, result);
 603           op_ptr += 4;
 604           break;
 605         case DW_OP_const8u:
 606           result = extract_unsigned_integer (op_ptr, 8, byte_order);
 607           result_val = value_from_ulongest (address_type, result);
 608           op_ptr += 8;
 609           break;
 610         case DW_OP_const8s:
 611           result = extract_signed_integer (op_ptr, 8, byte_order);
 612           result_val = value_from_ulongest (address_type, result);
 613           op_ptr += 8;
 614           break;
 615         case DW_OP_constu:
 616           op_ptr = read_uleb128 (op_ptr, op_end, &uoffset);
 617           result = uoffset;
 618           result_val = value_from_ulongest (address_type, result);
 619           break;
 620         case DW_OP_consts:
 621           op_ptr = read_sleb128 (op_ptr, op_end, &offset);
 622           result = offset;
 623           result_val = value_from_ulongest (address_type, result);
 624           break;
 625
 626         /* The DW_OP_reg operations are required to occur alone in
 627            location expressions.  */
 628         case DW_OP_reg0:
 629         case DW_OP_reg1:
 630         case DW_OP_reg2:
 631         case DW_OP_reg3:
 632         case DW_OP_reg4:
 633         case DW_OP_reg5:
 634         case DW_OP_reg6:
 635         case DW_OP_reg7:
 636         case DW_OP_reg8:
 637         case DW_OP_reg9:
 638         case DW_OP_reg10:
 639         case DW_OP_reg11:
 640         case DW_OP_reg12:
 641         case DW_OP_reg13:
 642         case DW_OP_reg14:
 643         case DW_OP_reg15:
 644         case DW_OP_reg16:
 645         case DW_OP_reg17:
 646         case DW_OP_reg18:
 647         case DW_OP_reg19:
 648         case DW_OP_reg20:
 649         case DW_OP_reg21:
 650         case DW_OP_reg22:
 651         case DW_OP_reg23:
 652         case DW_OP_reg24:
 653         case DW_OP_reg25:
 654         case DW_OP_reg26:
 655         case DW_OP_reg27:
 656         case DW_OP_reg28:
 657         case DW_OP_reg29:
 658         case DW_OP_reg30:
 659         case DW_OP_reg31:
 660           if (op_ptr != op_end
 661               && *op_ptr != DW_OP_piece
 662               && *op_ptr != DW_OP_bit_piece
 663               && *op_ptr != DW_OP_GNU_uninit)
 664             error (_("DWARF-2 expression error: DW_OP_reg operations must be "
 665                      "used either alone or in conjunction with DW_OP_piece "
 666                      "or DW_OP_bit_piece."));
 667
 668           result = op - DW_OP_reg0;
 669           result_val = value_from_ulongest (address_type, result);
 670           ctx->location = DWARF_VALUE_REGISTER;
 671           break;
 672
 673         case DW_OP_regx:
 674           op_ptr = read_uleb128 (op_ptr, op_end, &reg);
 675           dwarf_expr_require_composition (op_ptr, op_end, "DW_OP_regx");
 676
 677           result = reg;
 678           result_val = value_from_ulongest (address_type, result);
 679           ctx->location = DWARF_VALUE_REGISTER;
 680           break;
 681
 682         case DW_OP_implicit_value:
 683           {
 684             ULONGEST len;
 685
 686             op_ptr = read_uleb128 (op_ptr, op_end, &len);
 687             if (op_ptr + len > op_end)
 688               error (_("DW_OP_implicit_value: too few bytes available."));
 689             ctx->len = len;
 690             ctx->data = op_ptr;
 691             ctx->location = DWARF_VALUE_LITERAL;
 692             op_ptr += len;
 693             dwarf_expr_require_composition (op_ptr, op_end,
 694                                             "DW_OP_implicit_value");
 695           }
 696           goto no_push;
 697
 698         case DW_OP_stack_value:
 699           ctx->location = DWARF_VALUE_STACK;
 700           dwarf_expr_require_composition (op_ptr, op_end, "DW_OP_stack_value");
 701           goto no_push;
 702
 703         case DW_OP_GNU_implicit_pointer:
 704           {
 705             ULONGEST die;
 706             LONGEST len;
 707
 708             /* The referred-to DIE.  */
 709             ctx->len = extract_unsigned_integer (op_ptr, ctx->addr_size,
 710                                                  byte_order);
 711             op_ptr += ctx->addr_size;
 712
 713             /* The byte offset into the data.  */
 714             op_ptr = read_sleb128 (op_ptr, op_end, &len);
 715             result = (ULONGEST) len;
 716             result_val = value_from_ulongest (address_type, result);
 717
 718             ctx->location = DWARF_VALUE_IMPLICIT_POINTER;
 719             dwarf_expr_require_composition (op_ptr, op_end,
 720                                             "DW_OP_GNU_implicit_pointer");
 721           }
 722           break;
 723
 724         case DW_OP_breg0:
 725         case DW_OP_breg1:
 726         case DW_OP_breg2:
 727         case DW_OP_breg3:
 728         case DW_OP_breg4:
 729         case DW_OP_breg5:
 730         case DW_OP_breg6:
 731         case DW_OP_breg7:
 732         case DW_OP_breg8:
 733         case DW_OP_breg9:
 734         case DW_OP_breg10:
 735         case DW_OP_breg11:
 736         case DW_OP_breg12:
 737         case DW_OP_breg13:
 738         case DW_OP_breg14:
 739         case DW_OP_breg15:
 740         case DW_OP_breg16:
 741         case DW_OP_breg17:
 742         case DW_OP_breg18:
 743         case DW_OP_breg19:
 744         case DW_OP_breg20:
 745         case DW_OP_breg21:
 746         case DW_OP_breg22:
 747         case DW_OP_breg23:
 748         case DW_OP_breg24:
 749         case DW_OP_breg25:
 750         case DW_OP_breg26:
 751         case DW_OP_breg27:
 752         case DW_OP_breg28:
 753         case DW_OP_breg29:
 754         case DW_OP_breg30:
 755         case DW_OP_breg31:
 756           {
 757             op_ptr = read_sleb128 (op_ptr, op_end, &offset);
 758             result = (ctx->read_reg) (ctx->baton, op - DW_OP_breg0);
 759             result += offset;
 760             result_val = value_from_ulongest (address_type, result);
 761           }
 762           break;
 763         case DW_OP_bregx:
 764           {
 765             op_ptr = read_uleb128 (op_ptr, op_end, &reg);
 766             op_ptr = read_sleb128 (op_ptr, op_end, &offset);
 767             result = (ctx->read_reg) (ctx->baton, reg);
 768             result += offset;
 769             result_val = value_from_ulongest (address_type, result);
 770           }
 771           break;
 772         case DW_OP_fbreg:
 773           {
 774             const gdb_byte *datastart;
 775             size_t datalen;
 776             unsigned int before_stack_len;
 777
 778             op_ptr = read_sleb128 (op_ptr, op_end, &offset);
 779             /* Rather than create a whole new context, we simply
 780                record the stack length before execution, then reset it
 781                afterwards, effectively erasing whatever the recursive
 782                call put there.  */
 783             before_stack_len = ctx->stack_len;
 784             /* FIXME: cagney/2003-03-26: This code should be using
 785                get_frame_base_address(), and then implement a dwarf2
 786                specific this_base method.  */
 787             (ctx->get_frame_base) (ctx->baton, &datastart, &datalen);
 788             dwarf_expr_eval (ctx, datastart, datalen);
 789             if (ctx->location == DWARF_VALUE_MEMORY)
 790               result = dwarf_expr_fetch_address (ctx, 0);
 791             else if (ctx->location == DWARF_VALUE_REGISTER)
 792               result
 793                 = (ctx->read_reg) (ctx->baton,
 794                                    value_as_long (dwarf_expr_fetch (ctx, 0)));
 795             else
 796               error (_("Not implemented: computing frame "
 797                        "base using explicit value operator"));
 798             result = result + offset;
 799             result_val = value_from_ulongest (address_type, result);
 800             in_stack_memory = 1;
 801             ctx->stack_len = before_stack_len;
 802             ctx->location = DWARF_VALUE_MEMORY;
 803           }
 804           break;
 805
 806         case DW_OP_dup:
 807           result_val = dwarf_expr_fetch (ctx, 0);
 808           in_stack_memory = dwarf_expr_fetch_in_stack_memory (ctx, 0);
 809           break;
 810
 811         case DW_OP_drop:
 812           dwarf_expr_pop (ctx);
 813           goto no_push;
 814
 815         case DW_OP_pick:
 816           offset = *op_ptr++;
 817           result_val = dwarf_expr_fetch (ctx, offset);
 818           in_stack_memory = dwarf_expr_fetch_in_stack_memory (ctx, offset);
 819           break;
 820
 821         case DW_OP_swap:
 822           {
 823             struct dwarf_stack_value t1, t2;
 824
 825             if (ctx->stack_len < 2)
 826                error (_("Not enough elements for "
 827                         "DW_OP_swap.  Need 2, have %d."),
 828                       ctx->stack_len);
 829             t1 = ctx->stack[ctx->stack_len - 1];
 830             t2 = ctx->stack[ctx->stack_len - 2];
 831             ctx->stack[ctx->stack_len - 1] = t2;
 832             ctx->stack[ctx->stack_len - 2] = t1;
 833             goto no_push;
 834           }
 835
 836         case DW_OP_over:
 837           result_val = dwarf_expr_fetch (ctx, 1);
 838           in_stack_memory = dwarf_expr_fetch_in_stack_memory (ctx, 1);
 839           break;
 840
 841         case DW_OP_rot:
 842           {
 843             struct dwarf_stack_value t1, t2, t3;
 844
 845             if (ctx->stack_len < 3)
 846                error (_("Not enough elements for "
 847                         "DW_OP_rot.  Need 3, have %d."),
 848                       ctx->stack_len);
 849             t1 = ctx->stack[ctx->stack_len - 1];
 850             t2 = ctx->stack[ctx->stack_len - 2];
 851             t3 = ctx->stack[ctx->stack_len - 3];
 852             ctx->stack[ctx->stack_len - 1] = t2;
 853             ctx->stack[ctx->stack_len - 2] = t3;
 854             ctx->stack[ctx->stack_len - 3] = t1;
 855             goto no_push;
 856           }
 857
 858         case DW_OP_deref:
 859         case DW_OP_deref_size:
 860         case DW_OP_GNU_deref_type:
 861           {
 862             int addr_size = (op == DW_OP_deref ? ctx->addr_size : *op_ptr++);
 863             gdb_byte *buf = alloca (addr_size);
 864             CORE_ADDR addr = dwarf_expr_fetch_address (ctx, 0);
 865             struct type *type;
 866
 867             dwarf_expr_pop (ctx);
 868
 869             if (op == DW_OP_GNU_deref_type)
 870               {
 871                 ULONGEST type_die;
 872
 873                 op_ptr = read_uleb128 (op_ptr, op_end, &type_die);
 874                 type = dwarf_get_base_type (ctx, type_die, 0);
 875               }
 876             else
 877               type = address_type;
 878
 879             (ctx->read_mem) (ctx->baton, buf, addr, addr_size);
 880
 881             /* If the size of the object read from memory is different
 882                from the type length, we need to zero-extend it.  */
 883             if (TYPE_LENGTH (type) != addr_size)
 884               {
 885                 ULONGEST result =
 886                   extract_unsigned_integer (buf, addr_size, byte_order);
 887
 888                 buf = alloca (TYPE_LENGTH (type));
 889                 store_unsigned_integer (buf, TYPE_LENGTH (type),
 890                                         byte_order, result);
 891               }
 892
 893             result_val = value_from_contents_and_address (type, buf, addr);
 894             break;
 895           }
 896
 897         case DW_OP_abs:
 898         case DW_OP_neg:
 899         case DW_OP_not:
 900         case DW_OP_plus_uconst:
 901           {
 902             /* Unary operations.  */
 903             result_val = dwarf_expr_fetch (ctx, 0);
 904             dwarf_expr_pop (ctx);
 905
 906             switch (op)
 907               {
 908               case DW_OP_abs:
 909                 if (value_less (result_val,
 910                                 value_zero (value_type (result_val), not_lval)))
 911                   result_val = value_neg (result_val);
 912                 break;
 913               case DW_OP_neg:
 914                 result_val = value_neg (result_val);
 915                 break;
 916               case DW_OP_not:
 917                 dwarf_require_integral (value_type (result_val));
 918                 result_val = value_complement (result_val);
 919                 break;
 920               case DW_OP_plus_uconst:
 921                 dwarf_require_integral (value_type (result_val));
 922                 result = value_as_long (result_val);
 923                 op_ptr = read_uleb128 (op_ptr, op_end, &reg);
 924                 result += reg;
 925                 result_val = value_from_ulongest (address_type, result);
 926                 break;
 927               }
 928           }
 929           break;
 930
 931         case DW_OP_and:
 932         case DW_OP_div:
 933         case DW_OP_minus:
 934         case DW_OP_mod:
 935         case DW_OP_mul:
 936         case DW_OP_or:
 937         case DW_OP_plus:
 938         case DW_OP_shl:
 939         case DW_OP_shr:
 940         case DW_OP_shra:
 941         case DW_OP_xor:
 942         case DW_OP_le:
 943         case DW_OP_ge:
 944         case DW_OP_eq:
 945         case DW_OP_lt:
 946         case DW_OP_gt:
 947         case DW_OP_ne:
 948           {
 949             /* Binary operations.  */
 950             struct value *first, *second;
 951
 952             second = dwarf_expr_fetch (ctx, 0);
 953             dwarf_expr_pop (ctx);
 954
 955             first = dwarf_expr_fetch (ctx, 0);
 956             dwarf_expr_pop (ctx);
 957
 958             if (! base_types_equal_p (value_type (first), value_type (second)))
 959               error (_("Incompatible types on DWARF stack"));
 960
 961             switch (op)
 962               {
 963               case DW_OP_and:
 964                 dwarf_require_integral (value_type (first));
 965                 dwarf_require_integral (value_type (second));
 966                 result_val = value_binop (first, second, BINOP_BITWISE_AND);
 967                 break;
 968               case DW_OP_div:
 969                 result_val = value_binop (first, second, BINOP_DIV);
 970                 break;
 971               case DW_OP_minus:
 972                 result_val = value_binop (first, second, BINOP_SUB);
 973                 break;
 974               case DW_OP_mod:
 975                 {
 976                   int cast_back = 0;
 977                   struct type *orig_type = value_type (first);
 978
 979                   /* We have to special-case "old-style" untyped values
 980                      -- these must have mod computed using unsigned
 981                      math.  */
 982                   if (orig_type == address_type)
 983                     {
 984                       struct type *utype
 985                         = get_unsigned_type (ctx->gdbarch, orig_type);
 986
 987                       cast_back = 1;
 988                       first = value_cast (utype, first);
 989                       second = value_cast (utype, second);
 990                     }
 991                   /* Note that value_binop doesn't handle float or
 992                      decimal float here.  This seems unimportant.  */
 993                   result_val = value_binop (first, second, BINOP_MOD);
 994                   if (cast_back)
 995                     result_val = value_cast (orig_type, result_val);
 996                 }
 997                 break;
 998               case DW_OP_mul:
 999                 result_val = value_binop (first, second, BINOP_MUL);
1000                 break;
1001               case DW_OP_or:
1002                 dwarf_require_integral (value_type (first));
1003                 dwarf_require_integral (value_type (second));
1004                 result_val = value_binop (first, second, BINOP_BITWISE_IOR);
1005                 break;
1006               case DW_OP_plus:
1007                 result_val = value_binop (first, second, BINOP_ADD);
1008                 break;
1009               case DW_OP_shl:
1010                 dwarf_require_integral (value_type (first));
1011                 dwarf_require_integral (value_type (second));
1012                 result_val = value_binop (first, second, BINOP_LSH);
1013                 break;
1014               case DW_OP_shr:
1015                 dwarf_require_integral (value_type (first));
1016                 dwarf_require_integral (value_type (second));
1017                 if (!TYPE_UNSIGNED (value_type (first)))
1018                   {
1019                     struct type *utype
1020                       = get_unsigned_type (ctx->gdbarch, value_type (first));
1021
1022                     first = value_cast (utype, first);
1023                   }
1024
1025                 result_val = value_binop (first, second, BINOP_RSH);
1026                 /* Make sure we wind up with the same type we started
1027                    with.  */
1028                 if (value_type (result_val) != value_type (second))
1029                   result_val = value_cast (value_type (second), result_val);
1030                 break;
1031               case DW_OP_shra:
1032                 dwarf_require_integral (value_type (first));
1033                 dwarf_require_integral (value_type (second));
1034                 if (TYPE_UNSIGNED (value_type (first)))
1035                   {
1036                     struct type *stype
1037                       = get_signed_type (ctx->gdbarch, value_type (first));
1038
1039                     first = value_cast (stype, first);
1040                   }
1041
1042                 result_val = value_binop (first, second, BINOP_RSH);
1043                 /* Make sure we wind up with the same type we started
1044                    with.  */
1045                 if (value_type (result_val) != value_type (second))
1046                   result_val = value_cast (value_type (second), result_val);
1047                 break;
1048               case DW_OP_xor:
1049                 dwarf_require_integral (value_type (first));
1050                 dwarf_require_integral (value_type (second));
1051                 result_val = value_binop (first, second, BINOP_BITWISE_XOR);
1052                 break;
1053               case DW_OP_le:
1054                 /* A <= B is !(B < A).  */
1055                 result = ! value_less (second, first);
1056                 result_val = value_from_ulongest (address_type, result);
1057                 break;
1058               case DW_OP_ge:
1059                 /* A >= B is !(A < B).  */
1060                 result = ! value_less (first, second);
1061                 result_val = value_from_ulongest (address_type, result);
1062                 break;
1063               case DW_OP_eq:
1064                 result = value_equal (first, second);
1065                 result_val = value_from_ulongest (address_type, result);
1066                 break;
1067               case DW_OP_lt:
1068                 result = value_less (first, second);
1069                 result_val = value_from_ulongest (address_type, result);
1070                 break;
1071               case DW_OP_gt:
1072                 /* A > B is B < A.  */
1073                 result = value_less (second, first);
1074                 result_val = value_from_ulongest (address_type, result);
1075                 break;
1076               case DW_OP_ne:
1077                 result = ! value_equal (first, second);
1078                 result_val = value_from_ulongest (address_type, result);
1079                 break;
1080               default:
1081                 internal_error (__FILE__, __LINE__,
1082                                 _("Can't be reached."));
1083               }
1084           }
1085           break;
1086
1087         case DW_OP_call_frame_cfa:
1088           result = (ctx->get_frame_cfa) (ctx->baton);
1089           result_val = value_from_ulongest (address_type, result);
1090           in_stack_memory = 1;
1091           break;
1092
1093         case DW_OP_GNU_push_tls_address:
1094           /* Variable is at a constant offset in the thread-local
1095           storage block into the objfile for the current thread and
1096           the dynamic linker module containing this expression.  Here
1097           we return returns the offset from that base.  The top of the
1098           stack has the offset from the beginning of the thread
1099           control block at which the variable is located.  Nothing
1100           should follow this operator, so the top of stack would be
1101           returned.  */
1102           result = value_as_long (dwarf_expr_fetch (ctx, 0));
1103           dwarf_expr_pop (ctx);
1104           result = (ctx->get_tls_address) (ctx->baton, result);
1105           result_val = value_from_ulongest (address_type, result);
1106           break;
1107
1108         case DW_OP_skip:
1109           offset = extract_signed_integer (op_ptr, 2, byte_order);
1110           op_ptr += 2;
1111           op_ptr += offset;
1112           goto no_push;
1113
1114         case DW_OP_bra:
1115           {
1116             struct value *val;
1117
1118             offset = extract_signed_integer (op_ptr, 2, byte_order);
1119             op_ptr += 2;
1120             val = dwarf_expr_fetch (ctx, 0);
1121             dwarf_require_integral (value_type (val));
1122             if (value_as_long (val) != 0)
1123               op_ptr += offset;
1124             dwarf_expr_pop (ctx);
1125           }
1126           goto no_push;
1127
1128         case DW_OP_nop:
1129           goto no_push;
1130
1131         case DW_OP_piece:
1132           {
1133             ULONGEST size;
1134
1135             /* Record the piece.  */
1136             op_ptr = read_uleb128 (op_ptr, op_end, &size);
1137             add_piece (ctx, 8 * size, 0);
1138
1139             /* Pop off the address/regnum, and reset the location
1140                type.  */
1141             if (ctx->location != DWARF_VALUE_LITERAL
1142                 && ctx->location != DWARF_VALUE_OPTIMIZED_OUT)
1143               dwarf_expr_pop (ctx);
1144             ctx->location = DWARF_VALUE_MEMORY;
1145           }
1146           goto no_push;
1147
1148         case DW_OP_bit_piece:
1149           {
1150             ULONGEST size, offset;
1151
1152             /* Record the piece.  */
1153             op_ptr = read_uleb128 (op_ptr, op_end, &size);
1154             op_ptr = read_uleb128 (op_ptr, op_end, &offset);
1155             add_piece (ctx, size, offset);
1156
1157             /* Pop off the address/regnum, and reset the location
1158                type.  */
1159             if (ctx->location != DWARF_VALUE_LITERAL
1160                 && ctx->location != DWARF_VALUE_OPTIMIZED_OUT)
1161               dwarf_expr_pop (ctx);
1162             ctx->location = DWARF_VALUE_MEMORY;
1163           }
1164           goto no_push;
1165
1166         case DW_OP_GNU_uninit:
1167           if (op_ptr != op_end)
1168             error (_("DWARF-2 expression error: DW_OP_GNU_uninit must always "
1169                    "be the very last op."));
1170
1171           ctx->initialized = 0;
1172           goto no_push;
1173
1174         case DW_OP_call2:
1175           result = extract_unsigned_integer (op_ptr, 2, byte_order);
1176           op_ptr += 2;
1177           ctx->dwarf_call (ctx, result);
1178           goto no_push;
1179
1180         case DW_OP_call4:
1181           result = extract_unsigned_integer (op_ptr, 4, byte_order);
1182           op_ptr += 4;
1183           ctx->dwarf_call (ctx, result);
1184           goto no_push;
1185
1186         case DW_OP_GNU_entry_value:
1187           /* This operation is not yet supported by GDB.  */
1188           ctx->location = DWARF_VALUE_OPTIMIZED_OUT;
1189           ctx->stack_len = 0;
1190           ctx->num_pieces = 0;
1191           goto abort_expression;
1192
1193         case DW_OP_GNU_const_type:
1194           {
1195             ULONGEST type_die;
1196             int n;
1197             const gdb_byte *data;
1198             struct type *type;
1199
1200             op_ptr = read_uleb128 (op_ptr, op_end, &type_die);
1201             n = *op_ptr++;
1202             data = op_ptr;
1203             op_ptr += n;
1204
1205             type = dwarf_get_base_type (ctx, type_die, n);
1206             result_val = value_from_contents (type, data);
1207           }
1208           break;
1209
1210         case DW_OP_GNU_regval_type:
1211           {
1212             ULONGEST type_die;
1213             struct type *type;
1214
1215             op_ptr = read_uleb128 (op_ptr, op_end, &reg);
1216             op_ptr = read_uleb128 (op_ptr, op_end, &type_die);
1217
1218             type = dwarf_get_base_type (ctx, type_die, 0);
1219             result = (ctx->read_reg) (ctx->baton, reg);
1220             result_val = value_from_ulongest (type, result);
1221           }
1222           break;
1223
1224         case DW_OP_GNU_convert:
1225         case DW_OP_GNU_reinterpret:
1226           {
1227             ULONGEST type_die;
1228             struct type *type;
1229
1230             op_ptr = read_uleb128 (op_ptr, op_end, &type_die);
1231
1232             type = dwarf_get_base_type (ctx, type_die, 0);
1233
1234             result_val = dwarf_expr_fetch (ctx, 0);
1235             dwarf_expr_pop (ctx);
1236
1237             if (op == DW_OP_GNU_convert)
1238               result_val = value_cast (type, result_val);
1239             else if (type == value_type (result_val))
1240               {
1241                 /* Nothing.  */
1242               }
1243             else if (TYPE_LENGTH (type)
1244                      != TYPE_LENGTH (value_type (result_val)))
1245               error (_("DW_OP_GNU_reinterpret has wrong size"));
1246             else
1247               result_val
1248                 = value_from_contents (type,
1249                                        value_contents_all (result_val));
1250           }
1251           break;
1252
1253         default:
1254           error (_("Unhandled dwarf expression opcode 0x%x"), op);
1255         }
1256
1257       /* Most things push a result value.  */
1258       gdb_assert (result_val != NULL);
1259       dwarf_expr_push (ctx, result_val, in_stack_memory);
1260     no_push:
1261       ;
1262     }
1263
1264   /* To simplify our main caller, if the result is an implicit
1265      pointer, then make a pieced value.  This is ok because we can't
1266      have implicit pointers in contexts where pieces are invalid.  */
1267   if (ctx->location == DWARF_VALUE_IMPLICIT_POINTER)
1268     add_piece (ctx, 8 * ctx->addr_size, 0);
1269
1270 abort_expression:
1271   ctx->recursion_depth--;
1272   gdb_assert (ctx->recursion_depth >= 0);
1273 }
1274
1275 void
1276 _initialize_dwarf2expr (void)
1277 {
1278   dwarf_arch_cookie
1279     = gdbarch_data_register_post_init (dwarf_gdbarch_types_init);
1280 }