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 |= -(((LONGEST) 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->funcs->get_base_type)
 470     {
 471       result = ctx->funcs->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       /* The DWARF expression might have a bug causing an infinite
 525          loop.  In that case, quitting is the only way out.  */
 526       QUIT;
 527
 528       switch (op)
 529         {
 530         case DW_OP_lit0:
 531         case DW_OP_lit1:
 532         case DW_OP_lit2:
 533         case DW_OP_lit3:
 534         case DW_OP_lit4:
 535         case DW_OP_lit5:
 536         case DW_OP_lit6:
 537         case DW_OP_lit7:
 538         case DW_OP_lit8:
 539         case DW_OP_lit9:
 540         case DW_OP_lit10:
 541         case DW_OP_lit11:
 542         case DW_OP_lit12:
 543         case DW_OP_lit13:
 544         case DW_OP_lit14:
 545         case DW_OP_lit15:
 546         case DW_OP_lit16:
 547         case DW_OP_lit17:
 548         case DW_OP_lit18:
 549         case DW_OP_lit19:
 550         case DW_OP_lit20:
 551         case DW_OP_lit21:
 552         case DW_OP_lit22:
 553         case DW_OP_lit23:
 554         case DW_OP_lit24:
 555         case DW_OP_lit25:
 556         case DW_OP_lit26:
 557         case DW_OP_lit27:
 558         case DW_OP_lit28:
 559         case DW_OP_lit29:
 560         case DW_OP_lit30:
 561         case DW_OP_lit31:
 562           result = op - DW_OP_lit0;
 563           result_val = value_from_ulongest (address_type, result);
 564           break;
 565
 566         case DW_OP_addr:
 567           result = extract_unsigned_integer (op_ptr,
 568                                              ctx->addr_size, byte_order);
 569           op_ptr += ctx->addr_size;
 570           /* Some versions of GCC emit DW_OP_addr before
 571              DW_OP_GNU_push_tls_address.  In this case the value is an
 572              index, not an address.  We don't support things like
 573              branching between the address and the TLS op.  */
 574           if (op_ptr >= op_end || *op_ptr != DW_OP_GNU_push_tls_address)
 575             result += ctx->offset;
 576           result_val = value_from_ulongest (address_type, result);
 577           break;
 578
 579         case DW_OP_const1u:
 580           result = extract_unsigned_integer (op_ptr, 1, byte_order);
 581           result_val = value_from_ulongest (address_type, result);
 582           op_ptr += 1;
 583           break;
 584         case DW_OP_const1s:
 585           result = extract_signed_integer (op_ptr, 1, byte_order);
 586           result_val = value_from_ulongest (address_type, result);
 587           op_ptr += 1;
 588           break;
 589         case DW_OP_const2u:
 590           result = extract_unsigned_integer (op_ptr, 2, byte_order);
 591           result_val = value_from_ulongest (address_type, result);
 592           op_ptr += 2;
 593           break;
 594         case DW_OP_const2s:
 595           result = extract_signed_integer (op_ptr, 2, byte_order);
 596           result_val = value_from_ulongest (address_type, result);
 597           op_ptr += 2;
 598           break;
 599         case DW_OP_const4u:
 600           result = extract_unsigned_integer (op_ptr, 4, byte_order);
 601           result_val = value_from_ulongest (address_type, result);
 602           op_ptr += 4;
 603           break;
 604         case DW_OP_const4s:
 605           result = extract_signed_integer (op_ptr, 4, byte_order);
 606           result_val = value_from_ulongest (address_type, result);
 607           op_ptr += 4;
 608           break;
 609         case DW_OP_const8u:
 610           result = extract_unsigned_integer (op_ptr, 8, byte_order);
 611           result_val = value_from_ulongest (address_type, result);
 612           op_ptr += 8;
 613           break;
 614         case DW_OP_const8s:
 615           result = extract_signed_integer (op_ptr, 8, byte_order);
 616           result_val = value_from_ulongest (address_type, result);
 617           op_ptr += 8;
 618           break;
 619         case DW_OP_constu:
 620           op_ptr = read_uleb128 (op_ptr, op_end, &uoffset);
 621           result = uoffset;
 622           result_val = value_from_ulongest (address_type, result);
 623           break;
 624         case DW_OP_consts:
 625           op_ptr = read_sleb128 (op_ptr, op_end, &offset);
 626           result = offset;
 627           result_val = value_from_ulongest (address_type, result);
 628           break;
 629
 630         /* The DW_OP_reg operations are required to occur alone in
 631            location expressions.  */
 632         case DW_OP_reg0:
 633         case DW_OP_reg1:
 634         case DW_OP_reg2:
 635         case DW_OP_reg3:
 636         case DW_OP_reg4:
 637         case DW_OP_reg5:
 638         case DW_OP_reg6:
 639         case DW_OP_reg7:
 640         case DW_OP_reg8:
 641         case DW_OP_reg9:
 642         case DW_OP_reg10:
 643         case DW_OP_reg11:
 644         case DW_OP_reg12:
 645         case DW_OP_reg13:
 646         case DW_OP_reg14:
 647         case DW_OP_reg15:
 648         case DW_OP_reg16:
 649         case DW_OP_reg17:
 650         case DW_OP_reg18:
 651         case DW_OP_reg19:
 652         case DW_OP_reg20:
 653         case DW_OP_reg21:
 654         case DW_OP_reg22:
 655         case DW_OP_reg23:
 656         case DW_OP_reg24:
 657         case DW_OP_reg25:
 658         case DW_OP_reg26:
 659         case DW_OP_reg27:
 660         case DW_OP_reg28:
 661         case DW_OP_reg29:
 662         case DW_OP_reg30:
 663         case DW_OP_reg31:
 664           if (op_ptr != op_end
 665               && *op_ptr != DW_OP_piece
 666               && *op_ptr != DW_OP_bit_piece
 667               && *op_ptr != DW_OP_GNU_uninit)
 668             error (_("DWARF-2 expression error: DW_OP_reg operations must be "
 669                      "used either alone or in conjunction with DW_OP_piece "
 670                      "or DW_OP_bit_piece."));
 671
 672           result = op - DW_OP_reg0;
 673           result_val = value_from_ulongest (address_type, result);
 674           ctx->location = DWARF_VALUE_REGISTER;
 675           break;
 676
 677         case DW_OP_regx:
 678           op_ptr = read_uleb128 (op_ptr, op_end, &reg);
 679           dwarf_expr_require_composition (op_ptr, op_end, "DW_OP_regx");
 680
 681           result = reg;
 682           result_val = value_from_ulongest (address_type, result);
 683           ctx->location = DWARF_VALUE_REGISTER;
 684           break;
 685
 686         case DW_OP_implicit_value:
 687           {
 688             ULONGEST len;
 689
 690             op_ptr = read_uleb128 (op_ptr, op_end, &len);
 691             if (op_ptr + len > op_end)
 692               error (_("DW_OP_implicit_value: too few bytes available."));
 693             ctx->len = len;
 694             ctx->data = op_ptr;
 695             ctx->location = DWARF_VALUE_LITERAL;
 696             op_ptr += len;
 697             dwarf_expr_require_composition (op_ptr, op_end,
 698                                             "DW_OP_implicit_value");
 699           }
 700           goto no_push;
 701
 702         case DW_OP_stack_value:
 703           ctx->location = DWARF_VALUE_STACK;
 704           dwarf_expr_require_composition (op_ptr, op_end, "DW_OP_stack_value");
 705           goto no_push;
 706
 707         case DW_OP_GNU_implicit_pointer:
 708           {
 709             ULONGEST die;
 710             LONGEST len;
 711
 712             /* The referred-to DIE.  */
 713             ctx->len = extract_unsigned_integer (op_ptr, ctx->addr_size,
 714                                                  byte_order);
 715             op_ptr += ctx->addr_size;
 716
 717             /* The byte offset into the data.  */
 718             op_ptr = read_sleb128 (op_ptr, op_end, &len);
 719             result = (ULONGEST) len;
 720             result_val = value_from_ulongest (address_type, result);
 721
 722             ctx->location = DWARF_VALUE_IMPLICIT_POINTER;
 723             dwarf_expr_require_composition (op_ptr, op_end,
 724                                             "DW_OP_GNU_implicit_pointer");
 725           }
 726           break;
 727
 728         case DW_OP_breg0:
 729         case DW_OP_breg1:
 730         case DW_OP_breg2:
 731         case DW_OP_breg3:
 732         case DW_OP_breg4:
 733         case DW_OP_breg5:
 734         case DW_OP_breg6:
 735         case DW_OP_breg7:
 736         case DW_OP_breg8:
 737         case DW_OP_breg9:
 738         case DW_OP_breg10:
 739         case DW_OP_breg11:
 740         case DW_OP_breg12:
 741         case DW_OP_breg13:
 742         case DW_OP_breg14:
 743         case DW_OP_breg15:
 744         case DW_OP_breg16:
 745         case DW_OP_breg17:
 746         case DW_OP_breg18:
 747         case DW_OP_breg19:
 748         case DW_OP_breg20:
 749         case DW_OP_breg21:
 750         case DW_OP_breg22:
 751         case DW_OP_breg23:
 752         case DW_OP_breg24:
 753         case DW_OP_breg25:
 754         case DW_OP_breg26:
 755         case DW_OP_breg27:
 756         case DW_OP_breg28:
 757         case DW_OP_breg29:
 758         case DW_OP_breg30:
 759         case DW_OP_breg31:
 760           {
 761             op_ptr = read_sleb128 (op_ptr, op_end, &offset);
 762             result = (ctx->funcs->read_reg) (ctx->baton, op - DW_OP_breg0);
 763             result += offset;
 764             result_val = value_from_ulongest (address_type, result);
 765           }
 766           break;
 767         case DW_OP_bregx:
 768           {
 769             op_ptr = read_uleb128 (op_ptr, op_end, &reg);
 770             op_ptr = read_sleb128 (op_ptr, op_end, &offset);
 771             result = (ctx->funcs->read_reg) (ctx->baton, reg);
 772             result += offset;
 773             result_val = value_from_ulongest (address_type, result);
 774           }
 775           break;
 776         case DW_OP_fbreg:
 777           {
 778             const gdb_byte *datastart;
 779             size_t datalen;
 780             unsigned int before_stack_len;
 781
 782             op_ptr = read_sleb128 (op_ptr, op_end, &offset);
 783             /* Rather than create a whole new context, we simply
 784                record the stack length before execution, then reset it
 785                afterwards, effectively erasing whatever the recursive
 786                call put there.  */
 787             before_stack_len = ctx->stack_len;
 788             /* FIXME: cagney/2003-03-26: This code should be using
 789                get_frame_base_address(), and then implement a dwarf2
 790                specific this_base method.  */
 791             (ctx->funcs->get_frame_base) (ctx->baton, &datastart, &datalen);
 792             dwarf_expr_eval (ctx, datastart, datalen);
 793             if (ctx->location == DWARF_VALUE_MEMORY)
 794               result = dwarf_expr_fetch_address (ctx, 0);
 795             else if (ctx->location == DWARF_VALUE_REGISTER)
 796               result = (ctx->funcs->read_reg) (ctx->baton,
 797                                      value_as_long (dwarf_expr_fetch (ctx, 0)));
 798             else
 799               error (_("Not implemented: computing frame "
 800                        "base using explicit value operator"));
 801             result = result + offset;
 802             result_val = value_from_ulongest (address_type, result);
 803             in_stack_memory = 1;
 804             ctx->stack_len = before_stack_len;
 805             ctx->location = DWARF_VALUE_MEMORY;
 806           }
 807           break;
 808
 809         case DW_OP_dup:
 810           result_val = dwarf_expr_fetch (ctx, 0);
 811           in_stack_memory = dwarf_expr_fetch_in_stack_memory (ctx, 0);
 812           break;
 813
 814         case DW_OP_drop:
 815           dwarf_expr_pop (ctx);
 816           goto no_push;
 817
 818         case DW_OP_pick:
 819           offset = *op_ptr++;
 820           result_val = dwarf_expr_fetch (ctx, offset);
 821           in_stack_memory = dwarf_expr_fetch_in_stack_memory (ctx, offset);
 822           break;
 823
 824         case DW_OP_swap:
 825           {
 826             struct dwarf_stack_value t1, t2;
 827
 828             if (ctx->stack_len < 2)
 829                error (_("Not enough elements for "
 830                         "DW_OP_swap.  Need 2, have %d."),
 831                       ctx->stack_len);
 832             t1 = ctx->stack[ctx->stack_len - 1];
 833             t2 = ctx->stack[ctx->stack_len - 2];
 834             ctx->stack[ctx->stack_len - 1] = t2;
 835             ctx->stack[ctx->stack_len - 2] = t1;
 836             goto no_push;
 837           }
 838
 839         case DW_OP_over:
 840           result_val = dwarf_expr_fetch (ctx, 1);
 841           in_stack_memory = dwarf_expr_fetch_in_stack_memory (ctx, 1);
 842           break;
 843
 844         case DW_OP_rot:
 845           {
 846             struct dwarf_stack_value t1, t2, t3;
 847
 848             if (ctx->stack_len < 3)
 849                error (_("Not enough elements for "
 850                         "DW_OP_rot.  Need 3, have %d."),
 851                       ctx->stack_len);
 852             t1 = ctx->stack[ctx->stack_len - 1];
 853             t2 = ctx->stack[ctx->stack_len - 2];
 854             t3 = ctx->stack[ctx->stack_len - 3];
 855             ctx->stack[ctx->stack_len - 1] = t2;
 856             ctx->stack[ctx->stack_len - 2] = t3;
 857             ctx->stack[ctx->stack_len - 3] = t1;
 858             goto no_push;
 859           }
 860
 861         case DW_OP_deref:
 862         case DW_OP_deref_size:
 863         case DW_OP_GNU_deref_type:
 864           {
 865             int addr_size = (op == DW_OP_deref ? ctx->addr_size : *op_ptr++);
 866             gdb_byte *buf = alloca (addr_size);
 867             CORE_ADDR addr = dwarf_expr_fetch_address (ctx, 0);
 868             struct type *type;
 869
 870             dwarf_expr_pop (ctx);
 871
 872             if (op == DW_OP_GNU_deref_type)
 873               {
 874                 ULONGEST type_die;
 875
 876                 op_ptr = read_uleb128 (op_ptr, op_end, &type_die);
 877                 type = dwarf_get_base_type (ctx, type_die, 0);
 878               }
 879             else
 880               type = address_type;
 881
 882             (ctx->funcs->read_mem) (ctx->baton, buf, addr, addr_size);
 883
 884             /* If the size of the object read from memory is different
 885                from the type length, we need to zero-extend it.  */
 886             if (TYPE_LENGTH (type) != addr_size)
 887               {
 888                 ULONGEST result =
 889                   extract_unsigned_integer (buf, addr_size, byte_order);
 890
 891                 buf = alloca (TYPE_LENGTH (type));
 892                 store_unsigned_integer (buf, TYPE_LENGTH (type),
 893                                         byte_order, result);
 894               }
 895
 896             result_val = value_from_contents_and_address (type, buf, addr);
 897             break;
 898           }
 899
 900         case DW_OP_abs:
 901         case DW_OP_neg:
 902         case DW_OP_not:
 903         case DW_OP_plus_uconst:
 904           {
 905             /* Unary operations.  */
 906             result_val = dwarf_expr_fetch (ctx, 0);
 907             dwarf_expr_pop (ctx);
 908
 909             switch (op)
 910               {
 911               case DW_OP_abs:
 912                 if (value_less (result_val,
 913                                 value_zero (value_type (result_val), not_lval)))
 914                   result_val = value_neg (result_val);
 915                 break;
 916               case DW_OP_neg:
 917                 result_val = value_neg (result_val);
 918                 break;
 919               case DW_OP_not:
 920                 dwarf_require_integral (value_type (result_val));
 921                 result_val = value_complement (result_val);
 922                 break;
 923               case DW_OP_plus_uconst:
 924                 dwarf_require_integral (value_type (result_val));
 925                 result = value_as_long (result_val);
 926                 op_ptr = read_uleb128 (op_ptr, op_end, &reg);
 927                 result += reg;
 928                 result_val = value_from_ulongest (address_type, result);
 929                 break;
 930               }
 931           }
 932           break;
 933
 934         case DW_OP_and:
 935         case DW_OP_div:
 936         case DW_OP_minus:
 937         case DW_OP_mod:
 938         case DW_OP_mul:
 939         case DW_OP_or:
 940         case DW_OP_plus:
 941         case DW_OP_shl:
 942         case DW_OP_shr:
 943         case DW_OP_shra:
 944         case DW_OP_xor:
 945         case DW_OP_le:
 946         case DW_OP_ge:
 947         case DW_OP_eq:
 948         case DW_OP_lt:
 949         case DW_OP_gt:
 950         case DW_OP_ne:
 951           {
 952             /* Binary operations.  */
 953             struct value *first, *second;
 954
 955             second = dwarf_expr_fetch (ctx, 0);
 956             dwarf_expr_pop (ctx);
 957
 958             first = dwarf_expr_fetch (ctx, 0);
 959             dwarf_expr_pop (ctx);
 960
 961             if (! base_types_equal_p (value_type (first), value_type (second)))
 962               error (_("Incompatible types on DWARF stack"));
 963
 964             switch (op)
 965               {
 966               case DW_OP_and:
 967                 dwarf_require_integral (value_type (first));
 968                 dwarf_require_integral (value_type (second));
 969                 result_val = value_binop (first, second, BINOP_BITWISE_AND);
 970                 break;
 971               case DW_OP_div:
 972                 result_val = value_binop (first, second, BINOP_DIV);
 973                 break;
 974               case DW_OP_minus:
 975                 result_val = value_binop (first, second, BINOP_SUB);
 976                 break;
 977               case DW_OP_mod:
 978                 {
 979                   int cast_back = 0;
 980                   struct type *orig_type = value_type (first);
 981
 982                   /* We have to special-case "old-style" untyped values
 983                      -- these must have mod computed using unsigned
 984                      math.  */
 985                   if (orig_type == address_type)
 986                     {
 987                       struct type *utype
 988                         = get_unsigned_type (ctx->gdbarch, orig_type);
 989
 990                       cast_back = 1;
 991                       first = value_cast (utype, first);
 992                       second = value_cast (utype, second);
 993                     }
 994                   /* Note that value_binop doesn't handle float or
 995                      decimal float here.  This seems unimportant.  */
 996                   result_val = value_binop (first, second, BINOP_MOD);
 997                   if (cast_back)
 998                     result_val = value_cast (orig_type, result_val);
 999                 }
1000                 break;
1001               case DW_OP_mul:
1002                 result_val = value_binop (first, second, BINOP_MUL);
1003                 break;
1004               case DW_OP_or:
1005                 dwarf_require_integral (value_type (first));
1006                 dwarf_require_integral (value_type (second));
1007                 result_val = value_binop (first, second, BINOP_BITWISE_IOR);
1008                 break;
1009               case DW_OP_plus:
1010                 result_val = value_binop (first, second, BINOP_ADD);
1011                 break;
1012               case DW_OP_shl:
1013                 dwarf_require_integral (value_type (first));
1014                 dwarf_require_integral (value_type (second));
1015                 result_val = value_binop (first, second, BINOP_LSH);
1016                 break;
1017               case DW_OP_shr:
1018                 dwarf_require_integral (value_type (first));
1019                 dwarf_require_integral (value_type (second));
1020                 if (!TYPE_UNSIGNED (value_type (first)))
1021                   {
1022                     struct type *utype
1023                       = get_unsigned_type (ctx->gdbarch, value_type (first));
1024
1025                     first = value_cast (utype, first);
1026                   }
1027
1028                 result_val = value_binop (first, second, BINOP_RSH);
1029                 /* Make sure we wind up with the same type we started
1030                    with.  */
1031                 if (value_type (result_val) != value_type (second))
1032                   result_val = value_cast (value_type (second), result_val);
1033                 break;
1034               case DW_OP_shra:
1035                 dwarf_require_integral (value_type (first));
1036                 dwarf_require_integral (value_type (second));
1037                 if (TYPE_UNSIGNED (value_type (first)))
1038                   {
1039                     struct type *stype
1040                       = get_signed_type (ctx->gdbarch, value_type (first));
1041
1042                     first = value_cast (stype, first);
1043                   }
1044
1045                 result_val = value_binop (first, second, BINOP_RSH);
1046                 /* Make sure we wind up with the same type we started
1047                    with.  */
1048                 if (value_type (result_val) != value_type (second))
1049                   result_val = value_cast (value_type (second), result_val);
1050                 break;
1051               case DW_OP_xor:
1052                 dwarf_require_integral (value_type (first));
1053                 dwarf_require_integral (value_type (second));
1054                 result_val = value_binop (first, second, BINOP_BITWISE_XOR);
1055                 break;
1056               case DW_OP_le:
1057                 /* A <= B is !(B < A).  */
1058                 result = ! value_less (second, first);
1059                 result_val = value_from_ulongest (address_type, result);
1060                 break;
1061               case DW_OP_ge:
1062                 /* A >= B is !(A < B).  */
1063                 result = ! value_less (first, second);
1064                 result_val = value_from_ulongest (address_type, result);
1065                 break;
1066               case DW_OP_eq:
1067                 result = value_equal (first, second);
1068                 result_val = value_from_ulongest (address_type, result);
1069                 break;
1070               case DW_OP_lt:
1071                 result = value_less (first, second);
1072                 result_val = value_from_ulongest (address_type, result);
1073                 break;
1074               case DW_OP_gt:
1075                 /* A > B is B < A.  */
1076                 result = value_less (second, first);
1077                 result_val = value_from_ulongest (address_type, result);
1078                 break;
1079               case DW_OP_ne:
1080                 result = ! value_equal (first, second);
1081                 result_val = value_from_ulongest (address_type, result);
1082                 break;
1083               default:
1084                 internal_error (__FILE__, __LINE__,
1085                                 _("Can't be reached."));
1086               }
1087           }
1088           break;
1089
1090         case DW_OP_call_frame_cfa:
1091           result = (ctx->funcs->get_frame_cfa) (ctx->baton);
1092           result_val = value_from_ulongest (address_type, result);
1093           in_stack_memory = 1;
1094           break;
1095
1096         case DW_OP_GNU_push_tls_address:
1097           /* Variable is at a constant offset in the thread-local
1098           storage block into the objfile for the current thread and
1099           the dynamic linker module containing this expression.  Here
1100           we return returns the offset from that base.  The top of the
1101           stack has the offset from the beginning of the thread
1102           control block at which the variable is located.  Nothing
1103           should follow this operator, so the top of stack would be
1104           returned.  */
1105           result = value_as_long (dwarf_expr_fetch (ctx, 0));
1106           dwarf_expr_pop (ctx);
1107           result = (ctx->funcs->get_tls_address) (ctx->baton, result);
1108           result_val = value_from_ulongest (address_type, result);
1109           break;
1110
1111         case DW_OP_skip:
1112           offset = extract_signed_integer (op_ptr, 2, byte_order);
1113           op_ptr += 2;
1114           op_ptr += offset;
1115           goto no_push;
1116
1117         case DW_OP_bra:
1118           {
1119             struct value *val;
1120
1121             offset = extract_signed_integer (op_ptr, 2, byte_order);
1122             op_ptr += 2;
1123             val = dwarf_expr_fetch (ctx, 0);
1124             dwarf_require_integral (value_type (val));
1125             if (value_as_long (val) != 0)
1126               op_ptr += offset;
1127             dwarf_expr_pop (ctx);
1128           }
1129           goto no_push;
1130
1131         case DW_OP_nop:
1132           goto no_push;
1133
1134         case DW_OP_piece:
1135           {
1136             ULONGEST size;
1137
1138             /* Record the piece.  */
1139             op_ptr = read_uleb128 (op_ptr, op_end, &size);
1140             add_piece (ctx, 8 * size, 0);
1141
1142             /* Pop off the address/regnum, and reset the location
1143                type.  */
1144             if (ctx->location != DWARF_VALUE_LITERAL
1145                 && ctx->location != DWARF_VALUE_OPTIMIZED_OUT)
1146               dwarf_expr_pop (ctx);
1147             ctx->location = DWARF_VALUE_MEMORY;
1148           }
1149           goto no_push;
1150
1151         case DW_OP_bit_piece:
1152           {
1153             ULONGEST size, offset;
1154
1155             /* Record the piece.  */
1156             op_ptr = read_uleb128 (op_ptr, op_end, &size);
1157             op_ptr = read_uleb128 (op_ptr, op_end, &offset);
1158             add_piece (ctx, size, offset);
1159
1160             /* Pop off the address/regnum, and reset the location
1161                type.  */
1162             if (ctx->location != DWARF_VALUE_LITERAL
1163                 && ctx->location != DWARF_VALUE_OPTIMIZED_OUT)
1164               dwarf_expr_pop (ctx);
1165             ctx->location = DWARF_VALUE_MEMORY;
1166           }
1167           goto no_push;
1168
1169         case DW_OP_GNU_uninit:
1170           if (op_ptr != op_end)
1171             error (_("DWARF-2 expression error: DW_OP_GNU_uninit must always "
1172                    "be the very last op."));
1173
1174           ctx->initialized = 0;
1175           goto no_push;
1176
1177         case DW_OP_call2:
1178           result = extract_unsigned_integer (op_ptr, 2, byte_order);
1179           op_ptr += 2;
1180           ctx->funcs->dwarf_call (ctx, result);
1181           goto no_push;
1182
1183         case DW_OP_call4:
1184           result = extract_unsigned_integer (op_ptr, 4, byte_order);
1185           op_ptr += 4;
1186           ctx->funcs->dwarf_call (ctx, result);
1187           goto no_push;
1188
1189         case DW_OP_GNU_entry_value:
1190           /* This operation is not yet supported by GDB.  */
1191           ctx->location = DWARF_VALUE_OPTIMIZED_OUT;
1192           ctx->stack_len = 0;
1193           ctx->num_pieces = 0;
1194           goto abort_expression;
1195
1196         case DW_OP_GNU_const_type:
1197           {
1198             ULONGEST type_die;
1199             int n;
1200             const gdb_byte *data;
1201             struct type *type;
1202
1203             op_ptr = read_uleb128 (op_ptr, op_end, &type_die);
1204             n = *op_ptr++;
1205             data = op_ptr;
1206             op_ptr += n;
1207
1208             type = dwarf_get_base_type (ctx, type_die, n);
1209             result_val = value_from_contents (type, data);
1210           }
1211           break;
1212
1213         case DW_OP_GNU_regval_type:
1214           {
1215             ULONGEST type_die;
1216             struct type *type;
1217
1218             op_ptr = read_uleb128 (op_ptr, op_end, &reg);
1219             op_ptr = read_uleb128 (op_ptr, op_end, &type_die);
1220
1221             type = dwarf_get_base_type (ctx, type_die, 0);
1222             result = (ctx->funcs->read_reg) (ctx->baton, reg);
1223             result_val = value_from_ulongest (address_type, result);
1224             result_val = value_from_contents (type,
1225                                               value_contents_all (result_val));
1226           }
1227           break;
1228
1229         case DW_OP_GNU_convert:
1230         case DW_OP_GNU_reinterpret:
1231           {
1232             ULONGEST type_die;
1233             struct type *type;
1234
1235             op_ptr = read_uleb128 (op_ptr, op_end, &type_die);
1236
1237             if (type_die == 0)
1238               type = address_type;
1239             else
1240               type = dwarf_get_base_type (ctx, type_die, 0);
1241
1242             result_val = dwarf_expr_fetch (ctx, 0);
1243             dwarf_expr_pop (ctx);
1244
1245             if (op == DW_OP_GNU_convert)
1246               result_val = value_cast (type, result_val);
1247             else if (type == value_type (result_val))
1248               {
1249                 /* Nothing.  */
1250               }
1251             else if (TYPE_LENGTH (type)
1252                      != TYPE_LENGTH (value_type (result_val)))
1253               error (_("DW_OP_GNU_reinterpret has wrong size"));
1254             else
1255               result_val
1256                 = value_from_contents (type,
1257                                        value_contents_all (result_val));
1258           }
1259           break;
1260
1261         default:
1262           error (_("Unhandled dwarf expression opcode 0x%x"), op);
1263         }
1264
1265       /* Most things push a result value.  */
1266       gdb_assert (result_val != NULL);
1267       dwarf_expr_push (ctx, result_val, in_stack_memory);
1268     no_push:
1269       ;
1270     }
1271
1272   /* To simplify our main caller, if the result is an implicit
1273      pointer, then make a pieced value.  This is ok because we can't
1274      have implicit pointers in contexts where pieces are invalid.  */
1275   if (ctx->location == DWARF_VALUE_IMPLICIT_POINTER)
1276     add_piece (ctx, 8 * ctx->addr_size, 0);
1277
1278 abort_expression:
1279   ctx->recursion_depth--;
1280   gdb_assert (ctx->recursion_depth >= 0);
1281 }
1282
1283 void
1284 _initialize_dwarf2expr (void)
1285 {
1286   dwarf_arch_cookie
1287     = gdbarch_data_register_post_init (dwarf_gdbarch_types_init);
1288 }