1 /* DWARF 2 Expression Evaluator.
3 Copyright (C) 2001-2003, 2005, 2007-2012 Free Software Foundation,
6 Contributed by Daniel Berlin (dan@dberlin.org)
8 This file is part of GDB.
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.
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.
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/>. */
29 #include "dwarf2expr.h"
30 #include "gdb_assert.h"
32 /* Local prototypes. */
34 static void execute_stack_op (struct dwarf_expr_context *,
35 const gdb_byte *, const gdb_byte *);
37 /* Cookie for gdbarch data. */
39 static struct gdbarch_data *dwarf_arch_cookie;
41 /* This holds gdbarch-specific types used by the DWARF expression
42 evaluator. See comments in execute_stack_op. */
44 struct dwarf_gdbarch_types
46 struct type *dw_types[3];
49 /* Allocate and fill in dwarf_gdbarch_types for an arch. */
52 dwarf_gdbarch_types_init (struct gdbarch *gdbarch)
54 struct dwarf_gdbarch_types *types
55 = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct dwarf_gdbarch_types);
57 /* The types themselves are lazily initialized. */
62 /* Return the type used for DWARF operations where the type is
63 unspecified in the DWARF spec. Only certain sizes are
67 dwarf_expr_address_type (struct dwarf_expr_context *ctx)
69 struct dwarf_gdbarch_types *types = gdbarch_data (ctx->gdbarch,
73 if (ctx->addr_size == 2)
75 else if (ctx->addr_size == 4)
77 else if (ctx->addr_size == 8)
80 error (_("Unsupported address size in DWARF expressions: %d bits"),
83 if (types->dw_types[ndx] == NULL)
85 = arch_integer_type (ctx->gdbarch,
87 0, "<signed DWARF address type>");
89 return types->dw_types[ndx];
92 /* Create a new context for the expression evaluator. */
94 struct dwarf_expr_context *
95 new_dwarf_expr_context (void)
97 struct dwarf_expr_context *retval;
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;
106 retval->max_recursion_depth = 0x100;
110 /* Release the memory allocated to CTX. */
113 free_dwarf_expr_context (struct dwarf_expr_context *ctx)
120 /* Helper for make_cleanup_free_dwarf_expr_context. */
123 free_dwarf_expr_context_cleanup (void *arg)
125 free_dwarf_expr_context (arg);
128 /* Return a cleanup that calls free_dwarf_expr_context. */
131 make_cleanup_free_dwarf_expr_context (struct dwarf_expr_context *ctx)
133 return make_cleanup (free_dwarf_expr_context_cleanup, ctx);
136 /* Expand the memory allocated to CTX's stack to contain at least
137 NEED more elements than are currently used. */
140 dwarf_expr_grow_stack (struct dwarf_expr_context *ctx, size_t need)
142 if (ctx->stack_len + need > ctx->stack_allocated)
144 size_t newlen = ctx->stack_len + need + 10;
146 ctx->stack = xrealloc (ctx->stack,
147 newlen * sizeof (struct dwarf_stack_value));
148 ctx->stack_allocated = newlen;
152 /* Push VALUE onto CTX's stack. */
155 dwarf_expr_push (struct dwarf_expr_context *ctx, struct value *value,
158 struct dwarf_stack_value *v;
160 dwarf_expr_grow_stack (ctx, 1);
161 v = &ctx->stack[ctx->stack_len++];
163 v->in_stack_memory = in_stack_memory;
166 /* Push VALUE onto CTX's stack. */
169 dwarf_expr_push_address (struct dwarf_expr_context *ctx, CORE_ADDR value,
172 dwarf_expr_push (ctx,
173 value_from_ulongest (dwarf_expr_address_type (ctx), value),
177 /* Pop the top item off of CTX's stack. */
180 dwarf_expr_pop (struct dwarf_expr_context *ctx)
182 if (ctx->stack_len <= 0)
183 error (_("dwarf expression stack underflow"));
187 /* Retrieve the N'th item on CTX's stack. */
190 dwarf_expr_fetch (struct dwarf_expr_context *ctx, int n)
192 if (ctx->stack_len <= n)
193 error (_("Asked for position %d of stack, "
194 "stack only has %d elements on it."),
196 return ctx->stack[ctx->stack_len - (1 + n)].value;
199 /* Require that TYPE be an integral type; throw an exception if not. */
202 dwarf_require_integral (struct type *type)
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"));
210 /* Return the unsigned form of TYPE. TYPE is necessarily an integral
214 get_unsigned_type (struct gdbarch *gdbarch, struct type *type)
216 switch (TYPE_LENGTH (type))
219 return builtin_type (gdbarch)->builtin_uint8;
221 return builtin_type (gdbarch)->builtin_uint16;
223 return builtin_type (gdbarch)->builtin_uint32;
225 return builtin_type (gdbarch)->builtin_uint64;
227 error (_("no unsigned variant found for type, while evaluating "
228 "DWARF expression"));
232 /* Return the signed form of TYPE. TYPE is necessarily an integral
236 get_signed_type (struct gdbarch *gdbarch, struct type *type)
238 switch (TYPE_LENGTH (type))
241 return builtin_type (gdbarch)->builtin_int8;
243 return builtin_type (gdbarch)->builtin_int16;
245 return builtin_type (gdbarch)->builtin_int32;
247 return builtin_type (gdbarch)->builtin_int64;
249 error (_("no signed variant found for type, while evaluating "
250 "DWARF expression"));
254 /* Retrieve the N'th item on CTX's stack, converted to an address. */
257 dwarf_expr_fetch_address (struct dwarf_expr_context *ctx, int n)
259 struct value *result_val = dwarf_expr_fetch (ctx, n);
260 enum bfd_endian byte_order = gdbarch_byte_order (ctx->gdbarch);
263 dwarf_require_integral (value_type (result_val));
264 result = extract_unsigned_integer (value_contents (result_val),
265 TYPE_LENGTH (value_type (result_val)),
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))
276 gdb_byte *buf = alloca (ctx->addr_size);
277 struct type *int_type = get_unsigned_type (ctx->gdbarch,
278 value_type (result_val));
280 store_unsigned_integer (buf, ctx->addr_size, byte_order, result);
281 return gdbarch_integer_to_address (ctx->gdbarch, int_type, buf);
284 return (CORE_ADDR) result;
287 /* Retrieve the in_stack_memory flag of the N'th item on CTX's stack. */
290 dwarf_expr_fetch_in_stack_memory (struct dwarf_expr_context *ctx, int n)
292 if (ctx->stack_len <= n)
293 error (_("Asked for position %d of stack, "
294 "stack only has %d elements on it."),
296 return ctx->stack[ctx->stack_len - (1 + n)].in_stack_memory;
299 /* Return true if the expression stack is empty. */
302 dwarf_expr_stack_empty_p (struct dwarf_expr_context *ctx)
304 return ctx->stack_len == 0;
307 /* Add a new piece to CTX's piece list. */
309 add_piece (struct dwarf_expr_context *ctx, ULONGEST size, ULONGEST offset)
311 struct dwarf_expr_piece *p;
315 ctx->pieces = xrealloc (ctx->pieces,
317 * sizeof (struct dwarf_expr_piece)));
319 p = &ctx->pieces[ctx->num_pieces - 1];
320 p->location = ctx->location;
324 if (p->location == DWARF_VALUE_LITERAL)
326 p->v.literal.data = ctx->data;
327 p->v.literal.length = ctx->len;
329 else if (dwarf_expr_stack_empty_p (ctx))
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;
338 else if (p->location == DWARF_VALUE_MEMORY)
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);
343 else if (p->location == DWARF_VALUE_IMPLICIT_POINTER)
345 p->v.ptr.die.cu_off = ctx->len;
346 p->v.ptr.offset = value_as_long (dwarf_expr_fetch (ctx, 0));
348 else if (p->location == DWARF_VALUE_REGISTER)
349 p->v.regno = value_as_long (dwarf_expr_fetch (ctx, 0));
352 p->v.value = dwarf_expr_fetch (ctx, 0);
356 /* Evaluate the expression at ADDR (LEN bytes long) using the context
360 dwarf_expr_eval (struct dwarf_expr_context *ctx, const gdb_byte *addr,
363 int old_recursion_depth = ctx->recursion_depth;
365 execute_stack_op (ctx, addr, addr + len);
367 /* CTX RECURSION_DEPTH becomes invalid if an exception was thrown here. */
369 gdb_assert (ctx->recursion_depth == old_recursion_depth);
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. R can be NULL, the constant is then only skipped. */
377 read_uleb128 (const gdb_byte *buf, const gdb_byte *buf_end, ULONGEST * r)
386 error (_("read_uleb128: Corrupted DWARF expression."));
389 result |= ((ULONGEST) (byte & 0x7f)) << shift;
390 if ((byte & 0x80) == 0)
399 /* Decode the signed LEB128 constant at BUF into the variable pointed to
400 by R, and return the new value of BUF. Verify that it doesn't extend
401 past BUF_END. R can be NULL, the constant is then only skipped. */
404 read_sleb128 (const gdb_byte *buf, const gdb_byte *buf_end, LONGEST * r)
413 error (_("read_sleb128: Corrupted DWARF expression."));
416 result |= ((ULONGEST) (byte & 0x7f)) << shift;
418 if ((byte & 0x80) == 0)
421 if (shift < (sizeof (*r) * 8) && (byte & 0x40) != 0)
422 result |= -(((LONGEST) 1) << shift);
430 /* Check that the current operator is either at the end of an
431 expression, or that it is followed by a composition operator. */
434 dwarf_expr_require_composition (const gdb_byte *op_ptr, const gdb_byte *op_end,
437 /* It seems like DW_OP_GNU_uninit should be handled here. However,
438 it doesn't seem to make sense for DW_OP_*_value, and it was not
439 checked at the other place that this function is called. */
440 if (op_ptr != op_end && *op_ptr != DW_OP_piece && *op_ptr != DW_OP_bit_piece)
441 error (_("DWARF-2 expression error: `%s' operations must be "
442 "used either alone or in conjunction with DW_OP_piece "
443 "or DW_OP_bit_piece."),
447 /* Return true iff the types T1 and T2 are "the same". This only does
448 checks that might reasonably be needed to compare DWARF base
452 base_types_equal_p (struct type *t1, struct type *t2)
454 if (TYPE_CODE (t1) != TYPE_CODE (t2))
456 if (TYPE_UNSIGNED (t1) != TYPE_UNSIGNED (t2))
458 return TYPE_LENGTH (t1) == TYPE_LENGTH (t2);
461 /* A convenience function to call get_base_type on CTX and return the
462 result. DIE is the DIE whose type we need. SIZE is non-zero if
463 this function should verify that the resulting type has the correct
467 dwarf_get_base_type (struct dwarf_expr_context *ctx, cu_offset die, int size)
471 if (ctx->funcs->get_base_type)
473 result = ctx->funcs->get_base_type (ctx, die);
475 error (_("Could not find type for DW_OP_GNU_const_type"));
476 if (size != 0 && TYPE_LENGTH (result) != size)
477 error (_("DW_OP_GNU_const_type has different sizes for type and data"));
480 /* Anything will do. */
481 result = builtin_type (ctx->gdbarch)->builtin_int;
486 /* If <BUF..BUF_END] contains DW_FORM_block* with single DW_OP_reg* return the
487 DWARF register number. Otherwise return -1. */
490 dwarf_block_to_dwarf_reg (const gdb_byte *buf, const gdb_byte *buf_end)
496 if (*buf >= DW_OP_reg0 && *buf <= DW_OP_reg31)
498 if (buf_end - buf != 1)
500 return *buf - DW_OP_reg0;
503 if (*buf == DW_OP_GNU_regval_type)
506 buf = read_uleb128 (buf, buf_end, &dwarf_reg);
507 buf = read_uleb128 (buf, buf_end, NULL);
509 else if (*buf == DW_OP_regx)
512 buf = read_uleb128 (buf, buf_end, &dwarf_reg);
516 if (buf != buf_end || (int) dwarf_reg != dwarf_reg)
521 /* If <BUF..BUF_END] contains DW_FORM_block* with just DW_OP_breg*(0) and
522 DW_OP_deref* return the DWARF register number. Otherwise return -1.
523 DEREF_SIZE_RETURN contains -1 for DW_OP_deref; otherwise it contains the
524 size from DW_OP_deref_size. */
527 dwarf_block_to_dwarf_reg_deref (const gdb_byte *buf, const gdb_byte *buf_end,
528 CORE_ADDR *deref_size_return)
535 if (*buf >= DW_OP_breg0 && *buf <= DW_OP_breg31)
537 dwarf_reg = *buf - DW_OP_breg0;
540 else if (*buf == DW_OP_bregx)
543 buf = read_uleb128 (buf, buf_end, &dwarf_reg);
544 if ((int) dwarf_reg != dwarf_reg)
550 buf = read_sleb128 (buf, buf_end, &offset);
557 if (*buf == DW_OP_deref)
560 *deref_size_return = -1;
562 else if (*buf == DW_OP_deref_size)
567 *deref_size_return = *buf++;
578 /* If <BUF..BUF_END] contains DW_FORM_block* with single DW_OP_fbreg(X) fill
579 in FB_OFFSET_RETURN with the X offset and return 1. Otherwise return 0. */
582 dwarf_block_to_fb_offset (const gdb_byte *buf, const gdb_byte *buf_end,
583 CORE_ADDR *fb_offset_return)
590 if (*buf != DW_OP_fbreg)
594 buf = read_sleb128 (buf, buf_end, &fb_offset);
595 *fb_offset_return = fb_offset;
596 if (buf != buf_end || fb_offset != (LONGEST) *fb_offset_return)
602 /* If <BUF..BUF_END] contains DW_FORM_block* with single DW_OP_bregSP(X) fill
603 in SP_OFFSET_RETURN with the X offset and return 1. Otherwise return 0.
604 The matched SP register number depends on GDBARCH. */
607 dwarf_block_to_sp_offset (struct gdbarch *gdbarch, const gdb_byte *buf,
608 const gdb_byte *buf_end, CORE_ADDR *sp_offset_return)
615 if (*buf >= DW_OP_breg0 && *buf <= DW_OP_breg31)
617 dwarf_reg = *buf - DW_OP_breg0;
622 if (*buf != DW_OP_bregx)
625 buf = read_uleb128 (buf, buf_end, &dwarf_reg);
628 if (gdbarch_dwarf2_reg_to_regnum (gdbarch, dwarf_reg)
629 != gdbarch_sp_regnum (gdbarch))
632 buf = read_sleb128 (buf, buf_end, &sp_offset);
633 *sp_offset_return = sp_offset;
634 if (buf != buf_end || sp_offset != (LONGEST) *sp_offset_return)
640 /* The engine for the expression evaluator. Using the context in CTX,
641 evaluate the expression between OP_PTR and OP_END. */
644 execute_stack_op (struct dwarf_expr_context *ctx,
645 const gdb_byte *op_ptr, const gdb_byte *op_end)
647 enum bfd_endian byte_order = gdbarch_byte_order (ctx->gdbarch);
648 /* Old-style "untyped" DWARF values need special treatment in a
649 couple of places, specifically DW_OP_mod and DW_OP_shr. We need
650 a special type for these values so we can distinguish them from
651 values that have an explicit type, because explicitly-typed
652 values do not need special treatment. This special type must be
653 different (in the `==' sense) from any base type coming from the
655 struct type *address_type = dwarf_expr_address_type (ctx);
657 ctx->location = DWARF_VALUE_MEMORY;
658 ctx->initialized = 1; /* Default is initialized. */
660 if (ctx->recursion_depth > ctx->max_recursion_depth)
661 error (_("DWARF-2 expression error: Loop detected (%d)."),
662 ctx->recursion_depth);
663 ctx->recursion_depth++;
665 while (op_ptr < op_end)
667 enum dwarf_location_atom op = *op_ptr++;
669 /* Assume the value is not in stack memory.
670 Code that knows otherwise sets this to 1.
671 Some arithmetic on stack addresses can probably be assumed to still
672 be a stack address, but we skip this complication for now.
673 This is just an optimization, so it's always ok to punt
674 and leave this as 0. */
675 int in_stack_memory = 0;
676 ULONGEST uoffset, reg;
678 struct value *result_val = NULL;
680 /* The DWARF expression might have a bug causing an infinite
681 loop. In that case, quitting is the only way out. */
718 result = op - DW_OP_lit0;
719 result_val = value_from_ulongest (address_type, result);
723 result = extract_unsigned_integer (op_ptr,
724 ctx->addr_size, byte_order);
725 op_ptr += ctx->addr_size;
726 /* Some versions of GCC emit DW_OP_addr before
727 DW_OP_GNU_push_tls_address. In this case the value is an
728 index, not an address. We don't support things like
729 branching between the address and the TLS op. */
730 if (op_ptr >= op_end || *op_ptr != DW_OP_GNU_push_tls_address)
731 result += ctx->offset;
732 result_val = value_from_ulongest (address_type, result);
735 case DW_OP_GNU_addr_index:
736 op_ptr = read_uleb128 (op_ptr, op_end, &uoffset);
737 result = (ctx->funcs->get_addr_index) (ctx->baton, uoffset);
738 result_val = value_from_ulongest (address_type, result);
742 result = extract_unsigned_integer (op_ptr, 1, byte_order);
743 result_val = value_from_ulongest (address_type, result);
747 result = extract_signed_integer (op_ptr, 1, byte_order);
748 result_val = value_from_ulongest (address_type, result);
752 result = extract_unsigned_integer (op_ptr, 2, byte_order);
753 result_val = value_from_ulongest (address_type, result);
757 result = extract_signed_integer (op_ptr, 2, byte_order);
758 result_val = value_from_ulongest (address_type, result);
762 result = extract_unsigned_integer (op_ptr, 4, byte_order);
763 result_val = value_from_ulongest (address_type, result);
767 result = extract_signed_integer (op_ptr, 4, byte_order);
768 result_val = value_from_ulongest (address_type, result);
772 result = extract_unsigned_integer (op_ptr, 8, byte_order);
773 result_val = value_from_ulongest (address_type, result);
777 result = extract_signed_integer (op_ptr, 8, byte_order);
778 result_val = value_from_ulongest (address_type, result);
782 op_ptr = read_uleb128 (op_ptr, op_end, &uoffset);
784 result_val = value_from_ulongest (address_type, result);
787 op_ptr = read_sleb128 (op_ptr, op_end, &offset);
789 result_val = value_from_ulongest (address_type, result);
792 /* The DW_OP_reg operations are required to occur alone in
793 location expressions. */
827 && *op_ptr != DW_OP_piece
828 && *op_ptr != DW_OP_bit_piece
829 && *op_ptr != DW_OP_GNU_uninit)
830 error (_("DWARF-2 expression error: DW_OP_reg operations must be "
831 "used either alone or in conjunction with DW_OP_piece "
832 "or DW_OP_bit_piece."));
834 result = op - DW_OP_reg0;
835 result_val = value_from_ulongest (address_type, result);
836 ctx->location = DWARF_VALUE_REGISTER;
840 op_ptr = read_uleb128 (op_ptr, op_end, ®);
841 dwarf_expr_require_composition (op_ptr, op_end, "DW_OP_regx");
844 result_val = value_from_ulongest (address_type, result);
845 ctx->location = DWARF_VALUE_REGISTER;
848 case DW_OP_implicit_value:
852 op_ptr = read_uleb128 (op_ptr, op_end, &len);
853 if (op_ptr + len > op_end)
854 error (_("DW_OP_implicit_value: too few bytes available."));
857 ctx->location = DWARF_VALUE_LITERAL;
859 dwarf_expr_require_composition (op_ptr, op_end,
860 "DW_OP_implicit_value");
864 case DW_OP_stack_value:
865 ctx->location = DWARF_VALUE_STACK;
866 dwarf_expr_require_composition (op_ptr, op_end, "DW_OP_stack_value");
869 case DW_OP_GNU_implicit_pointer:
873 if (ctx->ref_addr_size == -1)
874 error (_("DWARF-2 expression error: DW_OP_GNU_implicit_pointer "
875 "is not allowed in frame context"));
877 /* The referred-to DIE of cu_offset kind. */
878 ctx->len = extract_unsigned_integer (op_ptr, ctx->ref_addr_size,
880 op_ptr += ctx->ref_addr_size;
882 /* The byte offset into the data. */
883 op_ptr = read_sleb128 (op_ptr, op_end, &len);
884 result = (ULONGEST) len;
885 result_val = value_from_ulongest (address_type, result);
887 ctx->location = DWARF_VALUE_IMPLICIT_POINTER;
888 dwarf_expr_require_composition (op_ptr, op_end,
889 "DW_OP_GNU_implicit_pointer");
926 op_ptr = read_sleb128 (op_ptr, op_end, &offset);
927 result = (ctx->funcs->read_reg) (ctx->baton, op - DW_OP_breg0);
929 result_val = value_from_ulongest (address_type, result);
934 op_ptr = read_uleb128 (op_ptr, op_end, ®);
935 op_ptr = read_sleb128 (op_ptr, op_end, &offset);
936 result = (ctx->funcs->read_reg) (ctx->baton, reg);
938 result_val = value_from_ulongest (address_type, result);
943 const gdb_byte *datastart;
945 unsigned int before_stack_len;
947 op_ptr = read_sleb128 (op_ptr, op_end, &offset);
948 /* Rather than create a whole new context, we simply
949 record the stack length before execution, then reset it
950 afterwards, effectively erasing whatever the recursive
952 before_stack_len = ctx->stack_len;
953 /* FIXME: cagney/2003-03-26: This code should be using
954 get_frame_base_address(), and then implement a dwarf2
955 specific this_base method. */
956 (ctx->funcs->get_frame_base) (ctx->baton, &datastart, &datalen);
957 dwarf_expr_eval (ctx, datastart, datalen);
958 if (ctx->location == DWARF_VALUE_MEMORY)
959 result = dwarf_expr_fetch_address (ctx, 0);
960 else if (ctx->location == DWARF_VALUE_REGISTER)
961 result = (ctx->funcs->read_reg) (ctx->baton,
962 value_as_long (dwarf_expr_fetch (ctx, 0)));
964 error (_("Not implemented: computing frame "
965 "base using explicit value operator"));
966 result = result + offset;
967 result_val = value_from_ulongest (address_type, result);
969 ctx->stack_len = before_stack_len;
970 ctx->location = DWARF_VALUE_MEMORY;
975 result_val = dwarf_expr_fetch (ctx, 0);
976 in_stack_memory = dwarf_expr_fetch_in_stack_memory (ctx, 0);
980 dwarf_expr_pop (ctx);
985 result_val = dwarf_expr_fetch (ctx, offset);
986 in_stack_memory = dwarf_expr_fetch_in_stack_memory (ctx, offset);
991 struct dwarf_stack_value t1, t2;
993 if (ctx->stack_len < 2)
994 error (_("Not enough elements for "
995 "DW_OP_swap. Need 2, have %d."),
997 t1 = ctx->stack[ctx->stack_len - 1];
998 t2 = ctx->stack[ctx->stack_len - 2];
999 ctx->stack[ctx->stack_len - 1] = t2;
1000 ctx->stack[ctx->stack_len - 2] = t1;
1005 result_val = dwarf_expr_fetch (ctx, 1);
1006 in_stack_memory = dwarf_expr_fetch_in_stack_memory (ctx, 1);
1011 struct dwarf_stack_value t1, t2, t3;
1013 if (ctx->stack_len < 3)
1014 error (_("Not enough elements for "
1015 "DW_OP_rot. Need 3, have %d."),
1017 t1 = ctx->stack[ctx->stack_len - 1];
1018 t2 = ctx->stack[ctx->stack_len - 2];
1019 t3 = ctx->stack[ctx->stack_len - 3];
1020 ctx->stack[ctx->stack_len - 1] = t2;
1021 ctx->stack[ctx->stack_len - 2] = t3;
1022 ctx->stack[ctx->stack_len - 3] = t1;
1027 case DW_OP_deref_size:
1028 case DW_OP_GNU_deref_type:
1030 int addr_size = (op == DW_OP_deref ? ctx->addr_size : *op_ptr++);
1031 gdb_byte *buf = alloca (addr_size);
1032 CORE_ADDR addr = dwarf_expr_fetch_address (ctx, 0);
1035 dwarf_expr_pop (ctx);
1037 if (op == DW_OP_GNU_deref_type)
1041 op_ptr = read_uleb128 (op_ptr, op_end, &uoffset);
1042 type_die.cu_off = uoffset;
1043 type = dwarf_get_base_type (ctx, type_die, 0);
1046 type = address_type;
1048 (ctx->funcs->read_mem) (ctx->baton, buf, addr, addr_size);
1050 /* If the size of the object read from memory is different
1051 from the type length, we need to zero-extend it. */
1052 if (TYPE_LENGTH (type) != addr_size)
1055 extract_unsigned_integer (buf, addr_size, byte_order);
1057 buf = alloca (TYPE_LENGTH (type));
1058 store_unsigned_integer (buf, TYPE_LENGTH (type),
1059 byte_order, result);
1062 result_val = value_from_contents_and_address (type, buf, addr);
1069 case DW_OP_plus_uconst:
1071 /* Unary operations. */
1072 result_val = dwarf_expr_fetch (ctx, 0);
1073 dwarf_expr_pop (ctx);
1078 if (value_less (result_val,
1079 value_zero (value_type (result_val), not_lval)))
1080 result_val = value_neg (result_val);
1083 result_val = value_neg (result_val);
1086 dwarf_require_integral (value_type (result_val));
1087 result_val = value_complement (result_val);
1089 case DW_OP_plus_uconst:
1090 dwarf_require_integral (value_type (result_val));
1091 result = value_as_long (result_val);
1092 op_ptr = read_uleb128 (op_ptr, op_end, ®);
1094 result_val = value_from_ulongest (address_type, result);
1118 /* Binary operations. */
1119 struct value *first, *second;
1121 second = dwarf_expr_fetch (ctx, 0);
1122 dwarf_expr_pop (ctx);
1124 first = dwarf_expr_fetch (ctx, 0);
1125 dwarf_expr_pop (ctx);
1127 if (! base_types_equal_p (value_type (first), value_type (second)))
1128 error (_("Incompatible types on DWARF stack"));
1133 dwarf_require_integral (value_type (first));
1134 dwarf_require_integral (value_type (second));
1135 result_val = value_binop (first, second, BINOP_BITWISE_AND);
1138 result_val = value_binop (first, second, BINOP_DIV);
1141 result_val = value_binop (first, second, BINOP_SUB);
1146 struct type *orig_type = value_type (first);
1148 /* We have to special-case "old-style" untyped values
1149 -- these must have mod computed using unsigned
1151 if (orig_type == address_type)
1154 = get_unsigned_type (ctx->gdbarch, orig_type);
1157 first = value_cast (utype, first);
1158 second = value_cast (utype, second);
1160 /* Note that value_binop doesn't handle float or
1161 decimal float here. This seems unimportant. */
1162 result_val = value_binop (first, second, BINOP_MOD);
1164 result_val = value_cast (orig_type, result_val);
1168 result_val = value_binop (first, second, BINOP_MUL);
1171 dwarf_require_integral (value_type (first));
1172 dwarf_require_integral (value_type (second));
1173 result_val = value_binop (first, second, BINOP_BITWISE_IOR);
1176 result_val = value_binop (first, second, BINOP_ADD);
1179 dwarf_require_integral (value_type (first));
1180 dwarf_require_integral (value_type (second));
1181 result_val = value_binop (first, second, BINOP_LSH);
1184 dwarf_require_integral (value_type (first));
1185 dwarf_require_integral (value_type (second));
1186 if (!TYPE_UNSIGNED (value_type (first)))
1189 = get_unsigned_type (ctx->gdbarch, value_type (first));
1191 first = value_cast (utype, first);
1194 result_val = value_binop (first, second, BINOP_RSH);
1195 /* Make sure we wind up with the same type we started
1197 if (value_type (result_val) != value_type (second))
1198 result_val = value_cast (value_type (second), result_val);
1201 dwarf_require_integral (value_type (first));
1202 dwarf_require_integral (value_type (second));
1203 if (TYPE_UNSIGNED (value_type (first)))
1206 = get_signed_type (ctx->gdbarch, value_type (first));
1208 first = value_cast (stype, first);
1211 result_val = value_binop (first, second, BINOP_RSH);
1212 /* Make sure we wind up with the same type we started
1214 if (value_type (result_val) != value_type (second))
1215 result_val = value_cast (value_type (second), result_val);
1218 dwarf_require_integral (value_type (first));
1219 dwarf_require_integral (value_type (second));
1220 result_val = value_binop (first, second, BINOP_BITWISE_XOR);
1223 /* A <= B is !(B < A). */
1224 result = ! value_less (second, first);
1225 result_val = value_from_ulongest (address_type, result);
1228 /* A >= B is !(A < B). */
1229 result = ! value_less (first, second);
1230 result_val = value_from_ulongest (address_type, result);
1233 result = value_equal (first, second);
1234 result_val = value_from_ulongest (address_type, result);
1237 result = value_less (first, second);
1238 result_val = value_from_ulongest (address_type, result);
1241 /* A > B is B < A. */
1242 result = value_less (second, first);
1243 result_val = value_from_ulongest (address_type, result);
1246 result = ! value_equal (first, second);
1247 result_val = value_from_ulongest (address_type, result);
1250 internal_error (__FILE__, __LINE__,
1251 _("Can't be reached."));
1256 case DW_OP_call_frame_cfa:
1257 result = (ctx->funcs->get_frame_cfa) (ctx->baton);
1258 result_val = value_from_ulongest (address_type, result);
1259 in_stack_memory = 1;
1262 case DW_OP_GNU_push_tls_address:
1263 /* Variable is at a constant offset in the thread-local
1264 storage block into the objfile for the current thread and
1265 the dynamic linker module containing this expression. Here
1266 we return returns the offset from that base. The top of the
1267 stack has the offset from the beginning of the thread
1268 control block at which the variable is located. Nothing
1269 should follow this operator, so the top of stack would be
1271 result = value_as_long (dwarf_expr_fetch (ctx, 0));
1272 dwarf_expr_pop (ctx);
1273 result = (ctx->funcs->get_tls_address) (ctx->baton, result);
1274 result_val = value_from_ulongest (address_type, result);
1278 offset = extract_signed_integer (op_ptr, 2, byte_order);
1287 offset = extract_signed_integer (op_ptr, 2, byte_order);
1289 val = dwarf_expr_fetch (ctx, 0);
1290 dwarf_require_integral (value_type (val));
1291 if (value_as_long (val) != 0)
1293 dwarf_expr_pop (ctx);
1304 /* Record the piece. */
1305 op_ptr = read_uleb128 (op_ptr, op_end, &size);
1306 add_piece (ctx, 8 * size, 0);
1308 /* Pop off the address/regnum, and reset the location
1310 if (ctx->location != DWARF_VALUE_LITERAL
1311 && ctx->location != DWARF_VALUE_OPTIMIZED_OUT)
1312 dwarf_expr_pop (ctx);
1313 ctx->location = DWARF_VALUE_MEMORY;
1317 case DW_OP_bit_piece:
1319 ULONGEST size, offset;
1321 /* Record the piece. */
1322 op_ptr = read_uleb128 (op_ptr, op_end, &size);
1323 op_ptr = read_uleb128 (op_ptr, op_end, &offset);
1324 add_piece (ctx, size, offset);
1326 /* Pop off the address/regnum, and reset the location
1328 if (ctx->location != DWARF_VALUE_LITERAL
1329 && ctx->location != DWARF_VALUE_OPTIMIZED_OUT)
1330 dwarf_expr_pop (ctx);
1331 ctx->location = DWARF_VALUE_MEMORY;
1335 case DW_OP_GNU_uninit:
1336 if (op_ptr != op_end)
1337 error (_("DWARF-2 expression error: DW_OP_GNU_uninit must always "
1338 "be the very last op."));
1340 ctx->initialized = 0;
1347 offset.cu_off = extract_unsigned_integer (op_ptr, 2, byte_order);
1349 ctx->funcs->dwarf_call (ctx, offset);
1357 offset.cu_off = extract_unsigned_integer (op_ptr, 4, byte_order);
1359 ctx->funcs->dwarf_call (ctx, offset);
1363 case DW_OP_GNU_entry_value:
1367 CORE_ADDR deref_size;
1369 op_ptr = read_uleb128 (op_ptr, op_end, &len);
1370 if (op_ptr + len > op_end)
1371 error (_("DW_OP_GNU_entry_value: too few bytes available."));
1373 dwarf_reg = dwarf_block_to_dwarf_reg (op_ptr, op_ptr + len);
1374 if (dwarf_reg != -1)
1377 ctx->funcs->push_dwarf_reg_entry_value (ctx, dwarf_reg,
1379 -1 /* deref_size */);
1383 dwarf_reg = dwarf_block_to_dwarf_reg_deref (op_ptr, op_ptr + len,
1385 if (dwarf_reg != -1)
1387 if (deref_size == -1)
1388 deref_size = ctx->addr_size;
1390 ctx->funcs->push_dwarf_reg_entry_value (ctx, dwarf_reg,
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*"));
1401 case DW_OP_GNU_const_type:
1405 const gdb_byte *data;
1408 op_ptr = read_uleb128 (op_ptr, op_end, &uoffset);
1409 type_die.cu_off = uoffset;
1414 type = dwarf_get_base_type (ctx, type_die, n);
1415 result_val = value_from_contents (type, data);
1419 case DW_OP_GNU_regval_type:
1424 op_ptr = read_uleb128 (op_ptr, op_end, ®);
1425 op_ptr = read_uleb128 (op_ptr, op_end, &uoffset);
1426 type_die.cu_off = uoffset;
1428 type = dwarf_get_base_type (ctx, type_die, 0);
1429 result = (ctx->funcs->read_reg) (ctx->baton, reg);
1430 result_val = value_from_ulongest (address_type, result);
1431 result_val = value_from_contents (type,
1432 value_contents_all (result_val));
1436 case DW_OP_GNU_convert:
1437 case DW_OP_GNU_reinterpret:
1442 op_ptr = read_uleb128 (op_ptr, op_end, &uoffset);
1443 type_die.cu_off = uoffset;
1445 if (type_die.cu_off == 0)
1446 type = address_type;
1448 type = dwarf_get_base_type (ctx, type_die, 0);
1450 result_val = dwarf_expr_fetch (ctx, 0);
1451 dwarf_expr_pop (ctx);
1453 if (op == DW_OP_GNU_convert)
1454 result_val = value_cast (type, result_val);
1455 else if (type == value_type (result_val))
1459 else if (TYPE_LENGTH (type)
1460 != TYPE_LENGTH (value_type (result_val)))
1461 error (_("DW_OP_GNU_reinterpret has wrong size"));
1464 = value_from_contents (type,
1465 value_contents_all (result_val));
1470 error (_("Unhandled dwarf expression opcode 0x%x"), op);
1473 /* Most things push a result value. */
1474 gdb_assert (result_val != NULL);
1475 dwarf_expr_push (ctx, result_val, in_stack_memory);
1480 /* To simplify our main caller, if the result is an implicit
1481 pointer, then make a pieced value. This is ok because we can't
1482 have implicit pointers in contexts where pieces are invalid. */
1483 if (ctx->location == DWARF_VALUE_IMPLICIT_POINTER)
1484 add_piece (ctx, 8 * ctx->addr_size, 0);
1487 ctx->recursion_depth--;
1488 gdb_assert (ctx->recursion_depth >= 0);
1491 /* Stub dwarf_expr_context_funcs.get_frame_base implementation. */
1494 ctx_no_get_frame_base (void *baton, const gdb_byte **start, size_t *length)
1496 error (_("%s is invalid in this context"), "DW_OP_fbreg");
1499 /* Stub dwarf_expr_context_funcs.get_frame_cfa implementation. */
1502 ctx_no_get_frame_cfa (void *baton)
1504 error (_("%s is invalid in this context"), "DW_OP_call_frame_cfa");
1507 /* Stub dwarf_expr_context_funcs.get_frame_pc implementation. */
1510 ctx_no_get_frame_pc (void *baton)
1512 error (_("%s is invalid in this context"), "DW_OP_GNU_implicit_pointer");
1515 /* Stub dwarf_expr_context_funcs.get_tls_address implementation. */
1518 ctx_no_get_tls_address (void *baton, CORE_ADDR offset)
1520 error (_("%s is invalid in this context"), "DW_OP_GNU_push_tls_address");
1523 /* Stub dwarf_expr_context_funcs.dwarf_call implementation. */
1526 ctx_no_dwarf_call (struct dwarf_expr_context *ctx, cu_offset die_offset)
1528 error (_("%s is invalid in this context"), "DW_OP_call*");
1531 /* Stub dwarf_expr_context_funcs.get_base_type implementation. */
1534 ctx_no_get_base_type (struct dwarf_expr_context *ctx, cu_offset die)
1536 error (_("Support for typed DWARF is not supported in this context"));
1539 /* Stub dwarf_expr_context_funcs.push_dwarf_block_entry_value
1543 ctx_no_push_dwarf_reg_entry_value (struct dwarf_expr_context *ctx,
1544 int dwarf_reg, CORE_ADDR fb_offset,
1547 internal_error (__FILE__, __LINE__,
1548 _("Support for DW_OP_GNU_entry_value is unimplemented"));
1551 /* Stub dwarf_expr_context_funcs.get_addr_index implementation. */
1554 ctx_no_get_addr_index (void *baton, unsigned int index)
1556 error (_("%s is invalid in this context"), "DW_OP_GNU_addr_index");
1559 /* Provide a prototype to silence -Wmissing-prototypes. */
1560 extern initialize_file_ftype _initialize_dwarf2expr;
1563 _initialize_dwarf2expr (void)
1566 = gdbarch_data_register_post_init (dwarf_gdbarch_types_init);