GDB (xrefs)
/tmp/gdb-7.10/gdb/dwarf2expr.c
Go to the documentation of this file.
1 /* DWARF 2 Expression Evaluator.
2 
3  Copyright (C) 2001-2015 Free Software Foundation, Inc.
4 
5  Contributed by Daniel Berlin (dan@dberlin.org)
6 
7  This file is part of GDB.
8 
9  This program is free software; you can redistribute it and/or modify
10  it under the terms of the GNU General Public License as published by
11  the Free Software Foundation; either version 3 of the License, or
12  (at your option) any later version.
13 
14  This program is distributed in the hope that it will be useful,
15  but WITHOUT ANY WARRANTY; without even the implied warranty of
16  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17  GNU General Public License for more details.
18 
19  You should have received a copy of the GNU General Public License
20  along with this program. If not, see <http://www.gnu.org/licenses/>. */
21 
22 #include "defs.h"
23 #include "symtab.h"
24 #include "gdbtypes.h"
25 #include "value.h"
26 #include "gdbcore.h"
27 #include "dwarf2.h"
28 #include "dwarf2expr.h"
29 
30 /* Local prototypes. */
31 
32 static void execute_stack_op (struct dwarf_expr_context *,
33  const gdb_byte *, const gdb_byte *);
34 
35 /* Cookie for gdbarch data. */
36 
38 
39 /* This holds gdbarch-specific types used by the DWARF expression
40  evaluator. See comments in execute_stack_op. */
41 
43 {
44  struct type *dw_types[3];
45 };
46 
47 /* Allocate and fill in dwarf_gdbarch_types for an arch. */
48 
49 static void *
51 {
52  struct dwarf_gdbarch_types *types
53  = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct dwarf_gdbarch_types);
54 
55  /* The types themselves are lazily initialized. */
56 
57  return types;
58 }
59 
60 /* Return the type used for DWARF operations where the type is
61  unspecified in the DWARF spec. Only certain sizes are
62  supported. */
63 
64 static struct type *
66 {
67  struct dwarf_gdbarch_types *types = gdbarch_data (ctx->gdbarch,
68  dwarf_arch_cookie);
69  int ndx;
70 
71  if (ctx->addr_size == 2)
72  ndx = 0;
73  else if (ctx->addr_size == 4)
74  ndx = 1;
75  else if (ctx->addr_size == 8)
76  ndx = 2;
77  else
78  error (_("Unsupported address size in DWARF expressions: %d bits"),
79  8 * ctx->addr_size);
80 
81  if (types->dw_types[ndx] == NULL)
82  types->dw_types[ndx]
83  = arch_integer_type (ctx->gdbarch,
84  8 * ctx->addr_size,
85  0, "<signed DWARF address type>");
86 
87  return types->dw_types[ndx];
88 }
89 
90 /* Create a new context for the expression evaluator. */
91 
92 struct dwarf_expr_context *
94 {
95  struct dwarf_expr_context *retval;
96 
97  retval = xcalloc (1, sizeof (struct dwarf_expr_context));
98  retval->stack_len = 0;
99  retval->stack_allocated = 10;
100  retval->stack = xmalloc (retval->stack_allocated
101  * sizeof (struct dwarf_stack_value));
102  retval->num_pieces = 0;
103  retval->pieces = 0;
104  retval->max_recursion_depth = 0x100;
105  return retval;
106 }
107 
108 /* Release the memory allocated to CTX. */
109 
110 void
112 {
113  xfree (ctx->stack);
114  xfree (ctx->pieces);
115  xfree (ctx);
116 }
117 
118 /* Helper for make_cleanup_free_dwarf_expr_context. */
119 
120 static void
122 {
124 }
125 
126 /* Return a cleanup that calls free_dwarf_expr_context. */
127 
128 struct cleanup *
130 {
132 }
133 
134 /* Expand the memory allocated to CTX's stack to contain at least
135  NEED more elements than are currently used. */
136 
137 static void
138 dwarf_expr_grow_stack (struct dwarf_expr_context *ctx, size_t need)
139 {
140  if (ctx->stack_len + need > ctx->stack_allocated)
141  {
142  size_t newlen = ctx->stack_len + need + 10;
143 
144  ctx->stack = xrealloc (ctx->stack,
145  newlen * sizeof (struct dwarf_stack_value));
146  ctx->stack_allocated = newlen;
147  }
148 }
149 
150 /* Push VALUE onto CTX's stack. */
151 
152 static void
154  int in_stack_memory)
155 {
156  struct dwarf_stack_value *v;
157 
158  dwarf_expr_grow_stack (ctx, 1);
159  v = &ctx->stack[ctx->stack_len++];
160  v->value = value;
162 }
163 
164 /* Push VALUE onto CTX's stack. */
165 
166 void
168  int in_stack_memory)
169 {
170  dwarf_expr_push (ctx,
172  in_stack_memory);
173 }
174 
175 /* Pop the top item off of CTX's stack. */
176 
177 static void
179 {
180  if (ctx->stack_len <= 0)
181  error (_("dwarf expression stack underflow"));
182  ctx->stack_len--;
183 }
184 
185 /* Retrieve the N'th item on CTX's stack. */
186 
187 struct value *
189 {
190  if (ctx->stack_len <= n)
191  error (_("Asked for position %d of stack, "
192  "stack only has %d elements on it."),
193  n, ctx->stack_len);
194  return ctx->stack[ctx->stack_len - (1 + n)].value;
195 }
196 
197 /* Require that TYPE be an integral type; throw an exception if not. */
198 
199 static void
201 {
202  if (TYPE_CODE (type) != TYPE_CODE_INT
203  && TYPE_CODE (type) != TYPE_CODE_CHAR
204  && TYPE_CODE (type) != TYPE_CODE_BOOL)
205  error (_("integral type expected in DWARF expression"));
206 }
207 
208 /* Return the unsigned form of TYPE. TYPE is necessarily an integral
209  type. */
210 
211 static struct type *
213 {
214  switch (TYPE_LENGTH (type))
215  {
216  case 1:
217  return builtin_type (gdbarch)->builtin_uint8;
218  case 2:
219  return builtin_type (gdbarch)->builtin_uint16;
220  case 4:
221  return builtin_type (gdbarch)->builtin_uint32;
222  case 8:
223  return builtin_type (gdbarch)->builtin_uint64;
224  default:
225  error (_("no unsigned variant found for type, while evaluating "
226  "DWARF expression"));
227  }
228 }
229 
230 /* Return the signed form of TYPE. TYPE is necessarily an integral
231  type. */
232 
233 static struct type *
235 {
236  switch (TYPE_LENGTH (type))
237  {
238  case 1:
239  return builtin_type (gdbarch)->builtin_int8;
240  case 2:
241  return builtin_type (gdbarch)->builtin_int16;
242  case 4:
243  return builtin_type (gdbarch)->builtin_int32;
244  case 8:
245  return builtin_type (gdbarch)->builtin_int64;
246  default:
247  error (_("no signed variant found for type, while evaluating "
248  "DWARF expression"));
249  }
250 }
251 
252 /* Retrieve the N'th item on CTX's stack, converted to an address. */
253 
254 CORE_ADDR
256 {
257  struct value *result_val = dwarf_expr_fetch (ctx, n);
258  enum bfd_endian byte_order = gdbarch_byte_order (ctx->gdbarch);
259  ULONGEST result;
260 
261  dwarf_require_integral (value_type (result_val));
262  result = extract_unsigned_integer (value_contents (result_val),
263  TYPE_LENGTH (value_type (result_val)),
264  byte_order);
265 
266  /* For most architectures, calling extract_unsigned_integer() alone
267  is sufficient for extracting an address. However, some
268  architectures (e.g. MIPS) use signed addresses and using
269  extract_unsigned_integer() will not produce a correct
270  result. Make sure we invoke gdbarch_integer_to_address()
271  for those architectures which require it. */
273  {
274  gdb_byte *buf = alloca (ctx->addr_size);
275  struct type *int_type = get_unsigned_type (ctx->gdbarch,
276  value_type (result_val));
277 
278  store_unsigned_integer (buf, ctx->addr_size, byte_order, result);
279  return gdbarch_integer_to_address (ctx->gdbarch, int_type, buf);
280  }
281 
282  return (CORE_ADDR) result;
283 }
284 
285 /* Retrieve the in_stack_memory flag of the N'th item on CTX's stack. */
286 
287 int
289 {
290  if (ctx->stack_len <= n)
291  error (_("Asked for position %d of stack, "
292  "stack only has %d elements on it."),
293  n, ctx->stack_len);
294  return ctx->stack[ctx->stack_len - (1 + n)].in_stack_memory;
295 }
296 
297 /* Return true if the expression stack is empty. */
298 
299 static int
301 {
302  return ctx->stack_len == 0;
303 }
304 
305 /* Add a new piece to CTX's piece list. */
306 static void
308 {
309  struct dwarf_expr_piece *p;
310 
311  ctx->num_pieces++;
312 
313  ctx->pieces = xrealloc (ctx->pieces,
314  (ctx->num_pieces
315  * sizeof (struct dwarf_expr_piece)));
316 
317  p = &ctx->pieces[ctx->num_pieces - 1];
318  p->location = ctx->location;
319  p->size = size;
320  p->offset = offset;
321 
322  if (p->location == DWARF_VALUE_LITERAL)
323  {
324  p->v.literal.data = ctx->data;
325  p->v.literal.length = ctx->len;
326  }
327  else if (dwarf_expr_stack_empty_p (ctx))
328  {
330  /* Also reset the context's location, for our callers. This is
331  a somewhat strange approach, but this lets us avoid setting
332  the location to DWARF_VALUE_MEMORY in all the individual
333  cases in the evaluator. */
335  }
336  else if (p->location == DWARF_VALUE_MEMORY)
337  {
338  p->v.mem.addr = dwarf_expr_fetch_address (ctx, 0);
339  p->v.mem.in_stack_memory = dwarf_expr_fetch_in_stack_memory (ctx, 0);
340  }
341  else if (p->location == DWARF_VALUE_IMPLICIT_POINTER)
342  {
343  p->v.ptr.die.sect_off = ctx->len;
344  p->v.ptr.offset = value_as_long (dwarf_expr_fetch (ctx, 0));
345  }
346  else if (p->location == DWARF_VALUE_REGISTER)
347  p->v.regno = value_as_long (dwarf_expr_fetch (ctx, 0));
348  else
349  {
350  p->v.value = dwarf_expr_fetch (ctx, 0);
351  }
352 }
353 
354 /* Evaluate the expression at ADDR (LEN bytes long) using the context
355  CTX. */
356 
357 void
359  size_t len)
360 {
361  int old_recursion_depth = ctx->recursion_depth;
362 
363  execute_stack_op (ctx, addr, addr + len);
364 
365  /* CTX RECURSION_DEPTH becomes invalid if an exception was thrown here. */
366 
367  gdb_assert (ctx->recursion_depth == old_recursion_depth);
368 }
369 
370 /* Helper to read a uleb128 value or throw an error. */
371 
372 const gdb_byte *
373 safe_read_uleb128 (const gdb_byte *buf, const gdb_byte *buf_end,
374  uint64_t *r)
375 {
376  buf = gdb_read_uleb128 (buf, buf_end, r);
377  if (buf == NULL)
378  error (_("DWARF expression error: ran off end of buffer reading uleb128 value"));
379  return buf;
380 }
381 
382 /* Helper to read a sleb128 value or throw an error. */
383 
384 const gdb_byte *
385 safe_read_sleb128 (const gdb_byte *buf, const gdb_byte *buf_end,
386  int64_t *r)
387 {
388  buf = gdb_read_sleb128 (buf, buf_end, r);
389  if (buf == NULL)
390  error (_("DWARF expression error: ran off end of buffer reading sleb128 value"));
391  return buf;
392 }
393 
394 const gdb_byte *
395 safe_skip_leb128 (const gdb_byte *buf, const gdb_byte *buf_end)
396 {
397  buf = gdb_skip_leb128 (buf, buf_end);
398  if (buf == NULL)
399  error (_("DWARF expression error: ran off end of buffer reading leb128 value"));
400  return buf;
401 }
402 
403 
404 /* Check that the current operator is either at the end of an
405  expression, or that it is followed by a composition operator. */
406 
407 void
408 dwarf_expr_require_composition (const gdb_byte *op_ptr, const gdb_byte *op_end,
409  const char *op_name)
410 {
411  /* It seems like DW_OP_GNU_uninit should be handled here. However,
412  it doesn't seem to make sense for DW_OP_*_value, and it was not
413  checked at the other place that this function is called. */
414  if (op_ptr != op_end && *op_ptr != DW_OP_piece && *op_ptr != DW_OP_bit_piece)
415  error (_("DWARF-2 expression error: `%s' operations must be "
416  "used either alone or in conjunction with DW_OP_piece "
417  "or DW_OP_bit_piece."),
418  op_name);
419 }
420 
421 /* Return true iff the types T1 and T2 are "the same". This only does
422  checks that might reasonably be needed to compare DWARF base
423  types. */
424 
425 static int
426 base_types_equal_p (struct type *t1, struct type *t2)
427 {
428  if (TYPE_CODE (t1) != TYPE_CODE (t2))
429  return 0;
430  if (TYPE_UNSIGNED (t1) != TYPE_UNSIGNED (t2))
431  return 0;
432  return TYPE_LENGTH (t1) == TYPE_LENGTH (t2);
433 }
434 
435 /* A convenience function to call get_base_type on CTX and return the
436  result. DIE is the DIE whose type we need. SIZE is non-zero if
437  this function should verify that the resulting type has the correct
438  size. */
439 
440 static struct type *
442 {
443  struct type *result;
444 
445  if (ctx->funcs->get_base_type)
446  {
447  result = ctx->funcs->get_base_type (ctx, die);
448  if (result == NULL)
449  error (_("Could not find type for DW_OP_GNU_const_type"));
450  if (size != 0 && TYPE_LENGTH (result) != size)
451  error (_("DW_OP_GNU_const_type has different sizes for type and data"));
452  }
453  else
454  /* Anything will do. */
455  result = builtin_type (ctx->gdbarch)->builtin_int;
456 
457  return result;
458 }
459 
460 /* If <BUF..BUF_END] contains DW_FORM_block* with single DW_OP_reg* return the
461  DWARF register number. Otherwise return -1. */
462 
463 int
464 dwarf_block_to_dwarf_reg (const gdb_byte *buf, const gdb_byte *buf_end)
465 {
466  uint64_t dwarf_reg;
467 
468  if (buf_end <= buf)
469  return -1;
470  if (*buf >= DW_OP_reg0 && *buf <= DW_OP_reg31)
471  {
472  if (buf_end - buf != 1)
473  return -1;
474  return *buf - DW_OP_reg0;
475  }
476 
477  if (*buf == DW_OP_GNU_regval_type)
478  {
479  buf++;
480  buf = gdb_read_uleb128 (buf, buf_end, &dwarf_reg);
481  if (buf == NULL)
482  return -1;
483  buf = gdb_skip_leb128 (buf, buf_end);
484  if (buf == NULL)
485  return -1;
486  }
487  else if (*buf == DW_OP_regx)
488  {
489  buf++;
490  buf = gdb_read_uleb128 (buf, buf_end, &dwarf_reg);
491  if (buf == NULL)
492  return -1;
493  }
494  else
495  return -1;
496  if (buf != buf_end || (int) dwarf_reg != dwarf_reg)
497  return -1;
498  return dwarf_reg;
499 }
500 
501 /* If <BUF..BUF_END] contains DW_FORM_block* with just DW_OP_breg*(0) and
502  DW_OP_deref* return the DWARF register number. Otherwise return -1.
503  DEREF_SIZE_RETURN contains -1 for DW_OP_deref; otherwise it contains the
504  size from DW_OP_deref_size. */
505 
506 int
508  CORE_ADDR *deref_size_return)
509 {
510  uint64_t dwarf_reg;
511  int64_t offset;
512 
513  if (buf_end <= buf)
514  return -1;
515 
516  if (*buf >= DW_OP_breg0 && *buf <= DW_OP_breg31)
517  {
518  dwarf_reg = *buf - DW_OP_breg0;
519  buf++;
520  if (buf >= buf_end)
521  return -1;
522  }
523  else if (*buf == DW_OP_bregx)
524  {
525  buf++;
526  buf = gdb_read_uleb128 (buf, buf_end, &dwarf_reg);
527  if (buf == NULL)
528  return -1;
529  if ((int) dwarf_reg != dwarf_reg)
530  return -1;
531  }
532  else
533  return -1;
534 
535  buf = gdb_read_sleb128 (buf, buf_end, &offset);
536  if (buf == NULL)
537  return -1;
538  if (offset != 0)
539  return -1;
540 
541  if (*buf == DW_OP_deref)
542  {
543  buf++;
544  *deref_size_return = -1;
545  }
546  else if (*buf == DW_OP_deref_size)
547  {
548  buf++;
549  if (buf >= buf_end)
550  return -1;
551  *deref_size_return = *buf++;
552  }
553  else
554  return -1;
555 
556  if (buf != buf_end)
557  return -1;
558 
559  return dwarf_reg;
560 }
561 
562 /* If <BUF..BUF_END] contains DW_FORM_block* with single DW_OP_fbreg(X) fill
563  in FB_OFFSET_RETURN with the X offset and return 1. Otherwise return 0. */
564 
565 int
566 dwarf_block_to_fb_offset (const gdb_byte *buf, const gdb_byte *buf_end,
567  CORE_ADDR *fb_offset_return)
568 {
569  int64_t fb_offset;
570 
571  if (buf_end <= buf)
572  return 0;
573 
574  if (*buf != DW_OP_fbreg)
575  return 0;
576  buf++;
577 
578  buf = gdb_read_sleb128 (buf, buf_end, &fb_offset);
579  if (buf == NULL)
580  return 0;
581  *fb_offset_return = fb_offset;
582  if (buf != buf_end || fb_offset != (LONGEST) *fb_offset_return)
583  return 0;
584 
585  return 1;
586 }
587 
588 /* If <BUF..BUF_END] contains DW_FORM_block* with single DW_OP_bregSP(X) fill
589  in SP_OFFSET_RETURN with the X offset and return 1. Otherwise return 0.
590  The matched SP register number depends on GDBARCH. */
591 
592 int
594  const gdb_byte *buf_end, CORE_ADDR *sp_offset_return)
595 {
596  uint64_t dwarf_reg;
597  int64_t sp_offset;
598 
599  if (buf_end <= buf)
600  return 0;
601  if (*buf >= DW_OP_breg0 && *buf <= DW_OP_breg31)
602  {
603  dwarf_reg = *buf - DW_OP_breg0;
604  buf++;
605  }
606  else
607  {
608  if (*buf != DW_OP_bregx)
609  return 0;
610  buf++;
611  buf = gdb_read_uleb128 (buf, buf_end, &dwarf_reg);
612  if (buf == NULL)
613  return 0;
614  }
615 
616  if (gdbarch_dwarf2_reg_to_regnum (gdbarch, dwarf_reg)
617  != gdbarch_sp_regnum (gdbarch))
618  return 0;
619 
620  buf = gdb_read_sleb128 (buf, buf_end, &sp_offset);
621  if (buf == NULL)
622  return 0;
623  *sp_offset_return = sp_offset;
624  if (buf != buf_end || sp_offset != (LONGEST) *sp_offset_return)
625  return 0;
626 
627  return 1;
628 }
629 
630 /* The engine for the expression evaluator. Using the context in CTX,
631  evaluate the expression between OP_PTR and OP_END. */
632 
633 static void
635  const gdb_byte *op_ptr, const gdb_byte *op_end)
636 {
637  enum bfd_endian byte_order = gdbarch_byte_order (ctx->gdbarch);
638  /* Old-style "untyped" DWARF values need special treatment in a
639  couple of places, specifically DW_OP_mod and DW_OP_shr. We need
640  a special type for these values so we can distinguish them from
641  values that have an explicit type, because explicitly-typed
642  values do not need special treatment. This special type must be
643  different (in the `==' sense) from any base type coming from the
644  CU. */
645  struct type *address_type = dwarf_expr_address_type (ctx);
646 
648  ctx->initialized = 1; /* Default is initialized. */
649 
650  if (ctx->recursion_depth > ctx->max_recursion_depth)
651  error (_("DWARF-2 expression error: Loop detected (%d)."),
652  ctx->recursion_depth);
653  ctx->recursion_depth++;
654 
655  while (op_ptr < op_end)
656  {
657  enum dwarf_location_atom op = *op_ptr++;
658  ULONGEST result;
659  /* Assume the value is not in stack memory.
660  Code that knows otherwise sets this to 1.
661  Some arithmetic on stack addresses can probably be assumed to still
662  be a stack address, but we skip this complication for now.
663  This is just an optimization, so it's always ok to punt
664  and leave this as 0. */
665  int in_stack_memory = 0;
666  uint64_t uoffset, reg;
667  int64_t offset;
668  struct value *result_val = NULL;
669 
670  /* The DWARF expression might have a bug causing an infinite
671  loop. In that case, quitting is the only way out. */
672  QUIT;
673 
674  switch (op)
675  {
676  case DW_OP_lit0:
677  case DW_OP_lit1:
678  case DW_OP_lit2:
679  case DW_OP_lit3:
680  case DW_OP_lit4:
681  case DW_OP_lit5:
682  case DW_OP_lit6:
683  case DW_OP_lit7:
684  case DW_OP_lit8:
685  case DW_OP_lit9:
686  case DW_OP_lit10:
687  case DW_OP_lit11:
688  case DW_OP_lit12:
689  case DW_OP_lit13:
690  case DW_OP_lit14:
691  case DW_OP_lit15:
692  case DW_OP_lit16:
693  case DW_OP_lit17:
694  case DW_OP_lit18:
695  case DW_OP_lit19:
696  case DW_OP_lit20:
697  case DW_OP_lit21:
698  case DW_OP_lit22:
699  case DW_OP_lit23:
700  case DW_OP_lit24:
701  case DW_OP_lit25:
702  case DW_OP_lit26:
703  case DW_OP_lit27:
704  case DW_OP_lit28:
705  case DW_OP_lit29:
706  case DW_OP_lit30:
707  case DW_OP_lit31:
708  result = op - DW_OP_lit0;
709  result_val = value_from_ulongest (address_type, result);
710  break;
711 
712  case DW_OP_addr:
713  result = extract_unsigned_integer (op_ptr,
714  ctx->addr_size, byte_order);
715  op_ptr += ctx->addr_size;
716  /* Some versions of GCC emit DW_OP_addr before
717  DW_OP_GNU_push_tls_address. In this case the value is an
718  index, not an address. We don't support things like
719  branching between the address and the TLS op. */
720  if (op_ptr >= op_end || *op_ptr != DW_OP_GNU_push_tls_address)
721  result += ctx->offset;
722  result_val = value_from_ulongest (address_type, result);
723  break;
724 
725  case DW_OP_GNU_addr_index:
726  op_ptr = safe_read_uleb128 (op_ptr, op_end, &uoffset);
727  result = (ctx->funcs->get_addr_index) (ctx->baton, uoffset);
728  result += ctx->offset;
729  result_val = value_from_ulongest (address_type, result);
730  break;
731  case DW_OP_GNU_const_index:
732  op_ptr = safe_read_uleb128 (op_ptr, op_end, &uoffset);
733  result = (ctx->funcs->get_addr_index) (ctx->baton, uoffset);
734  result_val = value_from_ulongest (address_type, result);
735  break;
736 
737  case DW_OP_const1u:
738  result = extract_unsigned_integer (op_ptr, 1, byte_order);
739  result_val = value_from_ulongest (address_type, result);
740  op_ptr += 1;
741  break;
742  case DW_OP_const1s:
743  result = extract_signed_integer (op_ptr, 1, byte_order);
744  result_val = value_from_ulongest (address_type, result);
745  op_ptr += 1;
746  break;
747  case DW_OP_const2u:
748  result = extract_unsigned_integer (op_ptr, 2, byte_order);
749  result_val = value_from_ulongest (address_type, result);
750  op_ptr += 2;
751  break;
752  case DW_OP_const2s:
753  result = extract_signed_integer (op_ptr, 2, byte_order);
754  result_val = value_from_ulongest (address_type, result);
755  op_ptr += 2;
756  break;
757  case DW_OP_const4u:
758  result = extract_unsigned_integer (op_ptr, 4, byte_order);
759  result_val = value_from_ulongest (address_type, result);
760  op_ptr += 4;
761  break;
762  case DW_OP_const4s:
763  result = extract_signed_integer (op_ptr, 4, byte_order);
764  result_val = value_from_ulongest (address_type, result);
765  op_ptr += 4;
766  break;
767  case DW_OP_const8u:
768  result = extract_unsigned_integer (op_ptr, 8, byte_order);
769  result_val = value_from_ulongest (address_type, result);
770  op_ptr += 8;
771  break;
772  case DW_OP_const8s:
773  result = extract_signed_integer (op_ptr, 8, byte_order);
774  result_val = value_from_ulongest (address_type, result);
775  op_ptr += 8;
776  break;
777  case DW_OP_constu:
778  op_ptr = safe_read_uleb128 (op_ptr, op_end, &uoffset);
779  result = uoffset;
780  result_val = value_from_ulongest (address_type, result);
781  break;
782  case DW_OP_consts:
783  op_ptr = safe_read_sleb128 (op_ptr, op_end, &offset);
784  result = offset;
785  result_val = value_from_ulongest (address_type, result);
786  break;
787 
788  /* The DW_OP_reg operations are required to occur alone in
789  location expressions. */
790  case DW_OP_reg0:
791  case DW_OP_reg1:
792  case DW_OP_reg2:
793  case DW_OP_reg3:
794  case DW_OP_reg4:
795  case DW_OP_reg5:
796  case DW_OP_reg6:
797  case DW_OP_reg7:
798  case DW_OP_reg8:
799  case DW_OP_reg9:
800  case DW_OP_reg10:
801  case DW_OP_reg11:
802  case DW_OP_reg12:
803  case DW_OP_reg13:
804  case DW_OP_reg14:
805  case DW_OP_reg15:
806  case DW_OP_reg16:
807  case DW_OP_reg17:
808  case DW_OP_reg18:
809  case DW_OP_reg19:
810  case DW_OP_reg20:
811  case DW_OP_reg21:
812  case DW_OP_reg22:
813  case DW_OP_reg23:
814  case DW_OP_reg24:
815  case DW_OP_reg25:
816  case DW_OP_reg26:
817  case DW_OP_reg27:
818  case DW_OP_reg28:
819  case DW_OP_reg29:
820  case DW_OP_reg30:
821  case DW_OP_reg31:
822  if (op_ptr != op_end
823  && *op_ptr != DW_OP_piece
824  && *op_ptr != DW_OP_bit_piece
825  && *op_ptr != DW_OP_GNU_uninit)
826  error (_("DWARF-2 expression error: DW_OP_reg operations must be "
827  "used either alone or in conjunction with DW_OP_piece "
828  "or DW_OP_bit_piece."));
829 
830  result = op - DW_OP_reg0;
831  result_val = value_from_ulongest (address_type, result);
833  break;
834 
835  case DW_OP_regx:
836  op_ptr = safe_read_uleb128 (op_ptr, op_end, &reg);
837  dwarf_expr_require_composition (op_ptr, op_end, "DW_OP_regx");
838 
839  result = reg;
840  result_val = value_from_ulongest (address_type, result);
842  break;
843 
844  case DW_OP_implicit_value:
845  {
846  uint64_t len;
847 
848  op_ptr = safe_read_uleb128 (op_ptr, op_end, &len);
849  if (op_ptr + len > op_end)
850  error (_("DW_OP_implicit_value: too few bytes available."));
851  ctx->len = len;
852  ctx->data = op_ptr;
854  op_ptr += len;
855  dwarf_expr_require_composition (op_ptr, op_end,
856  "DW_OP_implicit_value");
857  }
858  goto no_push;
859 
860  case DW_OP_stack_value:
862  dwarf_expr_require_composition (op_ptr, op_end, "DW_OP_stack_value");
863  goto no_push;
864 
865  case DW_OP_GNU_implicit_pointer:
866  {
867  int64_t len;
868 
869  if (ctx->ref_addr_size == -1)
870  error (_("DWARF-2 expression error: DW_OP_GNU_implicit_pointer "
871  "is not allowed in frame context"));
872 
873  /* The referred-to DIE of sect_offset kind. */
874  ctx->len = extract_unsigned_integer (op_ptr, ctx->ref_addr_size,
875  byte_order);
876  op_ptr += ctx->ref_addr_size;
877 
878  /* The byte offset into the data. */
879  op_ptr = safe_read_sleb128 (op_ptr, op_end, &len);
880  result = (ULONGEST) len;
881  result_val = value_from_ulongest (address_type, result);
882 
884  dwarf_expr_require_composition (op_ptr, op_end,
885  "DW_OP_GNU_implicit_pointer");
886  }
887  break;
888 
889  case DW_OP_breg0:
890  case DW_OP_breg1:
891  case DW_OP_breg2:
892  case DW_OP_breg3:
893  case DW_OP_breg4:
894  case DW_OP_breg5:
895  case DW_OP_breg6:
896  case DW_OP_breg7:
897  case DW_OP_breg8:
898  case DW_OP_breg9:
899  case DW_OP_breg10:
900  case DW_OP_breg11:
901  case DW_OP_breg12:
902  case DW_OP_breg13:
903  case DW_OP_breg14:
904  case DW_OP_breg15:
905  case DW_OP_breg16:
906  case DW_OP_breg17:
907  case DW_OP_breg18:
908  case DW_OP_breg19:
909  case DW_OP_breg20:
910  case DW_OP_breg21:
911  case DW_OP_breg22:
912  case DW_OP_breg23:
913  case DW_OP_breg24:
914  case DW_OP_breg25:
915  case DW_OP_breg26:
916  case DW_OP_breg27:
917  case DW_OP_breg28:
918  case DW_OP_breg29:
919  case DW_OP_breg30:
920  case DW_OP_breg31:
921  {
922  op_ptr = safe_read_sleb128 (op_ptr, op_end, &offset);
923  result = (ctx->funcs->read_addr_from_reg) (ctx->baton,
924  op - DW_OP_breg0);
925  result += offset;
926  result_val = value_from_ulongest (address_type, result);
927  }
928  break;
929  case DW_OP_bregx:
930  {
931  op_ptr = safe_read_uleb128 (op_ptr, op_end, &reg);
932  op_ptr = safe_read_sleb128 (op_ptr, op_end, &offset);
933  result = (ctx->funcs->read_addr_from_reg) (ctx->baton, reg);
934  result += offset;
935  result_val = value_from_ulongest (address_type, result);
936  }
937  break;
938  case DW_OP_fbreg:
939  {
940  const gdb_byte *datastart;
941  size_t datalen;
942  unsigned int before_stack_len;
943 
944  op_ptr = safe_read_sleb128 (op_ptr, op_end, &offset);
945  /* Rather than create a whole new context, we simply
946  record the stack length before execution, then reset it
947  afterwards, effectively erasing whatever the recursive
948  call put there. */
949  before_stack_len = ctx->stack_len;
950  /* FIXME: cagney/2003-03-26: This code should be using
951  get_frame_base_address(), and then implement a dwarf2
952  specific this_base method. */
953  (ctx->funcs->get_frame_base) (ctx->baton, &datastart, &datalen);
954  dwarf_expr_eval (ctx, datastart, datalen);
955  if (ctx->location == DWARF_VALUE_MEMORY)
956  result = dwarf_expr_fetch_address (ctx, 0);
957  else if (ctx->location == DWARF_VALUE_REGISTER)
958  result = (ctx->funcs->read_addr_from_reg)
959  (ctx->baton,
960  value_as_long (dwarf_expr_fetch (ctx, 0)));
961  else
962  error (_("Not implemented: computing frame "
963  "base using explicit value operator"));
964  result = result + offset;
965  result_val = value_from_ulongest (address_type, result);
966  in_stack_memory = 1;
967  ctx->stack_len = before_stack_len;
969  }
970  break;
971 
972  case DW_OP_dup:
973  result_val = dwarf_expr_fetch (ctx, 0);
974  in_stack_memory = dwarf_expr_fetch_in_stack_memory (ctx, 0);
975  break;
976 
977  case DW_OP_drop:
978  dwarf_expr_pop (ctx);
979  goto no_push;
980 
981  case DW_OP_pick:
982  offset = *op_ptr++;
983  result_val = dwarf_expr_fetch (ctx, offset);
984  in_stack_memory = dwarf_expr_fetch_in_stack_memory (ctx, offset);
985  break;
986 
987  case DW_OP_swap:
988  {
989  struct dwarf_stack_value t1, t2;
990 
991  if (ctx->stack_len < 2)
992  error (_("Not enough elements for "
993  "DW_OP_swap. Need 2, have %d."),
994  ctx->stack_len);
995  t1 = ctx->stack[ctx->stack_len - 1];
996  t2 = ctx->stack[ctx->stack_len - 2];
997  ctx->stack[ctx->stack_len - 1] = t2;
998  ctx->stack[ctx->stack_len - 2] = t1;
999  goto no_push;
1000  }
1001 
1002  case DW_OP_over:
1003  result_val = dwarf_expr_fetch (ctx, 1);
1004  in_stack_memory = dwarf_expr_fetch_in_stack_memory (ctx, 1);
1005  break;
1006 
1007  case DW_OP_rot:
1008  {
1009  struct dwarf_stack_value t1, t2, t3;
1010 
1011  if (ctx->stack_len < 3)
1012  error (_("Not enough elements for "
1013  "DW_OP_rot. Need 3, have %d."),
1014  ctx->stack_len);
1015  t1 = ctx->stack[ctx->stack_len - 1];
1016  t2 = ctx->stack[ctx->stack_len - 2];
1017  t3 = ctx->stack[ctx->stack_len - 3];
1018  ctx->stack[ctx->stack_len - 1] = t2;
1019  ctx->stack[ctx->stack_len - 2] = t3;
1020  ctx->stack[ctx->stack_len - 3] = t1;
1021  goto no_push;
1022  }
1023 
1024  case DW_OP_deref:
1025  case DW_OP_deref_size:
1026  case DW_OP_GNU_deref_type:
1027  {
1028  int addr_size = (op == DW_OP_deref ? ctx->addr_size : *op_ptr++);
1029  gdb_byte *buf = alloca (addr_size);
1030  CORE_ADDR addr = dwarf_expr_fetch_address (ctx, 0);
1031  struct type *type;
1032 
1033  dwarf_expr_pop (ctx);
1034 
1035  if (op == DW_OP_GNU_deref_type)
1036  {
1037  cu_offset type_die;
1038 
1039  op_ptr = safe_read_uleb128 (op_ptr, op_end, &uoffset);
1040  type_die.cu_off = uoffset;
1041  type = dwarf_get_base_type (ctx, type_die, 0);
1042  }
1043  else
1044  type = address_type;
1045 
1046  (ctx->funcs->read_mem) (ctx->baton, buf, addr, addr_size);
1047 
1048  /* If the size of the object read from memory is different
1049  from the type length, we need to zero-extend it. */
1050  if (TYPE_LENGTH (type) != addr_size)
1051  {
1052  ULONGEST result =
1053  extract_unsigned_integer (buf, addr_size, byte_order);
1054 
1055  buf = alloca (TYPE_LENGTH (type));
1056  store_unsigned_integer (buf, TYPE_LENGTH (type),
1057  byte_order, result);
1058  }
1059 
1060  result_val = value_from_contents_and_address (type, buf, addr);
1061  break;
1062  }
1063 
1064  case DW_OP_abs:
1065  case DW_OP_neg:
1066  case DW_OP_not:
1067  case DW_OP_plus_uconst:
1068  {
1069  /* Unary operations. */
1070  result_val = dwarf_expr_fetch (ctx, 0);
1071  dwarf_expr_pop (ctx);
1072 
1073  switch (op)
1074  {
1075  case DW_OP_abs:
1076  if (value_less (result_val,
1077  value_zero (value_type (result_val), not_lval)))
1078  result_val = value_neg (result_val);
1079  break;
1080  case DW_OP_neg:
1081  result_val = value_neg (result_val);
1082  break;
1083  case DW_OP_not:
1084  dwarf_require_integral (value_type (result_val));
1085  result_val = value_complement (result_val);
1086  break;
1087  case DW_OP_plus_uconst:
1088  dwarf_require_integral (value_type (result_val));
1089  result = value_as_long (result_val);
1090  op_ptr = safe_read_uleb128 (op_ptr, op_end, &reg);
1091  result += reg;
1092  result_val = value_from_ulongest (address_type, result);
1093  break;
1094  }
1095  }
1096  break;
1097 
1098  case DW_OP_and:
1099  case DW_OP_div:
1100  case DW_OP_minus:
1101  case DW_OP_mod:
1102  case DW_OP_mul:
1103  case DW_OP_or:
1104  case DW_OP_plus:
1105  case DW_OP_shl:
1106  case DW_OP_shr:
1107  case DW_OP_shra:
1108  case DW_OP_xor:
1109  case DW_OP_le:
1110  case DW_OP_ge:
1111  case DW_OP_eq:
1112  case DW_OP_lt:
1113  case DW_OP_gt:
1114  case DW_OP_ne:
1115  {
1116  /* Binary operations. */
1117  struct value *first, *second;
1118 
1119  second = dwarf_expr_fetch (ctx, 0);
1120  dwarf_expr_pop (ctx);
1121 
1122  first = dwarf_expr_fetch (ctx, 0);
1123  dwarf_expr_pop (ctx);
1124 
1125  if (! base_types_equal_p (value_type (first), value_type (second)))
1126  error (_("Incompatible types on DWARF stack"));
1127 
1128  switch (op)
1129  {
1130  case DW_OP_and:
1133  result_val = value_binop (first, second, BINOP_BITWISE_AND);
1134  break;
1135  case DW_OP_div:
1136  result_val = value_binop (first, second, BINOP_DIV);
1137  break;
1138  case DW_OP_minus:
1139  result_val = value_binop (first, second, BINOP_SUB);
1140  break;
1141  case DW_OP_mod:
1142  {
1143  int cast_back = 0;
1144  struct type *orig_type = value_type (first);
1145 
1146  /* We have to special-case "old-style" untyped values
1147  -- these must have mod computed using unsigned
1148  math. */
1149  if (orig_type == address_type)
1150  {
1151  struct type *utype
1152  = get_unsigned_type (ctx->gdbarch, orig_type);
1153 
1154  cast_back = 1;
1155  first = value_cast (utype, first);
1156  second = value_cast (utype, second);
1157  }
1158  /* Note that value_binop doesn't handle float or
1159  decimal float here. This seems unimportant. */
1160  result_val = value_binop (first, second, BINOP_MOD);
1161  if (cast_back)
1162  result_val = value_cast (orig_type, result_val);
1163  }
1164  break;
1165  case DW_OP_mul:
1166  result_val = value_binop (first, second, BINOP_MUL);
1167  break;
1168  case DW_OP_or:
1171  result_val = value_binop (first, second, BINOP_BITWISE_IOR);
1172  break;
1173  case DW_OP_plus:
1174  result_val = value_binop (first, second, BINOP_ADD);
1175  break;
1176  case DW_OP_shl:
1179  result_val = value_binop (first, second, BINOP_LSH);
1180  break;
1181  case DW_OP_shr:
1184  if (!TYPE_UNSIGNED (value_type (first)))
1185  {
1186  struct type *utype
1187  = get_unsigned_type (ctx->gdbarch, value_type (first));
1188 
1189  first = value_cast (utype, first);
1190  }
1191 
1192  result_val = value_binop (first, second, BINOP_RSH);
1193  /* Make sure we wind up with the same type we started
1194  with. */
1195  if (value_type (result_val) != value_type (second))
1196  result_val = value_cast (value_type (second), result_val);
1197  break;
1198  case DW_OP_shra:
1201  if (TYPE_UNSIGNED (value_type (first)))
1202  {
1203  struct type *stype
1204  = get_signed_type (ctx->gdbarch, value_type (first));
1205 
1206  first = value_cast (stype, first);
1207  }
1208 
1209  result_val = value_binop (first, second, BINOP_RSH);
1210  /* Make sure we wind up with the same type we started
1211  with. */
1212  if (value_type (result_val) != value_type (second))
1213  result_val = value_cast (value_type (second), result_val);
1214  break;
1215  case DW_OP_xor:
1218  result_val = value_binop (first, second, BINOP_BITWISE_XOR);
1219  break;
1220  case DW_OP_le:
1221  /* A <= B is !(B < A). */
1222  result = ! value_less (second, first);
1223  result_val = value_from_ulongest (address_type, result);
1224  break;
1225  case DW_OP_ge:
1226  /* A >= B is !(A < B). */
1227  result = ! value_less (first, second);
1228  result_val = value_from_ulongest (address_type, result);
1229  break;
1230  case DW_OP_eq:
1231  result = value_equal (first, second);
1232  result_val = value_from_ulongest (address_type, result);
1233  break;
1234  case DW_OP_lt:
1235  result = value_less (first, second);
1236  result_val = value_from_ulongest (address_type, result);
1237  break;
1238  case DW_OP_gt:
1239  /* A > B is B < A. */
1240  result = value_less (second, first);
1241  result_val = value_from_ulongest (address_type, result);
1242  break;
1243  case DW_OP_ne:
1244  result = ! value_equal (first, second);
1245  result_val = value_from_ulongest (address_type, result);
1246  break;
1247  default:
1248  internal_error (__FILE__, __LINE__,
1249  _("Can't be reached."));
1250  }
1251  }
1252  break;
1253 
1254  case DW_OP_call_frame_cfa:
1255  result = (ctx->funcs->get_frame_cfa) (ctx->baton);
1256  result_val = value_from_ulongest (address_type, result);
1257  in_stack_memory = 1;
1258  break;
1259 
1260  case DW_OP_GNU_push_tls_address:
1261  /* Variable is at a constant offset in the thread-local
1262  storage block into the objfile for the current thread and
1263  the dynamic linker module containing this expression. Here
1264  we return returns the offset from that base. The top of the
1265  stack has the offset from the beginning of the thread
1266  control block at which the variable is located. Nothing
1267  should follow this operator, so the top of stack would be
1268  returned. */
1269  result = value_as_long (dwarf_expr_fetch (ctx, 0));
1270  dwarf_expr_pop (ctx);
1271  result = (ctx->funcs->get_tls_address) (ctx->baton, result);
1272  result_val = value_from_ulongest (address_type, result);
1273  break;
1274 
1275  case DW_OP_skip:
1276  offset = extract_signed_integer (op_ptr, 2, byte_order);
1277  op_ptr += 2;
1278  op_ptr += offset;
1279  goto no_push;
1280 
1281  case DW_OP_bra:
1282  {
1283  struct value *val;
1284 
1285  offset = extract_signed_integer (op_ptr, 2, byte_order);
1286  op_ptr += 2;
1287  val = dwarf_expr_fetch (ctx, 0);
1289  if (value_as_long (val) != 0)
1290  op_ptr += offset;
1291  dwarf_expr_pop (ctx);
1292  }
1293  goto no_push;
1294 
1295  case DW_OP_nop:
1296  goto no_push;
1297 
1298  case DW_OP_piece:
1299  {
1300  uint64_t size;
1301 
1302  /* Record the piece. */
1303  op_ptr = safe_read_uleb128 (op_ptr, op_end, &size);
1304  add_piece (ctx, 8 * size, 0);
1305 
1306  /* Pop off the address/regnum, and reset the location
1307  type. */
1308  if (ctx->location != DWARF_VALUE_LITERAL
1310  dwarf_expr_pop (ctx);
1312  }
1313  goto no_push;
1314 
1315  case DW_OP_bit_piece:
1316  {
1317  uint64_t size, offset;
1318 
1319  /* Record the piece. */
1320  op_ptr = safe_read_uleb128 (op_ptr, op_end, &size);
1321  op_ptr = safe_read_uleb128 (op_ptr, op_end, &offset);
1322  add_piece (ctx, size, offset);
1323 
1324  /* Pop off the address/regnum, and reset the location
1325  type. */
1326  if (ctx->location != DWARF_VALUE_LITERAL
1328  dwarf_expr_pop (ctx);
1330  }
1331  goto no_push;
1332 
1333  case DW_OP_GNU_uninit:
1334  if (op_ptr != op_end)
1335  error (_("DWARF-2 expression error: DW_OP_GNU_uninit must always "
1336  "be the very last op."));
1337 
1338  ctx->initialized = 0;
1339  goto no_push;
1340 
1341  case DW_OP_call2:
1342  {
1343  cu_offset offset;
1344 
1345  offset.cu_off = extract_unsigned_integer (op_ptr, 2, byte_order);
1346  op_ptr += 2;
1347  ctx->funcs->dwarf_call (ctx, offset);
1348  }
1349  goto no_push;
1350 
1351  case DW_OP_call4:
1352  {
1353  cu_offset offset;
1354 
1355  offset.cu_off = extract_unsigned_integer (op_ptr, 4, byte_order);
1356  op_ptr += 4;
1357  ctx->funcs->dwarf_call (ctx, offset);
1358  }
1359  goto no_push;
1360 
1361  case DW_OP_GNU_entry_value:
1362  {
1363  uint64_t len;
1364  CORE_ADDR deref_size;
1365  union call_site_parameter_u kind_u;
1366 
1367  op_ptr = safe_read_uleb128 (op_ptr, op_end, &len);
1368  if (op_ptr + len > op_end)
1369  error (_("DW_OP_GNU_entry_value: too few bytes available."));
1370 
1371  kind_u.dwarf_reg = dwarf_block_to_dwarf_reg (op_ptr, op_ptr + len);
1372  if (kind_u.dwarf_reg != -1)
1373  {
1374  op_ptr += len;
1375  ctx->funcs->push_dwarf_reg_entry_value (ctx,
1377  kind_u,
1378  -1 /* deref_size */);
1379  goto no_push;
1380  }
1381 
1382  kind_u.dwarf_reg = dwarf_block_to_dwarf_reg_deref (op_ptr,
1383  op_ptr + len,
1384  &deref_size);
1385  if (kind_u.dwarf_reg != -1)
1386  {
1387  if (deref_size == -1)
1388  deref_size = ctx->addr_size;
1389  op_ptr += len;
1390  ctx->funcs->push_dwarf_reg_entry_value (ctx,
1392  kind_u, deref_size);
1393  goto no_push;
1394  }
1395 
1396  error (_("DWARF-2 expression error: DW_OP_GNU_entry_value is "
1397  "supported only for single DW_OP_reg* "
1398  "or for DW_OP_breg*(0)+DW_OP_deref*"));
1399  }
1400 
1401  case DW_OP_GNU_parameter_ref:
1402  {
1403  union call_site_parameter_u kind_u;
1404 
1405  kind_u.param_offset.cu_off = extract_unsigned_integer (op_ptr, 4,
1406  byte_order);
1407  op_ptr += 4;
1408  ctx->funcs->push_dwarf_reg_entry_value (ctx,
1410  kind_u,
1411  -1 /* deref_size */);
1412  }
1413  goto no_push;
1414 
1415  case DW_OP_GNU_const_type:
1416  {
1417  cu_offset type_die;
1418  int n;
1419  const gdb_byte *data;
1420  struct type *type;
1421 
1422  op_ptr = safe_read_uleb128 (op_ptr, op_end, &uoffset);
1423  type_die.cu_off = uoffset;
1424  n = *op_ptr++;
1425  data = op_ptr;
1426  op_ptr += n;
1427 
1428  type = dwarf_get_base_type (ctx, type_die, n);
1429  result_val = value_from_contents (type, data);
1430  }
1431  break;
1432 
1433  case DW_OP_GNU_regval_type:
1434  {
1435  cu_offset type_die;
1436  struct type *type;
1437 
1438  op_ptr = safe_read_uleb128 (op_ptr, op_end, &reg);
1439  op_ptr = safe_read_uleb128 (op_ptr, op_end, &uoffset);
1440  type_die.cu_off = uoffset;
1441 
1442  type = dwarf_get_base_type (ctx, type_die, 0);
1443  result_val = ctx->funcs->get_reg_value (ctx->baton, type, reg);
1444  }
1445  break;
1446 
1447  case DW_OP_GNU_convert:
1448  case DW_OP_GNU_reinterpret:
1449  {
1450  cu_offset type_die;
1451  struct type *type;
1452 
1453  op_ptr = safe_read_uleb128 (op_ptr, op_end, &uoffset);
1454  type_die.cu_off = uoffset;
1455 
1456  if (type_die.cu_off == 0)
1457  type = address_type;
1458  else
1459  type = dwarf_get_base_type (ctx, type_die, 0);
1460 
1461  result_val = dwarf_expr_fetch (ctx, 0);
1462  dwarf_expr_pop (ctx);
1463 
1464  if (op == DW_OP_GNU_convert)
1465  result_val = value_cast (type, result_val);
1466  else if (type == value_type (result_val))
1467  {
1468  /* Nothing. */
1469  }
1470  else if (TYPE_LENGTH (type)
1471  != TYPE_LENGTH (value_type (result_val)))
1472  error (_("DW_OP_GNU_reinterpret has wrong size"));
1473  else
1474  result_val
1475  = value_from_contents (type,
1476  value_contents_all (result_val));
1477  }
1478  break;
1479 
1480  case DW_OP_push_object_address:
1481  /* Return the address of the object we are currently observing. */
1482  result = (ctx->funcs->get_object_address) (ctx->baton);
1483  result_val = value_from_ulongest (address_type, result);
1484  break;
1485 
1486  default:
1487  error (_("Unhandled dwarf expression opcode 0x%x"), op);
1488  }
1489 
1490  /* Most things push a result value. */
1491  gdb_assert (result_val != NULL);
1492  dwarf_expr_push (ctx, result_val, in_stack_memory);
1493  no_push:
1494  ;
1495  }
1496 
1497  /* To simplify our main caller, if the result is an implicit
1498  pointer, then make a pieced value. This is ok because we can't
1499  have implicit pointers in contexts where pieces are invalid. */
1501  add_piece (ctx, 8 * ctx->addr_size, 0);
1502 
1503 abort_expression:
1504  ctx->recursion_depth--;
1505  gdb_assert (ctx->recursion_depth >= 0);
1506 }
1507 
1508 /* Stub dwarf_expr_context_funcs.get_frame_base implementation. */
1509 
1510 void
1511 ctx_no_get_frame_base (void *baton, const gdb_byte **start, size_t *length)
1512 {
1513  error (_("%s is invalid in this context"), "DW_OP_fbreg");
1514 }
1515 
1516 /* Stub dwarf_expr_context_funcs.get_frame_cfa implementation. */
1517 
1518 CORE_ADDR
1520 {
1521  error (_("%s is invalid in this context"), "DW_OP_call_frame_cfa");
1522 }
1523 
1524 /* Stub dwarf_expr_context_funcs.get_frame_pc implementation. */
1525 
1526 CORE_ADDR
1527 ctx_no_get_frame_pc (void *baton)
1528 {
1529  error (_("%s is invalid in this context"), "DW_OP_GNU_implicit_pointer");
1530 }
1531 
1532 /* Stub dwarf_expr_context_funcs.get_tls_address implementation. */
1533 
1534 CORE_ADDR
1536 {
1537  error (_("%s is invalid in this context"), "DW_OP_GNU_push_tls_address");
1538 }
1539 
1540 /* Stub dwarf_expr_context_funcs.dwarf_call implementation. */
1541 
1542 void
1544 {
1545  error (_("%s is invalid in this context"), "DW_OP_call*");
1546 }
1547 
1548 /* Stub dwarf_expr_context_funcs.get_base_type implementation. */
1549 
1550 struct type *
1552 {
1553  error (_("Support for typed DWARF is not supported in this context"));
1554 }
1555 
1556 /* Stub dwarf_expr_context_funcs.push_dwarf_block_entry_value
1557  implementation. */
1558 
1559 void
1561  enum call_site_parameter_kind kind,
1562  union call_site_parameter_u kind_u,
1563  int deref_size)
1564 {
1565  internal_error (__FILE__, __LINE__,
1566  _("Support for DW_OP_GNU_entry_value is unimplemented"));
1567 }
1568 
1569 /* Stub dwarf_expr_context_funcs.get_addr_index implementation. */
1570 
1571 CORE_ADDR
1572 ctx_no_get_addr_index (void *baton, unsigned int index)
1573 {
1574  error (_("%s is invalid in this context"), "DW_OP_GNU_addr_index");
1575 }
1576 
1577 /* Provide a prototype to silence -Wmissing-prototypes. */
1579 
1580 void
1582 {
1583  dwarf_arch_cookie
1585 }
CORE_ADDR gdbarch_integer_to_address(struct gdbarch *gdbarch, struct type *type, const gdb_byte *buf)
Definition: gdbarch.c:2522
void dwarf_expr_push_address(struct dwarf_expr_context *ctx, CORE_ADDR value, int in_stack_memory)
Definition: dwarf2expr.c:167
struct value * value_zero(struct type *type, enum lval_type lv)
Definition: valops.c:842
ULONGEST extract_unsigned_integer(const gdb_byte *, int, enum bfd_endian)
Definition: findvar.c:84
CORE_ADDR addr
Definition: dwarf2expr.h:216
static int base_types_equal_p(struct type *t1, struct type *t2)
Definition: dwarf2expr.c:426
static void add_piece(struct dwarf_expr_context *ctx, ULONGEST size, ULONGEST offset)
Definition: dwarf2expr.c:307
struct value * value_from_contents_and_address(struct type *type, const gdb_byte *valaddr, CORE_ADDR address)
Definition: value.c:3529
bfd_vma CORE_ADDR
Definition: common-types.h:41
CORE_ADDR ctx_no_get_frame_pc(void *baton)
Definition: dwarf2expr.c:1527
static struct type * get_signed_type(struct gdbarch *gdbarch, struct type *type)
Definition: dwarf2expr.c:234
void xfree(void *)
Definition: common-utils.c:97
struct type * dw_types[3]
Definition: dwarf2expr.c:44
struct value * value_from_contents(struct type *type, const gdb_byte *contents)
Definition: value.c:3553
struct dwarf_expr_piece::@52::@55 ptr
LONGEST value_as_long(struct value *val)
Definition: value.c:2654
void * gdbarch_data(struct gdbarch *gdbarch, struct gdbarch_data *data)
Definition: gdbarch.c:4845
const struct builtin_type * builtin_type(struct gdbarch *gdbarch)
Definition: gdbtypes.c:4766
cu_offset param_offset
Definition: gdbtypes.h:1131
void internal_error(const char *file, int line, const char *fmt,...)
Definition: errors.c:50
struct gdbarch * gdbarch
Definition: dwarf2expr.h:141
struct type * builtin_uint8
Definition: gdbtypes.h:1515
struct type * ctx_no_get_base_type(struct dwarf_expr_context *ctx, cu_offset die)
Definition: dwarf2expr.c:1551
struct type * builtin_uint16
Definition: gdbtypes.h:1517
CORE_ADDR(* get_addr_index)(void *baton, unsigned int index)
Definition: dwarf2expr.h:85
void ctx_no_get_frame_base(void *baton, const gdb_byte **start, size_t *length)
Definition: dwarf2expr.c:1511
void dwarf_expr_require_composition(const gdb_byte *op_ptr, const gdb_byte *op_end, const char *op_name)
Definition: dwarf2expr.c:408
struct type *(* get_base_type)(struct dwarf_expr_context *ctx, cu_offset die)
Definition: dwarf2expr.h:72
const gdb_byte * safe_read_uleb128(const gdb_byte *buf, const gdb_byte *buf_end, uint64_t *r)
Definition: dwarf2expr.c:373
static const gdb_byte * gdb_skip_leb128(const gdb_byte *buf, const gdb_byte *buf_end)
Definition: dwarf2expr.h:325
#define _(String)
Definition: gdb_locale.h:40
static void dwarf_expr_pop(struct dwarf_expr_context *ctx)
Definition: dwarf2expr.c:178
static void execute_stack_op(struct dwarf_expr_context *, const gdb_byte *, const gdb_byte *)
Definition: dwarf2expr.c:634
struct type * builtin_int32
Definition: gdbtypes.h:1518
struct value * dwarf_expr_fetch(struct dwarf_expr_context *ctx, int n)
Definition: dwarf2expr.c:188
int gdbarch_integer_to_address_p(struct gdbarch *gdbarch)
Definition: gdbarch.c:2515
void store_unsigned_integer(gdb_byte *, int, enum bfd_endian, ULONGEST)
Definition: findvar.c:212
#define GDBARCH_OBSTACK_ZALLOC(GDBARCH, TYPE)
Definition: gdbarch.h:1615
CORE_ADDR ctx_no_get_addr_index(void *baton, unsigned int index)
Definition: dwarf2expr.c:1572
CORE_ADDR(* get_object_address)(void *baton)
Definition: dwarf2expr.h:88
char * op_name(struct expression *exp, enum exp_opcode opcode)
Definition: expprint.c:653
const gdb_byte * safe_skip_leb128(const gdb_byte *buf, const gdb_byte *buf_end)
Definition: dwarf2expr.c:395
CORE_ADDR(* get_tls_address)(void *baton, CORE_ADDR offset)
Definition: dwarf2expr.h:60
const gdb_byte * value_contents(struct value *value)
Definition: value.c:1329
struct dwarf_expr_piece::@52::@53 mem
const struct dwarf_expr_context_funcs * funcs
Definition: dwarf2expr.h:158
static int dwarf_expr_stack_empty_p(struct dwarf_expr_context *ctx)
Definition: dwarf2expr.c:300
void initialize_file_ftype(void)
Definition: defs.h:281
int gdbarch_sp_regnum(struct gdbarch *gdbarch)
Definition: gdbarch.c:1981
static struct gdbarch_data * dwarf_arch_cookie
Definition: dwarf2expr.c:37
call_site_parameter_kind
Definition: gdbtypes.h:1092
const gdb_byte * value_contents_all(struct value *value)
Definition: value.c:1188
initialize_file_ftype _initialize_dwarf2expr
struct type * builtin_int16
Definition: gdbtypes.h:1516
static void dwarf_require_integral(struct type *type)
Definition: dwarf2expr.c:200
enum bfd_endian gdbarch_byte_order(struct gdbarch *gdbarch)
Definition: gdbarch.c:1420
struct cleanup * make_cleanup(make_cleanup_ftype *function, void *arg)
Definition: cleanups.c:117
Definition: gdbtypes.h:749
static const gdb_byte * gdb_read_uleb128(const gdb_byte *buf, const gdb_byte *buf_end, uint64_t *r)
Definition: dwarf2expr.h:303
struct type * builtin_uint32
Definition: gdbtypes.h:1519
static const char * type
Definition: language.c:103
CORE_ADDR ctx_no_get_tls_address(void *baton, CORE_ADDR offset)
Definition: dwarf2expr.c:1535
#define gdb_assert(expr)
Definition: gdb_assert.h:33
struct dwarf_expr_context * new_dwarf_expr_context(void)
Definition: dwarf2expr.c:93
static struct type * dwarf_get_base_type(struct dwarf_expr_context *ctx, cu_offset die, int size)
Definition: dwarf2expr.c:441
static void dwarf_expr_grow_stack(struct dwarf_expr_context *ctx, size_t need)
Definition: dwarf2expr.c:138
struct value * value_cast(struct type *type, struct value *arg2)
Definition: valops.c:351
struct dwarf_expr_piece::@52::@54 literal
struct type * arch_integer_type(struct gdbarch *gdbarch, int bit, int unsigned_p, char *name)
Definition: gdbtypes.c:4552
int value_equal(struct value *arg1, struct value *arg2)
Definition: valarith.c:1574
void * xmalloc(YYSIZE_T)
enum dwarf_value_location location
Definition: dwarf2expr.h:209
struct value *(* get_reg_value)(void *baton, struct type *type, int regnum)
Definition: dwarf2expr.h:42
struct dwarf_expr_piece * pieces
Definition: dwarf2expr.h:202
#define TYPE_UNSIGNED(t)
Definition: gdbtypes.h:233
const gdb_byte * safe_read_sleb128(const gdb_byte *buf, const gdb_byte *buf_end, int64_t *r)
Definition: dwarf2expr.c:385
Definition: regdef.h:22
Definition: value.c:172
PTR xrealloc(PTR ptr, size_t size)
Definition: common-utils.c:51
int gdbarch_dwarf2_reg_to_regnum(struct gdbarch *gdbarch, int dwarf2_regnr)
Definition: gdbarch.c:2100
int dwarf_block_to_dwarf_reg(const gdb_byte *buf, const gdb_byte *buf_end)
Definition: dwarf2expr.c:464
bfd_byte gdb_byte
Definition: common-types.h:38
static struct type * get_unsigned_type(struct gdbarch *gdbarch, struct type *type)
Definition: dwarf2expr.c:212
unsigned length
Definition: gdbtypes.h:807
struct value * value_neg(struct value *arg1)
Definition: valarith.c:1767
CORE_ADDR(* get_frame_cfa)(void *baton)
Definition: dwarf2expr.h:53
const gdb_byte * data
Definition: dwarf2expr.h:172
#define TYPE_CODE(thistype)
Definition: gdbtypes.h:1240
struct value * value
Definition: dwarf2expr.h:119
void(* dwarf_call)(struct dwarf_expr_context *ctx, cu_offset die_offset)
Definition: dwarf2expr.h:65
void free_dwarf_expr_context(struct dwarf_expr_context *ctx)
Definition: dwarf2expr.c:111
static struct type * dwarf_expr_address_type(struct dwarf_expr_context *ctx)
Definition: dwarf2expr.c:65
static void dwarf_expr_push(struct dwarf_expr_context *ctx, struct value *value, int in_stack_memory)
Definition: dwarf2expr.c:153
unsigned int cu_off
Definition: gdbtypes.h:62
int offset
Definition: agent.c:65
int value_less(struct value *arg1, struct value *arg2)
Definition: valarith.c:1673
CORE_ADDR offset
Definition: dwarf2expr.h:151
static void free_dwarf_expr_context_cleanup(void *arg)
Definition: dwarf2expr.c:121
unsigned stype
Definition: go32-nat.c:1066
struct value * value_complement(struct value *arg1)
Definition: valarith.c:1822
static void * dwarf_gdbarch_types_init(struct gdbarch *gdbarch)
Definition: dwarf2expr.c:50
CORE_ADDR(* read_addr_from_reg)(void *baton, int regnum)
Definition: dwarf2expr.h:36
CORE_ADDR ctx_no_get_frame_cfa(void *baton)
Definition: dwarf2expr.c:1519
struct value * value_binop(struct value *arg1, struct value *arg2, enum exp_opcode op)
Definition: valarith.c:1476
void(* get_frame_base)(void *baton, const gdb_byte **start, size_t *length)
Definition: dwarf2expr.h:50
int dwarf_expr_fetch_in_stack_memory(struct dwarf_expr_context *ctx, int n)
Definition: dwarf2expr.c:288
enum dwarf_value_location location
Definition: dwarf2expr.h:166
void ctx_no_push_dwarf_reg_entry_value(struct dwarf_expr_context *ctx, enum call_site_parameter_kind kind, union call_site_parameter_u kind_u, int deref_size)
Definition: dwarf2expr.c:1560
unsigned long long ULONGEST
Definition: common-types.h:53
struct dwarf_stack_value * stack
Definition: dwarf2expr.h:134
struct type * value_type(const struct value *value)
Definition: value.c:1021
static const gdb_byte * gdb_read_sleb128(const gdb_byte *buf, const gdb_byte *buf_end, int64_t *r)
Definition: dwarf2expr.h:314
struct type * builtin_int64
Definition: gdbtypes.h:1520
struct value * value_from_ulongest(struct type *type, ULONGEST num)
Definition: value.c:3476
union dwarf_expr_piece::@52 v
CORE_ADDR dwarf_expr_fetch_address(struct dwarf_expr_context *ctx, int n)
Definition: dwarf2expr.c:255
void(* push_dwarf_reg_entry_value)(struct dwarf_expr_context *ctx, enum call_site_parameter_kind kind, union call_site_parameter_u kind_u, int deref_size)
Definition: dwarf2expr.h:78
#define TYPE_LENGTH(thistype)
Definition: gdbtypes.h:1237
int dwarf_block_to_dwarf_reg_deref(const gdb_byte *buf, const gdb_byte *buf_end, CORE_ADDR *deref_size_return)
Definition: dwarf2expr.c:507
void dwarf_expr_eval(struct dwarf_expr_context *ctx, const gdb_byte *addr, size_t len)
Definition: dwarf2expr.c:358
struct type * builtin_uint64
Definition: gdbtypes.h:1521
#define QUIT
Definition: defs.h:160
LONGEST extract_signed_integer(const gdb_byte *, int, enum bfd_endian)
Definition: findvar.c:49
struct type * builtin_int8
Definition: gdbtypes.h:1514
Definition: defs.h:353
PTR xcalloc(size_t number, size_t size)
Definition: common-utils.c:71
void ctx_no_dwarf_call(struct dwarf_expr_context *ctx, cu_offset die_offset)
Definition: dwarf2expr.c:1543
int dwarf_block_to_sp_offset(struct gdbarch *gdbarch, const gdb_byte *buf, const gdb_byte *buf_end, CORE_ADDR *sp_offset_return)
Definition: dwarf2expr.c:593
void error(const char *fmt,...)
Definition: errors.c:38
size_t size
Definition: go32-nat.c:242
struct gdbarch_data * gdbarch_data_register_post_init(gdbarch_data_post_init_ftype *post_init)
Definition: gdbarch.c:4812
int dwarf_block_to_fb_offset(const gdb_byte *buf, const gdb_byte *buf_end, CORE_ADDR *fb_offset_return)
Definition: dwarf2expr.c:566
struct value * value
Definition: dwarf2expr.h:226
long long LONGEST
Definition: common-types.h:52
struct cleanup * make_cleanup_free_dwarf_expr_context(struct dwarf_expr_context *ctx)
Definition: dwarf2expr.c:129
struct type * builtin_int
Definition: gdbtypes.h:1483
const ULONGEST const LONGEST len
Definition: target.h:309
void(* read_mem)(void *baton, gdb_byte *buf, CORE_ADDR addr, size_t length)
Definition: dwarf2expr.h:45