1 /* DWARF 2 Expression Evaluator.
3 Copyright (C) 2001-2016 Free Software Foundation, Inc.
5 Contributed by Daniel Berlin (dan@dberlin.org)
7 This file is part of GDB.
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.
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.
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/>. */
28 #include "dwarf2expr.h"
29 #include "dwarf2loc.h"
31 /* Local prototypes. */
33 static void execute_stack_op (struct dwarf_expr_context
*,
34 const gdb_byte
*, const gdb_byte
*);
36 /* Cookie for gdbarch data. */
38 static struct gdbarch_data
*dwarf_arch_cookie
;
40 /* This holds gdbarch-specific types used by the DWARF expression
41 evaluator. See comments in execute_stack_op. */
43 struct dwarf_gdbarch_types
45 struct type
*dw_types
[3];
48 /* Allocate and fill in dwarf_gdbarch_types for an arch. */
51 dwarf_gdbarch_types_init (struct gdbarch
*gdbarch
)
53 struct dwarf_gdbarch_types
*types
54 = GDBARCH_OBSTACK_ZALLOC (gdbarch
, struct dwarf_gdbarch_types
);
56 /* The types themselves are lazily initialized. */
61 /* Return the type used for DWARF operations where the type is
62 unspecified in the DWARF spec. Only certain sizes are
66 dwarf_expr_address_type (struct dwarf_expr_context
*ctx
)
68 struct dwarf_gdbarch_types
*types
69 = (struct dwarf_gdbarch_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
= XCNEW (struct dwarf_expr_context
);
100 retval
->stack_len
= 0;
101 retval
->stack_allocated
= 10;
102 retval
->stack
= XNEWVEC (struct dwarf_stack_value
, retval
->stack_allocated
);
103 retval
->num_pieces
= 0;
105 retval
->max_recursion_depth
= 0x100;
109 /* Release the memory allocated to CTX. */
112 free_dwarf_expr_context (struct dwarf_expr_context
*ctx
)
119 /* Helper for make_cleanup_free_dwarf_expr_context. */
122 free_dwarf_expr_context_cleanup (void *arg
)
124 free_dwarf_expr_context ((struct dwarf_expr_context
*) arg
);
127 /* Return a cleanup that calls free_dwarf_expr_context. */
130 make_cleanup_free_dwarf_expr_context (struct dwarf_expr_context
*ctx
)
132 return make_cleanup (free_dwarf_expr_context_cleanup
, ctx
);
135 /* Expand the memory allocated to CTX's stack to contain at least
136 NEED more elements than are currently used. */
139 dwarf_expr_grow_stack (struct dwarf_expr_context
*ctx
, size_t need
)
141 if (ctx
->stack_len
+ need
> ctx
->stack_allocated
)
143 size_t newlen
= ctx
->stack_len
+ need
+ 10;
145 ctx
->stack
= XRESIZEVEC (struct dwarf_stack_value
, ctx
->stack
, newlen
);
146 ctx
->stack_allocated
= newlen
;
150 /* Push VALUE onto CTX's stack. */
153 dwarf_expr_push (struct dwarf_expr_context
*ctx
, struct value
*value
,
156 struct dwarf_stack_value
*v
;
158 dwarf_expr_grow_stack (ctx
, 1);
159 v
= &ctx
->stack
[ctx
->stack_len
++];
161 v
->in_stack_memory
= in_stack_memory
;
164 /* Push VALUE onto CTX's stack. */
167 dwarf_expr_push_address (struct dwarf_expr_context
*ctx
, CORE_ADDR value
,
170 dwarf_expr_push (ctx
,
171 value_from_ulongest (dwarf_expr_address_type (ctx
), value
),
175 /* Pop the top item off of CTX's stack. */
178 dwarf_expr_pop (struct dwarf_expr_context
*ctx
)
180 if (ctx
->stack_len
<= 0)
181 error (_("dwarf expression stack underflow"));
185 /* Retrieve the N'th item on CTX's stack. */
188 dwarf_expr_fetch (struct dwarf_expr_context
*ctx
, int n
)
190 if (ctx
->stack_len
<= n
)
191 error (_("Asked for position %d of stack, "
192 "stack only has %d elements on it."),
194 return ctx
->stack
[ctx
->stack_len
- (1 + n
)].value
;
197 /* Require that TYPE be an integral type; throw an exception if not. */
200 dwarf_require_integral (struct type
*type
)
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"));
208 /* Return the unsigned form of TYPE. TYPE is necessarily an integral
212 get_unsigned_type (struct gdbarch
*gdbarch
, struct type
*type
)
214 switch (TYPE_LENGTH (type
))
217 return builtin_type (gdbarch
)->builtin_uint8
;
219 return builtin_type (gdbarch
)->builtin_uint16
;
221 return builtin_type (gdbarch
)->builtin_uint32
;
223 return builtin_type (gdbarch
)->builtin_uint64
;
225 error (_("no unsigned variant found for type, while evaluating "
226 "DWARF expression"));
230 /* Return the signed form of TYPE. TYPE is necessarily an integral
234 get_signed_type (struct gdbarch
*gdbarch
, struct type
*type
)
236 switch (TYPE_LENGTH (type
))
239 return builtin_type (gdbarch
)->builtin_int8
;
241 return builtin_type (gdbarch
)->builtin_int16
;
243 return builtin_type (gdbarch
)->builtin_int32
;
245 return builtin_type (gdbarch
)->builtin_int64
;
247 error (_("no signed variant found for type, while evaluating "
248 "DWARF expression"));
252 /* Retrieve the N'th item on CTX's stack, converted to an address. */
255 dwarf_expr_fetch_address (struct dwarf_expr_context
*ctx
, int n
)
257 struct value
*result_val
= dwarf_expr_fetch (ctx
, n
);
258 enum bfd_endian byte_order
= gdbarch_byte_order (ctx
->gdbarch
);
261 dwarf_require_integral (value_type (result_val
));
262 result
= extract_unsigned_integer (value_contents (result_val
),
263 TYPE_LENGTH (value_type (result_val
)),
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. */
272 if (gdbarch_integer_to_address_p (ctx
->gdbarch
))
274 gdb_byte
*buf
= (gdb_byte
*) alloca (ctx
->addr_size
);
275 struct type
*int_type
= get_unsigned_type (ctx
->gdbarch
,
276 value_type (result_val
));
278 store_unsigned_integer (buf
, ctx
->addr_size
, byte_order
, result
);
279 return gdbarch_integer_to_address (ctx
->gdbarch
, int_type
, buf
);
282 return (CORE_ADDR
) result
;
285 /* Retrieve the in_stack_memory flag of the N'th item on CTX's stack. */
288 dwarf_expr_fetch_in_stack_memory (struct dwarf_expr_context
*ctx
, int n
)
290 if (ctx
->stack_len
<= n
)
291 error (_("Asked for position %d of stack, "
292 "stack only has %d elements on it."),
294 return ctx
->stack
[ctx
->stack_len
- (1 + n
)].in_stack_memory
;
297 /* Return true if the expression stack is empty. */
300 dwarf_expr_stack_empty_p (struct dwarf_expr_context
*ctx
)
302 return ctx
->stack_len
== 0;
305 /* Add a new piece to CTX's piece list. */
307 add_piece (struct dwarf_expr_context
*ctx
, ULONGEST size
, ULONGEST offset
)
309 struct dwarf_expr_piece
*p
;
314 = XRESIZEVEC (struct dwarf_expr_piece
, ctx
->pieces
, ctx
->num_pieces
);
316 p
= &ctx
->pieces
[ctx
->num_pieces
- 1];
317 p
->location
= ctx
->location
;
321 if (p
->location
== DWARF_VALUE_LITERAL
)
323 p
->v
.literal
.data
= ctx
->data
;
324 p
->v
.literal
.length
= ctx
->len
;
326 else if (dwarf_expr_stack_empty_p (ctx
))
328 p
->location
= DWARF_VALUE_OPTIMIZED_OUT
;
329 /* Also reset the context's location, for our callers. This is
330 a somewhat strange approach, but this lets us avoid setting
331 the location to DWARF_VALUE_MEMORY in all the individual
332 cases in the evaluator. */
333 ctx
->location
= DWARF_VALUE_OPTIMIZED_OUT
;
335 else if (p
->location
== DWARF_VALUE_MEMORY
)
337 p
->v
.mem
.addr
= dwarf_expr_fetch_address (ctx
, 0);
338 p
->v
.mem
.in_stack_memory
= dwarf_expr_fetch_in_stack_memory (ctx
, 0);
340 else if (p
->location
== DWARF_VALUE_IMPLICIT_POINTER
)
342 p
->v
.ptr
.die
.sect_off
= ctx
->len
;
343 p
->v
.ptr
.offset
= value_as_long (dwarf_expr_fetch (ctx
, 0));
345 else if (p
->location
== DWARF_VALUE_REGISTER
)
346 p
->v
.regno
= value_as_long (dwarf_expr_fetch (ctx
, 0));
349 p
->v
.value
= dwarf_expr_fetch (ctx
, 0);
353 /* Evaluate the expression at ADDR (LEN bytes long) using the context
357 dwarf_expr_eval (struct dwarf_expr_context
*ctx
, const gdb_byte
*addr
,
360 int old_recursion_depth
= ctx
->recursion_depth
;
362 execute_stack_op (ctx
, addr
, addr
+ len
);
364 /* CTX RECURSION_DEPTH becomes invalid if an exception was thrown here. */
366 gdb_assert (ctx
->recursion_depth
== old_recursion_depth
);
369 /* Helper to read a uleb128 value or throw an error. */
372 safe_read_uleb128 (const gdb_byte
*buf
, const gdb_byte
*buf_end
,
375 buf
= gdb_read_uleb128 (buf
, buf_end
, r
);
377 error (_("DWARF expression error: ran off end of buffer reading uleb128 value"));
381 /* Helper to read a sleb128 value or throw an error. */
384 safe_read_sleb128 (const gdb_byte
*buf
, const gdb_byte
*buf_end
,
387 buf
= gdb_read_sleb128 (buf
, buf_end
, r
);
389 error (_("DWARF expression error: ran off end of buffer reading sleb128 value"));
394 safe_skip_leb128 (const gdb_byte
*buf
, const gdb_byte
*buf_end
)
396 buf
= gdb_skip_leb128 (buf
, buf_end
);
398 error (_("DWARF expression error: ran off end of buffer reading leb128 value"));
403 /* Check that the current operator is either at the end of an
404 expression, or that it is followed by a composition operator or by
405 DW_OP_GNU_uninit (which should terminate the expression). */
408 dwarf_expr_require_composition (const gdb_byte
*op_ptr
, const gdb_byte
*op_end
,
411 if (op_ptr
!= op_end
&& *op_ptr
!= DW_OP_piece
&& *op_ptr
!= DW_OP_bit_piece
412 && *op_ptr
!= DW_OP_GNU_uninit
)
413 error (_("DWARF-2 expression error: `%s' operations must be "
414 "used either alone or in conjunction with DW_OP_piece "
415 "or DW_OP_bit_piece."),
419 /* Return true iff the types T1 and T2 are "the same". This only does
420 checks that might reasonably be needed to compare DWARF base
424 base_types_equal_p (struct type
*t1
, struct type
*t2
)
426 if (TYPE_CODE (t1
) != TYPE_CODE (t2
))
428 if (TYPE_UNSIGNED (t1
) != TYPE_UNSIGNED (t2
))
430 return TYPE_LENGTH (t1
) == TYPE_LENGTH (t2
);
433 /* A convenience function to call get_base_type on CTX and return the
434 result. DIE is the DIE whose type we need. SIZE is non-zero if
435 this function should verify that the resulting type has the correct
439 dwarf_get_base_type (struct dwarf_expr_context
*ctx
, cu_offset die
, int size
)
443 if (ctx
->funcs
->get_base_type
)
445 result
= ctx
->funcs
->get_base_type (ctx
, die
);
447 error (_("Could not find type for DW_OP_GNU_const_type"));
448 if (size
!= 0 && TYPE_LENGTH (result
) != size
)
449 error (_("DW_OP_GNU_const_type has different sizes for type and data"));
452 /* Anything will do. */
453 result
= builtin_type (ctx
->gdbarch
)->builtin_int
;
458 /* If <BUF..BUF_END] contains DW_FORM_block* with single DW_OP_reg* return the
459 DWARF register number. Otherwise return -1. */
462 dwarf_block_to_dwarf_reg (const gdb_byte
*buf
, const gdb_byte
*buf_end
)
468 if (*buf
>= DW_OP_reg0
&& *buf
<= DW_OP_reg31
)
470 if (buf_end
- buf
!= 1)
472 return *buf
- DW_OP_reg0
;
475 if (*buf
== DW_OP_GNU_regval_type
)
478 buf
= gdb_read_uleb128 (buf
, buf_end
, &dwarf_reg
);
481 buf
= gdb_skip_leb128 (buf
, buf_end
);
485 else if (*buf
== DW_OP_regx
)
488 buf
= gdb_read_uleb128 (buf
, buf_end
, &dwarf_reg
);
494 if (buf
!= buf_end
|| (int) dwarf_reg
!= dwarf_reg
)
499 /* If <BUF..BUF_END] contains DW_FORM_block* with just DW_OP_breg*(0) and
500 DW_OP_deref* return the DWARF register number. Otherwise return -1.
501 DEREF_SIZE_RETURN contains -1 for DW_OP_deref; otherwise it contains the
502 size from DW_OP_deref_size. */
505 dwarf_block_to_dwarf_reg_deref (const gdb_byte
*buf
, const gdb_byte
*buf_end
,
506 CORE_ADDR
*deref_size_return
)
514 if (*buf
>= DW_OP_breg0
&& *buf
<= DW_OP_breg31
)
516 dwarf_reg
= *buf
- DW_OP_breg0
;
521 else if (*buf
== DW_OP_bregx
)
524 buf
= gdb_read_uleb128 (buf
, buf_end
, &dwarf_reg
);
527 if ((int) dwarf_reg
!= dwarf_reg
)
533 buf
= gdb_read_sleb128 (buf
, buf_end
, &offset
);
539 if (*buf
== DW_OP_deref
)
542 *deref_size_return
= -1;
544 else if (*buf
== DW_OP_deref_size
)
549 *deref_size_return
= *buf
++;
560 /* If <BUF..BUF_END] contains DW_FORM_block* with single DW_OP_fbreg(X) fill
561 in FB_OFFSET_RETURN with the X offset and return 1. Otherwise return 0. */
564 dwarf_block_to_fb_offset (const gdb_byte
*buf
, const gdb_byte
*buf_end
,
565 CORE_ADDR
*fb_offset_return
)
572 if (*buf
!= DW_OP_fbreg
)
576 buf
= gdb_read_sleb128 (buf
, buf_end
, &fb_offset
);
579 *fb_offset_return
= fb_offset
;
580 if (buf
!= buf_end
|| fb_offset
!= (LONGEST
) *fb_offset_return
)
586 /* If <BUF..BUF_END] contains DW_FORM_block* with single DW_OP_bregSP(X) fill
587 in SP_OFFSET_RETURN with the X offset and return 1. Otherwise return 0.
588 The matched SP register number depends on GDBARCH. */
591 dwarf_block_to_sp_offset (struct gdbarch
*gdbarch
, const gdb_byte
*buf
,
592 const gdb_byte
*buf_end
, CORE_ADDR
*sp_offset_return
)
599 if (*buf
>= DW_OP_breg0
&& *buf
<= DW_OP_breg31
)
601 dwarf_reg
= *buf
- DW_OP_breg0
;
606 if (*buf
!= DW_OP_bregx
)
609 buf
= gdb_read_uleb128 (buf
, buf_end
, &dwarf_reg
);
614 if (dwarf_reg_to_regnum (gdbarch
, dwarf_reg
)
615 != gdbarch_sp_regnum (gdbarch
))
618 buf
= gdb_read_sleb128 (buf
, buf_end
, &sp_offset
);
621 *sp_offset_return
= sp_offset
;
622 if (buf
!= buf_end
|| sp_offset
!= (LONGEST
) *sp_offset_return
)
628 /* The engine for the expression evaluator. Using the context in CTX,
629 evaluate the expression between OP_PTR and OP_END. */
632 execute_stack_op (struct dwarf_expr_context
*ctx
,
633 const gdb_byte
*op_ptr
, const gdb_byte
*op_end
)
635 enum bfd_endian byte_order
= gdbarch_byte_order (ctx
->gdbarch
);
636 /* Old-style "untyped" DWARF values need special treatment in a
637 couple of places, specifically DW_OP_mod and DW_OP_shr. We need
638 a special type for these values so we can distinguish them from
639 values that have an explicit type, because explicitly-typed
640 values do not need special treatment. This special type must be
641 different (in the `==' sense) from any base type coming from the
643 struct type
*address_type
= dwarf_expr_address_type (ctx
);
645 ctx
->location
= DWARF_VALUE_MEMORY
;
646 ctx
->initialized
= 1; /* Default is initialized. */
648 if (ctx
->recursion_depth
> ctx
->max_recursion_depth
)
649 error (_("DWARF-2 expression error: Loop detected (%d)."),
650 ctx
->recursion_depth
);
651 ctx
->recursion_depth
++;
653 while (op_ptr
< op_end
)
655 enum dwarf_location_atom op
= (enum dwarf_location_atom
) *op_ptr
++;
657 /* Assume the value is not in stack memory.
658 Code that knows otherwise sets this to 1.
659 Some arithmetic on stack addresses can probably be assumed to still
660 be a stack address, but we skip this complication for now.
661 This is just an optimization, so it's always ok to punt
662 and leave this as 0. */
663 int in_stack_memory
= 0;
664 uint64_t uoffset
, reg
;
666 struct value
*result_val
= NULL
;
668 /* The DWARF expression might have a bug causing an infinite
669 loop. In that case, quitting is the only way out. */
706 result
= op
- DW_OP_lit0
;
707 result_val
= value_from_ulongest (address_type
, result
);
711 result
= extract_unsigned_integer (op_ptr
,
712 ctx
->addr_size
, byte_order
);
713 op_ptr
+= ctx
->addr_size
;
714 /* Some versions of GCC emit DW_OP_addr before
715 DW_OP_GNU_push_tls_address. In this case the value is an
716 index, not an address. We don't support things like
717 branching between the address and the TLS op. */
718 if (op_ptr
>= op_end
|| *op_ptr
!= DW_OP_GNU_push_tls_address
)
719 result
+= ctx
->offset
;
720 result_val
= value_from_ulongest (address_type
, result
);
723 case DW_OP_GNU_addr_index
:
724 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, &uoffset
);
725 result
= (ctx
->funcs
->get_addr_index
) (ctx
->baton
, uoffset
);
726 result
+= ctx
->offset
;
727 result_val
= value_from_ulongest (address_type
, result
);
729 case DW_OP_GNU_const_index
:
730 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, &uoffset
);
731 result
= (ctx
->funcs
->get_addr_index
) (ctx
->baton
, uoffset
);
732 result_val
= value_from_ulongest (address_type
, result
);
736 result
= extract_unsigned_integer (op_ptr
, 1, byte_order
);
737 result_val
= value_from_ulongest (address_type
, result
);
741 result
= extract_signed_integer (op_ptr
, 1, byte_order
);
742 result_val
= value_from_ulongest (address_type
, result
);
746 result
= extract_unsigned_integer (op_ptr
, 2, byte_order
);
747 result_val
= value_from_ulongest (address_type
, result
);
751 result
= extract_signed_integer (op_ptr
, 2, byte_order
);
752 result_val
= value_from_ulongest (address_type
, result
);
756 result
= extract_unsigned_integer (op_ptr
, 4, byte_order
);
757 result_val
= value_from_ulongest (address_type
, result
);
761 result
= extract_signed_integer (op_ptr
, 4, byte_order
);
762 result_val
= value_from_ulongest (address_type
, result
);
766 result
= extract_unsigned_integer (op_ptr
, 8, byte_order
);
767 result_val
= value_from_ulongest (address_type
, result
);
771 result
= extract_signed_integer (op_ptr
, 8, byte_order
);
772 result_val
= value_from_ulongest (address_type
, result
);
776 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, &uoffset
);
778 result_val
= value_from_ulongest (address_type
, result
);
781 op_ptr
= safe_read_sleb128 (op_ptr
, op_end
, &offset
);
783 result_val
= value_from_ulongest (address_type
, result
);
786 /* The DW_OP_reg operations are required to occur alone in
787 location expressions. */
820 dwarf_expr_require_composition (op_ptr
, op_end
, "DW_OP_reg");
822 result
= op
- DW_OP_reg0
;
823 result_val
= value_from_ulongest (address_type
, result
);
824 ctx
->location
= DWARF_VALUE_REGISTER
;
828 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, ®
);
829 dwarf_expr_require_composition (op_ptr
, op_end
, "DW_OP_regx");
832 result_val
= value_from_ulongest (address_type
, result
);
833 ctx
->location
= DWARF_VALUE_REGISTER
;
836 case DW_OP_implicit_value
:
840 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, &len
);
841 if (op_ptr
+ len
> op_end
)
842 error (_("DW_OP_implicit_value: too few bytes available."));
845 ctx
->location
= DWARF_VALUE_LITERAL
;
847 dwarf_expr_require_composition (op_ptr
, op_end
,
848 "DW_OP_implicit_value");
852 case DW_OP_stack_value
:
853 ctx
->location
= DWARF_VALUE_STACK
;
854 dwarf_expr_require_composition (op_ptr
, op_end
, "DW_OP_stack_value");
857 case DW_OP_GNU_implicit_pointer
:
861 if (ctx
->ref_addr_size
== -1)
862 error (_("DWARF-2 expression error: DW_OP_GNU_implicit_pointer "
863 "is not allowed in frame context"));
865 /* The referred-to DIE of sect_offset kind. */
866 ctx
->len
= extract_unsigned_integer (op_ptr
, ctx
->ref_addr_size
,
868 op_ptr
+= ctx
->ref_addr_size
;
870 /* The byte offset into the data. */
871 op_ptr
= safe_read_sleb128 (op_ptr
, op_end
, &len
);
872 result
= (ULONGEST
) len
;
873 result_val
= value_from_ulongest (address_type
, result
);
875 ctx
->location
= DWARF_VALUE_IMPLICIT_POINTER
;
876 dwarf_expr_require_composition (op_ptr
, op_end
,
877 "DW_OP_GNU_implicit_pointer");
914 op_ptr
= safe_read_sleb128 (op_ptr
, op_end
, &offset
);
915 result
= (ctx
->funcs
->read_addr_from_reg
) (ctx
->baton
,
918 result_val
= value_from_ulongest (address_type
, result
);
923 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, ®
);
924 op_ptr
= safe_read_sleb128 (op_ptr
, op_end
, &offset
);
925 result
= (ctx
->funcs
->read_addr_from_reg
) (ctx
->baton
, reg
);
927 result_val
= value_from_ulongest (address_type
, result
);
932 const gdb_byte
*datastart
;
934 unsigned int before_stack_len
;
936 op_ptr
= safe_read_sleb128 (op_ptr
, op_end
, &offset
);
937 /* Rather than create a whole new context, we simply
938 record the stack length before execution, then reset it
939 afterwards, effectively erasing whatever the recursive
941 before_stack_len
= ctx
->stack_len
;
942 /* FIXME: cagney/2003-03-26: This code should be using
943 get_frame_base_address(), and then implement a dwarf2
944 specific this_base method. */
945 (ctx
->funcs
->get_frame_base
) (ctx
->baton
, &datastart
, &datalen
);
946 dwarf_expr_eval (ctx
, datastart
, datalen
);
947 if (ctx
->location
== DWARF_VALUE_MEMORY
)
948 result
= dwarf_expr_fetch_address (ctx
, 0);
949 else if (ctx
->location
== DWARF_VALUE_REGISTER
)
950 result
= (ctx
->funcs
->read_addr_from_reg
)
952 value_as_long (dwarf_expr_fetch (ctx
, 0)));
954 error (_("Not implemented: computing frame "
955 "base using explicit value operator"));
956 result
= result
+ offset
;
957 result_val
= value_from_ulongest (address_type
, result
);
959 ctx
->stack_len
= before_stack_len
;
960 ctx
->location
= DWARF_VALUE_MEMORY
;
965 result_val
= dwarf_expr_fetch (ctx
, 0);
966 in_stack_memory
= dwarf_expr_fetch_in_stack_memory (ctx
, 0);
970 dwarf_expr_pop (ctx
);
975 result_val
= dwarf_expr_fetch (ctx
, offset
);
976 in_stack_memory
= dwarf_expr_fetch_in_stack_memory (ctx
, offset
);
981 struct dwarf_stack_value t1
, t2
;
983 if (ctx
->stack_len
< 2)
984 error (_("Not enough elements for "
985 "DW_OP_swap. Need 2, have %d."),
987 t1
= ctx
->stack
[ctx
->stack_len
- 1];
988 t2
= ctx
->stack
[ctx
->stack_len
- 2];
989 ctx
->stack
[ctx
->stack_len
- 1] = t2
;
990 ctx
->stack
[ctx
->stack_len
- 2] = t1
;
995 result_val
= dwarf_expr_fetch (ctx
, 1);
996 in_stack_memory
= dwarf_expr_fetch_in_stack_memory (ctx
, 1);
1001 struct dwarf_stack_value t1
, t2
, t3
;
1003 if (ctx
->stack_len
< 3)
1004 error (_("Not enough elements for "
1005 "DW_OP_rot. Need 3, have %d."),
1007 t1
= ctx
->stack
[ctx
->stack_len
- 1];
1008 t2
= ctx
->stack
[ctx
->stack_len
- 2];
1009 t3
= ctx
->stack
[ctx
->stack_len
- 3];
1010 ctx
->stack
[ctx
->stack_len
- 1] = t2
;
1011 ctx
->stack
[ctx
->stack_len
- 2] = t3
;
1012 ctx
->stack
[ctx
->stack_len
- 3] = t1
;
1017 case DW_OP_deref_size
:
1018 case DW_OP_GNU_deref_type
:
1020 int addr_size
= (op
== DW_OP_deref
? ctx
->addr_size
: *op_ptr
++);
1021 gdb_byte
*buf
= (gdb_byte
*) alloca (addr_size
);
1022 CORE_ADDR addr
= dwarf_expr_fetch_address (ctx
, 0);
1025 dwarf_expr_pop (ctx
);
1027 if (op
== DW_OP_GNU_deref_type
)
1031 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, &uoffset
);
1032 type_die
.cu_off
= uoffset
;
1033 type
= dwarf_get_base_type (ctx
, type_die
, 0);
1036 type
= address_type
;
1038 (ctx
->funcs
->read_mem
) (ctx
->baton
, buf
, addr
, addr_size
);
1040 /* If the size of the object read from memory is different
1041 from the type length, we need to zero-extend it. */
1042 if (TYPE_LENGTH (type
) != addr_size
)
1045 extract_unsigned_integer (buf
, addr_size
, byte_order
);
1047 buf
= (gdb_byte
*) alloca (TYPE_LENGTH (type
));
1048 store_unsigned_integer (buf
, TYPE_LENGTH (type
),
1049 byte_order
, result
);
1052 result_val
= value_from_contents_and_address (type
, buf
, addr
);
1059 case DW_OP_plus_uconst
:
1061 /* Unary operations. */
1062 result_val
= dwarf_expr_fetch (ctx
, 0);
1063 dwarf_expr_pop (ctx
);
1068 if (value_less (result_val
,
1069 value_zero (value_type (result_val
), not_lval
)))
1070 result_val
= value_neg (result_val
);
1073 result_val
= value_neg (result_val
);
1076 dwarf_require_integral (value_type (result_val
));
1077 result_val
= value_complement (result_val
);
1079 case DW_OP_plus_uconst
:
1080 dwarf_require_integral (value_type (result_val
));
1081 result
= value_as_long (result_val
);
1082 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, ®
);
1084 result_val
= value_from_ulongest (address_type
, result
);
1108 /* Binary operations. */
1109 struct value
*first
, *second
;
1111 second
= dwarf_expr_fetch (ctx
, 0);
1112 dwarf_expr_pop (ctx
);
1114 first
= dwarf_expr_fetch (ctx
, 0);
1115 dwarf_expr_pop (ctx
);
1117 if (! base_types_equal_p (value_type (first
), value_type (second
)))
1118 error (_("Incompatible types on DWARF stack"));
1123 dwarf_require_integral (value_type (first
));
1124 dwarf_require_integral (value_type (second
));
1125 result_val
= value_binop (first
, second
, BINOP_BITWISE_AND
);
1128 result_val
= value_binop (first
, second
, BINOP_DIV
);
1131 result_val
= value_binop (first
, second
, BINOP_SUB
);
1136 struct type
*orig_type
= value_type (first
);
1138 /* We have to special-case "old-style" untyped values
1139 -- these must have mod computed using unsigned
1141 if (orig_type
== address_type
)
1144 = get_unsigned_type (ctx
->gdbarch
, orig_type
);
1147 first
= value_cast (utype
, first
);
1148 second
= value_cast (utype
, second
);
1150 /* Note that value_binop doesn't handle float or
1151 decimal float here. This seems unimportant. */
1152 result_val
= value_binop (first
, second
, BINOP_MOD
);
1154 result_val
= value_cast (orig_type
, result_val
);
1158 result_val
= value_binop (first
, second
, BINOP_MUL
);
1161 dwarf_require_integral (value_type (first
));
1162 dwarf_require_integral (value_type (second
));
1163 result_val
= value_binop (first
, second
, BINOP_BITWISE_IOR
);
1166 result_val
= value_binop (first
, second
, BINOP_ADD
);
1169 dwarf_require_integral (value_type (first
));
1170 dwarf_require_integral (value_type (second
));
1171 result_val
= value_binop (first
, second
, BINOP_LSH
);
1174 dwarf_require_integral (value_type (first
));
1175 dwarf_require_integral (value_type (second
));
1176 if (!TYPE_UNSIGNED (value_type (first
)))
1179 = get_unsigned_type (ctx
->gdbarch
, value_type (first
));
1181 first
= value_cast (utype
, first
);
1184 result_val
= value_binop (first
, second
, BINOP_RSH
);
1185 /* Make sure we wind up with the same type we started
1187 if (value_type (result_val
) != value_type (second
))
1188 result_val
= value_cast (value_type (second
), result_val
);
1191 dwarf_require_integral (value_type (first
));
1192 dwarf_require_integral (value_type (second
));
1193 if (TYPE_UNSIGNED (value_type (first
)))
1196 = get_signed_type (ctx
->gdbarch
, value_type (first
));
1198 first
= value_cast (stype
, first
);
1201 result_val
= value_binop (first
, second
, BINOP_RSH
);
1202 /* Make sure we wind up with the same type we started
1204 if (value_type (result_val
) != value_type (second
))
1205 result_val
= value_cast (value_type (second
), result_val
);
1208 dwarf_require_integral (value_type (first
));
1209 dwarf_require_integral (value_type (second
));
1210 result_val
= value_binop (first
, second
, BINOP_BITWISE_XOR
);
1213 /* A <= B is !(B < A). */
1214 result
= ! value_less (second
, first
);
1215 result_val
= value_from_ulongest (address_type
, result
);
1218 /* A >= B is !(A < B). */
1219 result
= ! value_less (first
, second
);
1220 result_val
= value_from_ulongest (address_type
, result
);
1223 result
= value_equal (first
, second
);
1224 result_val
= value_from_ulongest (address_type
, result
);
1227 result
= value_less (first
, second
);
1228 result_val
= value_from_ulongest (address_type
, result
);
1231 /* A > B is B < A. */
1232 result
= value_less (second
, first
);
1233 result_val
= value_from_ulongest (address_type
, result
);
1236 result
= ! value_equal (first
, second
);
1237 result_val
= value_from_ulongest (address_type
, result
);
1240 internal_error (__FILE__
, __LINE__
,
1241 _("Can't be reached."));
1246 case DW_OP_call_frame_cfa
:
1247 result
= (ctx
->funcs
->get_frame_cfa
) (ctx
->baton
);
1248 result_val
= value_from_ulongest (address_type
, result
);
1249 in_stack_memory
= 1;
1252 case DW_OP_GNU_push_tls_address
:
1253 case DW_OP_form_tls_address
:
1254 /* Variable is at a constant offset in the thread-local
1255 storage block into the objfile for the current thread and
1256 the dynamic linker module containing this expression. Here
1257 we return returns the offset from that base. The top of the
1258 stack has the offset from the beginning of the thread
1259 control block at which the variable is located. Nothing
1260 should follow this operator, so the top of stack would be
1262 result
= value_as_long (dwarf_expr_fetch (ctx
, 0));
1263 dwarf_expr_pop (ctx
);
1264 result
= (ctx
->funcs
->get_tls_address
) (ctx
->baton
, result
);
1265 result_val
= value_from_ulongest (address_type
, result
);
1269 offset
= extract_signed_integer (op_ptr
, 2, byte_order
);
1278 offset
= extract_signed_integer (op_ptr
, 2, byte_order
);
1280 val
= dwarf_expr_fetch (ctx
, 0);
1281 dwarf_require_integral (value_type (val
));
1282 if (value_as_long (val
) != 0)
1284 dwarf_expr_pop (ctx
);
1295 /* Record the piece. */
1296 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, &size
);
1297 add_piece (ctx
, 8 * size
, 0);
1299 /* Pop off the address/regnum, and reset the location
1301 if (ctx
->location
!= DWARF_VALUE_LITERAL
1302 && ctx
->location
!= DWARF_VALUE_OPTIMIZED_OUT
)
1303 dwarf_expr_pop (ctx
);
1304 ctx
->location
= DWARF_VALUE_MEMORY
;
1308 case DW_OP_bit_piece
:
1310 uint64_t size
, offset
;
1312 /* Record the piece. */
1313 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, &size
);
1314 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, &offset
);
1315 add_piece (ctx
, size
, offset
);
1317 /* Pop off the address/regnum, and reset the location
1319 if (ctx
->location
!= DWARF_VALUE_LITERAL
1320 && ctx
->location
!= DWARF_VALUE_OPTIMIZED_OUT
)
1321 dwarf_expr_pop (ctx
);
1322 ctx
->location
= DWARF_VALUE_MEMORY
;
1326 case DW_OP_GNU_uninit
:
1327 if (op_ptr
!= op_end
)
1328 error (_("DWARF-2 expression error: DW_OP_GNU_uninit must always "
1329 "be the very last op."));
1331 ctx
->initialized
= 0;
1338 offset
.cu_off
= extract_unsigned_integer (op_ptr
, 2, byte_order
);
1340 ctx
->funcs
->dwarf_call (ctx
, offset
);
1348 offset
.cu_off
= extract_unsigned_integer (op_ptr
, 4, byte_order
);
1350 ctx
->funcs
->dwarf_call (ctx
, offset
);
1354 case DW_OP_GNU_entry_value
:
1357 CORE_ADDR deref_size
;
1358 union call_site_parameter_u kind_u
;
1360 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, &len
);
1361 if (op_ptr
+ len
> op_end
)
1362 error (_("DW_OP_GNU_entry_value: too few bytes available."));
1364 kind_u
.dwarf_reg
= dwarf_block_to_dwarf_reg (op_ptr
, op_ptr
+ len
);
1365 if (kind_u
.dwarf_reg
!= -1)
1368 ctx
->funcs
->push_dwarf_reg_entry_value (ctx
,
1369 CALL_SITE_PARAMETER_DWARF_REG
,
1371 -1 /* deref_size */);
1375 kind_u
.dwarf_reg
= dwarf_block_to_dwarf_reg_deref (op_ptr
,
1378 if (kind_u
.dwarf_reg
!= -1)
1380 if (deref_size
== -1)
1381 deref_size
= ctx
->addr_size
;
1383 ctx
->funcs
->push_dwarf_reg_entry_value (ctx
,
1384 CALL_SITE_PARAMETER_DWARF_REG
,
1385 kind_u
, deref_size
);
1389 error (_("DWARF-2 expression error: DW_OP_GNU_entry_value is "
1390 "supported only for single DW_OP_reg* "
1391 "or for DW_OP_breg*(0)+DW_OP_deref*"));
1394 case DW_OP_GNU_parameter_ref
:
1396 union call_site_parameter_u kind_u
;
1398 kind_u
.param_offset
.cu_off
= extract_unsigned_integer (op_ptr
, 4,
1401 ctx
->funcs
->push_dwarf_reg_entry_value (ctx
,
1402 CALL_SITE_PARAMETER_PARAM_OFFSET
,
1404 -1 /* deref_size */);
1408 case DW_OP_GNU_const_type
:
1412 const gdb_byte
*data
;
1415 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, &uoffset
);
1416 type_die
.cu_off
= uoffset
;
1421 type
= dwarf_get_base_type (ctx
, type_die
, n
);
1422 result_val
= value_from_contents (type
, data
);
1426 case DW_OP_GNU_regval_type
:
1431 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, ®
);
1432 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, &uoffset
);
1433 type_die
.cu_off
= uoffset
;
1435 type
= dwarf_get_base_type (ctx
, type_die
, 0);
1436 result_val
= ctx
->funcs
->get_reg_value (ctx
->baton
, type
, reg
);
1440 case DW_OP_GNU_convert
:
1441 case DW_OP_GNU_reinterpret
:
1446 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, &uoffset
);
1447 type_die
.cu_off
= uoffset
;
1449 if (type_die
.cu_off
== 0)
1450 type
= address_type
;
1452 type
= dwarf_get_base_type (ctx
, type_die
, 0);
1454 result_val
= dwarf_expr_fetch (ctx
, 0);
1455 dwarf_expr_pop (ctx
);
1457 if (op
== DW_OP_GNU_convert
)
1458 result_val
= value_cast (type
, result_val
);
1459 else if (type
== value_type (result_val
))
1463 else if (TYPE_LENGTH (type
)
1464 != TYPE_LENGTH (value_type (result_val
)))
1465 error (_("DW_OP_GNU_reinterpret has wrong size"));
1468 = value_from_contents (type
,
1469 value_contents_all (result_val
));
1473 case DW_OP_push_object_address
:
1474 /* Return the address of the object we are currently observing. */
1475 result
= (ctx
->funcs
->get_object_address
) (ctx
->baton
);
1476 result_val
= value_from_ulongest (address_type
, result
);
1480 error (_("Unhandled dwarf expression opcode 0x%x"), op
);
1483 /* Most things push a result value. */
1484 gdb_assert (result_val
!= NULL
);
1485 dwarf_expr_push (ctx
, result_val
, in_stack_memory
);
1490 /* To simplify our main caller, if the result is an implicit
1491 pointer, then make a pieced value. This is ok because we can't
1492 have implicit pointers in contexts where pieces are invalid. */
1493 if (ctx
->location
== DWARF_VALUE_IMPLICIT_POINTER
)
1494 add_piece (ctx
, 8 * ctx
->addr_size
, 0);
1497 ctx
->recursion_depth
--;
1498 gdb_assert (ctx
->recursion_depth
>= 0);
1501 /* Stub dwarf_expr_context_funcs.get_frame_base implementation. */
1504 ctx_no_get_frame_base (void *baton
, const gdb_byte
**start
, size_t *length
)
1506 error (_("%s is invalid in this context"), "DW_OP_fbreg");
1509 /* Stub dwarf_expr_context_funcs.get_frame_cfa implementation. */
1512 ctx_no_get_frame_cfa (void *baton
)
1514 error (_("%s is invalid in this context"), "DW_OP_call_frame_cfa");
1517 /* Stub dwarf_expr_context_funcs.get_frame_pc implementation. */
1520 ctx_no_get_frame_pc (void *baton
)
1522 error (_("%s is invalid in this context"), "DW_OP_GNU_implicit_pointer");
1525 /* Stub dwarf_expr_context_funcs.get_tls_address implementation. */
1528 ctx_no_get_tls_address (void *baton
, CORE_ADDR offset
)
1530 error (_("%s is invalid in this context"), "DW_OP_form_tls_address");
1533 /* Stub dwarf_expr_context_funcs.dwarf_call implementation. */
1536 ctx_no_dwarf_call (struct dwarf_expr_context
*ctx
, cu_offset die_offset
)
1538 error (_("%s is invalid in this context"), "DW_OP_call*");
1541 /* Stub dwarf_expr_context_funcs.get_base_type implementation. */
1544 ctx_no_get_base_type (struct dwarf_expr_context
*ctx
, cu_offset die
)
1546 error (_("Support for typed DWARF is not supported in this context"));
1549 /* Stub dwarf_expr_context_funcs.push_dwarf_block_entry_value
1553 ctx_no_push_dwarf_reg_entry_value (struct dwarf_expr_context
*ctx
,
1554 enum call_site_parameter_kind kind
,
1555 union call_site_parameter_u kind_u
,
1558 internal_error (__FILE__
, __LINE__
,
1559 _("Support for DW_OP_GNU_entry_value is unimplemented"));
1562 /* Stub dwarf_expr_context_funcs.get_addr_index implementation. */
1565 ctx_no_get_addr_index (void *baton
, unsigned int index
)
1567 error (_("%s is invalid in this context"), "DW_OP_GNU_addr_index");
1570 /* Provide a prototype to silence -Wmissing-prototypes. */
1571 extern initialize_file_ftype _initialize_dwarf2expr
;
1574 _initialize_dwarf2expr (void)
1577 = gdbarch_data_register_post_init (dwarf_gdbarch_types_init
);