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 /* Cookie for gdbarch data. */
33 static struct gdbarch_data
*dwarf_arch_cookie
;
35 /* This holds gdbarch-specific types used by the DWARF expression
36 evaluator. See comments in execute_stack_op. */
38 struct dwarf_gdbarch_types
40 struct type
*dw_types
[3];
43 /* Allocate and fill in dwarf_gdbarch_types for an arch. */
46 dwarf_gdbarch_types_init (struct gdbarch
*gdbarch
)
48 struct dwarf_gdbarch_types
*types
49 = GDBARCH_OBSTACK_ZALLOC (gdbarch
, struct dwarf_gdbarch_types
);
51 /* The types themselves are lazily initialized. */
56 /* Return the type used for DWARF operations where the type is
57 unspecified in the DWARF spec. Only certain sizes are
61 dwarf_expr_context::address_type () const
63 struct dwarf_gdbarch_types
*types
64 = (struct dwarf_gdbarch_types
*) gdbarch_data (this->gdbarch
,
68 if (this->addr_size
== 2)
70 else if (this->addr_size
== 4)
72 else if (this->addr_size
== 8)
75 error (_("Unsupported address size in DWARF expressions: %d bits"),
78 if (types
->dw_types
[ndx
] == NULL
)
80 = arch_integer_type (this->gdbarch
,
82 0, "<signed DWARF address type>");
84 return types
->dw_types
[ndx
];
87 /* Create a new context for the expression evaluator. */
89 dwarf_expr_context::dwarf_expr_context ()
98 max_recursion_depth (0x100),
99 location (DWARF_VALUE_MEMORY
),
106 this->stack
= XNEWVEC (struct dwarf_stack_value
, this->stack_allocated
);
109 /* Clean up a dwarf_expr_context. */
111 dwarf_expr_context::~dwarf_expr_context ()
114 xfree (this->pieces
);
117 /* Expand the memory allocated stack to contain at least
118 NEED more elements than are currently used. */
121 dwarf_expr_context::grow_stack (size_t need
)
123 if (this->stack_len
+ need
> this->stack_allocated
)
125 size_t newlen
= this->stack_len
+ need
+ 10;
127 this->stack
= XRESIZEVEC (struct dwarf_stack_value
, this->stack
, newlen
);
128 this->stack_allocated
= newlen
;
132 /* Push VALUE onto the stack. */
135 dwarf_expr_context::push (struct value
*value
, int in_stack_memory
)
137 struct dwarf_stack_value
*v
;
140 v
= &this->stack
[this->stack_len
++];
142 v
->in_stack_memory
= in_stack_memory
;
145 /* Push VALUE onto the stack. */
148 dwarf_expr_context::push_address (CORE_ADDR value
, int in_stack_memory
)
150 push (value_from_ulongest (address_type (), value
), in_stack_memory
);
153 /* Pop the top item off of the stack. */
156 dwarf_expr_context::pop ()
158 if (this->stack_len
<= 0)
159 error (_("dwarf expression stack underflow"));
163 /* Retrieve the N'th item on the stack. */
166 dwarf_expr_context::fetch (int n
)
168 if (this->stack_len
<= n
)
169 error (_("Asked for position %d of stack, "
170 "stack only has %d elements on it."),
172 return this->stack
[this->stack_len
- (1 + n
)].value
;
175 /* Require that TYPE be an integral type; throw an exception if not. */
178 dwarf_require_integral (struct type
*type
)
180 if (TYPE_CODE (type
) != TYPE_CODE_INT
181 && TYPE_CODE (type
) != TYPE_CODE_CHAR
182 && TYPE_CODE (type
) != TYPE_CODE_BOOL
)
183 error (_("integral type expected in DWARF expression"));
186 /* Return the unsigned form of TYPE. TYPE is necessarily an integral
190 get_unsigned_type (struct gdbarch
*gdbarch
, struct type
*type
)
192 switch (TYPE_LENGTH (type
))
195 return builtin_type (gdbarch
)->builtin_uint8
;
197 return builtin_type (gdbarch
)->builtin_uint16
;
199 return builtin_type (gdbarch
)->builtin_uint32
;
201 return builtin_type (gdbarch
)->builtin_uint64
;
203 error (_("no unsigned variant found for type, while evaluating "
204 "DWARF expression"));
208 /* Return the signed form of TYPE. TYPE is necessarily an integral
212 get_signed_type (struct gdbarch
*gdbarch
, struct type
*type
)
214 switch (TYPE_LENGTH (type
))
217 return builtin_type (gdbarch
)->builtin_int8
;
219 return builtin_type (gdbarch
)->builtin_int16
;
221 return builtin_type (gdbarch
)->builtin_int32
;
223 return builtin_type (gdbarch
)->builtin_int64
;
225 error (_("no signed variant found for type, while evaluating "
226 "DWARF expression"));
230 /* Retrieve the N'th item on the stack, converted to an address. */
233 dwarf_expr_context::fetch_address (int n
)
235 struct value
*result_val
= fetch (n
);
236 enum bfd_endian byte_order
= gdbarch_byte_order (this->gdbarch
);
239 dwarf_require_integral (value_type (result_val
));
240 result
= extract_unsigned_integer (value_contents (result_val
),
241 TYPE_LENGTH (value_type (result_val
)),
244 /* For most architectures, calling extract_unsigned_integer() alone
245 is sufficient for extracting an address. However, some
246 architectures (e.g. MIPS) use signed addresses and using
247 extract_unsigned_integer() will not produce a correct
248 result. Make sure we invoke gdbarch_integer_to_address()
249 for those architectures which require it. */
250 if (gdbarch_integer_to_address_p (this->gdbarch
))
252 gdb_byte
*buf
= (gdb_byte
*) alloca (this->addr_size
);
253 struct type
*int_type
= get_unsigned_type (this->gdbarch
,
254 value_type (result_val
));
256 store_unsigned_integer (buf
, this->addr_size
, byte_order
, result
);
257 return gdbarch_integer_to_address (this->gdbarch
, int_type
, buf
);
260 return (CORE_ADDR
) result
;
263 /* Retrieve the in_stack_memory flag of the N'th item on the stack. */
266 dwarf_expr_context::fetch_in_stack_memory (int n
)
268 if (this->stack_len
<= n
)
269 error (_("Asked for position %d of stack, "
270 "stack only has %d elements on it."),
272 return this->stack
[this->stack_len
- (1 + n
)].in_stack_memory
;
275 /* Return true if the expression stack is empty. */
278 dwarf_expr_context::stack_empty_p () const
280 return this->stack_len
== 0;
283 /* Add a new piece to the dwarf_expr_context's piece list. */
285 dwarf_expr_context::add_piece (ULONGEST size
, ULONGEST offset
)
287 struct dwarf_expr_piece
*p
;
292 = XRESIZEVEC (struct dwarf_expr_piece
, this->pieces
, this->num_pieces
);
294 p
= &this->pieces
[this->num_pieces
- 1];
295 p
->location
= this->location
;
299 if (p
->location
== DWARF_VALUE_LITERAL
)
301 p
->v
.literal
.data
= this->data
;
302 p
->v
.literal
.length
= this->len
;
304 else if (stack_empty_p ())
306 p
->location
= DWARF_VALUE_OPTIMIZED_OUT
;
307 /* Also reset the context's location, for our callers. This is
308 a somewhat strange approach, but this lets us avoid setting
309 the location to DWARF_VALUE_MEMORY in all the individual
310 cases in the evaluator. */
311 this->location
= DWARF_VALUE_OPTIMIZED_OUT
;
313 else if (p
->location
== DWARF_VALUE_MEMORY
)
315 p
->v
.mem
.addr
= fetch_address (0);
316 p
->v
.mem
.in_stack_memory
= fetch_in_stack_memory (0);
318 else if (p
->location
== DWARF_VALUE_IMPLICIT_POINTER
)
320 p
->v
.ptr
.die
.sect_off
= this->len
;
321 p
->v
.ptr
.offset
= value_as_long (fetch (0));
323 else if (p
->location
== DWARF_VALUE_REGISTER
)
324 p
->v
.regno
= value_as_long (fetch (0));
327 p
->v
.value
= fetch (0);
331 /* Evaluate the expression at ADDR (LEN bytes long). */
334 dwarf_expr_context::eval (const gdb_byte
*addr
, size_t len
)
336 int old_recursion_depth
= this->recursion_depth
;
338 execute_stack_op (addr
, addr
+ len
);
340 /* RECURSION_DEPTH becomes invalid if an exception was thrown here. */
342 gdb_assert (this->recursion_depth
== old_recursion_depth
);
345 /* Helper to read a uleb128 value or throw an error. */
348 safe_read_uleb128 (const gdb_byte
*buf
, const gdb_byte
*buf_end
,
351 buf
= gdb_read_uleb128 (buf
, buf_end
, r
);
353 error (_("DWARF expression error: ran off end of buffer reading uleb128 value"));
357 /* Helper to read a sleb128 value or throw an error. */
360 safe_read_sleb128 (const gdb_byte
*buf
, const gdb_byte
*buf_end
,
363 buf
= gdb_read_sleb128 (buf
, buf_end
, r
);
365 error (_("DWARF expression error: ran off end of buffer reading sleb128 value"));
370 safe_skip_leb128 (const gdb_byte
*buf
, const gdb_byte
*buf_end
)
372 buf
= gdb_skip_leb128 (buf
, buf_end
);
374 error (_("DWARF expression error: ran off end of buffer reading leb128 value"));
379 /* Check that the current operator is either at the end of an
380 expression, or that it is followed by a composition operator or by
381 DW_OP_GNU_uninit (which should terminate the expression). */
384 dwarf_expr_require_composition (const gdb_byte
*op_ptr
, const gdb_byte
*op_end
,
387 if (op_ptr
!= op_end
&& *op_ptr
!= DW_OP_piece
&& *op_ptr
!= DW_OP_bit_piece
388 && *op_ptr
!= DW_OP_GNU_uninit
)
389 error (_("DWARF-2 expression error: `%s' operations must be "
390 "used either alone or in conjunction with DW_OP_piece "
391 "or DW_OP_bit_piece."),
395 /* Return true iff the types T1 and T2 are "the same". This only does
396 checks that might reasonably be needed to compare DWARF base
400 base_types_equal_p (struct type
*t1
, struct type
*t2
)
402 if (TYPE_CODE (t1
) != TYPE_CODE (t2
))
404 if (TYPE_UNSIGNED (t1
) != TYPE_UNSIGNED (t2
))
406 return TYPE_LENGTH (t1
) == TYPE_LENGTH (t2
);
409 /* A convenience function to call get_base_type and return the result.
410 DIE is the DIE whose type we need. SIZE is non-zero if this
411 function should verify that the resulting type has the correct
415 dwarf_expr_context::get_base_type (cu_offset die
, int size
)
417 struct type
*result
= this->impl_get_base_type (die
);
419 error (_("Could not find type for DW_OP_GNU_const_type"));
420 if (size
!= 0 && TYPE_LENGTH (result
) != size
)
421 error (_("DW_OP_GNU_const_type has different sizes for type and data"));
425 /* If <BUF..BUF_END] contains DW_FORM_block* with single DW_OP_reg* return the
426 DWARF register number. Otherwise return -1. */
429 dwarf_block_to_dwarf_reg (const gdb_byte
*buf
, const gdb_byte
*buf_end
)
435 if (*buf
>= DW_OP_reg0
&& *buf
<= DW_OP_reg31
)
437 if (buf_end
- buf
!= 1)
439 return *buf
- DW_OP_reg0
;
442 if (*buf
== DW_OP_GNU_regval_type
)
445 buf
= gdb_read_uleb128 (buf
, buf_end
, &dwarf_reg
);
448 buf
= gdb_skip_leb128 (buf
, buf_end
);
452 else if (*buf
== DW_OP_regx
)
455 buf
= gdb_read_uleb128 (buf
, buf_end
, &dwarf_reg
);
461 if (buf
!= buf_end
|| (int) dwarf_reg
!= dwarf_reg
)
466 /* If <BUF..BUF_END] contains DW_FORM_block* with just DW_OP_breg*(0) and
467 DW_OP_deref* return the DWARF register number. Otherwise return -1.
468 DEREF_SIZE_RETURN contains -1 for DW_OP_deref; otherwise it contains the
469 size from DW_OP_deref_size. */
472 dwarf_block_to_dwarf_reg_deref (const gdb_byte
*buf
, const gdb_byte
*buf_end
,
473 CORE_ADDR
*deref_size_return
)
481 if (*buf
>= DW_OP_breg0
&& *buf
<= DW_OP_breg31
)
483 dwarf_reg
= *buf
- DW_OP_breg0
;
488 else if (*buf
== DW_OP_bregx
)
491 buf
= gdb_read_uleb128 (buf
, buf_end
, &dwarf_reg
);
494 if ((int) dwarf_reg
!= dwarf_reg
)
500 buf
= gdb_read_sleb128 (buf
, buf_end
, &offset
);
506 if (*buf
== DW_OP_deref
)
509 *deref_size_return
= -1;
511 else if (*buf
== DW_OP_deref_size
)
516 *deref_size_return
= *buf
++;
527 /* If <BUF..BUF_END] contains DW_FORM_block* with single DW_OP_fbreg(X) fill
528 in FB_OFFSET_RETURN with the X offset and return 1. Otherwise return 0. */
531 dwarf_block_to_fb_offset (const gdb_byte
*buf
, const gdb_byte
*buf_end
,
532 CORE_ADDR
*fb_offset_return
)
539 if (*buf
!= DW_OP_fbreg
)
543 buf
= gdb_read_sleb128 (buf
, buf_end
, &fb_offset
);
546 *fb_offset_return
= fb_offset
;
547 if (buf
!= buf_end
|| fb_offset
!= (LONGEST
) *fb_offset_return
)
553 /* If <BUF..BUF_END] contains DW_FORM_block* with single DW_OP_bregSP(X) fill
554 in SP_OFFSET_RETURN with the X offset and return 1. Otherwise return 0.
555 The matched SP register number depends on GDBARCH. */
558 dwarf_block_to_sp_offset (struct gdbarch
*gdbarch
, const gdb_byte
*buf
,
559 const gdb_byte
*buf_end
, CORE_ADDR
*sp_offset_return
)
566 if (*buf
>= DW_OP_breg0
&& *buf
<= DW_OP_breg31
)
568 dwarf_reg
= *buf
- DW_OP_breg0
;
573 if (*buf
!= DW_OP_bregx
)
576 buf
= gdb_read_uleb128 (buf
, buf_end
, &dwarf_reg
);
581 if (dwarf_reg_to_regnum (gdbarch
, dwarf_reg
)
582 != gdbarch_sp_regnum (gdbarch
))
585 buf
= gdb_read_sleb128 (buf
, buf_end
, &sp_offset
);
588 *sp_offset_return
= sp_offset
;
589 if (buf
!= buf_end
|| sp_offset
!= (LONGEST
) *sp_offset_return
)
595 /* The engine for the expression evaluator. Using the context in this
596 object, evaluate the expression between OP_PTR and OP_END. */
599 dwarf_expr_context::execute_stack_op (const gdb_byte
*op_ptr
,
600 const gdb_byte
*op_end
)
602 enum bfd_endian byte_order
= gdbarch_byte_order (this->gdbarch
);
603 /* Old-style "untyped" DWARF values need special treatment in a
604 couple of places, specifically DW_OP_mod and DW_OP_shr. We need
605 a special type for these values so we can distinguish them from
606 values that have an explicit type, because explicitly-typed
607 values do not need special treatment. This special type must be
608 different (in the `==' sense) from any base type coming from the
610 struct type
*address_type
= this->address_type ();
612 this->location
= DWARF_VALUE_MEMORY
;
613 this->initialized
= 1; /* Default is initialized. */
615 if (this->recursion_depth
> this->max_recursion_depth
)
616 error (_("DWARF-2 expression error: Loop detected (%d)."),
617 this->recursion_depth
);
618 this->recursion_depth
++;
620 while (op_ptr
< op_end
)
622 enum dwarf_location_atom op
= (enum dwarf_location_atom
) *op_ptr
++;
624 /* Assume the value is not in stack memory.
625 Code that knows otherwise sets this to 1.
626 Some arithmetic on stack addresses can probably be assumed to still
627 be a stack address, but we skip this complication for now.
628 This is just an optimization, so it's always ok to punt
629 and leave this as 0. */
630 int in_stack_memory
= 0;
631 uint64_t uoffset
, reg
;
633 struct value
*result_val
= NULL
;
635 /* The DWARF expression might have a bug causing an infinite
636 loop. In that case, quitting is the only way out. */
673 result
= op
- DW_OP_lit0
;
674 result_val
= value_from_ulongest (address_type
, result
);
678 result
= extract_unsigned_integer (op_ptr
,
679 this->addr_size
, byte_order
);
680 op_ptr
+= this->addr_size
;
681 /* Some versions of GCC emit DW_OP_addr before
682 DW_OP_GNU_push_tls_address. In this case the value is an
683 index, not an address. We don't support things like
684 branching between the address and the TLS op. */
685 if (op_ptr
>= op_end
|| *op_ptr
!= DW_OP_GNU_push_tls_address
)
686 result
+= this->offset
;
687 result_val
= value_from_ulongest (address_type
, result
);
690 case DW_OP_GNU_addr_index
:
691 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, &uoffset
);
692 result
= this->get_addr_index (uoffset
);
693 result
+= this->offset
;
694 result_val
= value_from_ulongest (address_type
, result
);
696 case DW_OP_GNU_const_index
:
697 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, &uoffset
);
698 result
= this->get_addr_index (uoffset
);
699 result_val
= value_from_ulongest (address_type
, result
);
703 result
= extract_unsigned_integer (op_ptr
, 1, byte_order
);
704 result_val
= value_from_ulongest (address_type
, result
);
708 result
= extract_signed_integer (op_ptr
, 1, byte_order
);
709 result_val
= value_from_ulongest (address_type
, result
);
713 result
= extract_unsigned_integer (op_ptr
, 2, byte_order
);
714 result_val
= value_from_ulongest (address_type
, result
);
718 result
= extract_signed_integer (op_ptr
, 2, byte_order
);
719 result_val
= value_from_ulongest (address_type
, result
);
723 result
= extract_unsigned_integer (op_ptr
, 4, byte_order
);
724 result_val
= value_from_ulongest (address_type
, result
);
728 result
= extract_signed_integer (op_ptr
, 4, byte_order
);
729 result_val
= value_from_ulongest (address_type
, result
);
733 result
= extract_unsigned_integer (op_ptr
, 8, byte_order
);
734 result_val
= value_from_ulongest (address_type
, result
);
738 result
= extract_signed_integer (op_ptr
, 8, byte_order
);
739 result_val
= value_from_ulongest (address_type
, result
);
743 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, &uoffset
);
745 result_val
= value_from_ulongest (address_type
, result
);
748 op_ptr
= safe_read_sleb128 (op_ptr
, op_end
, &offset
);
750 result_val
= value_from_ulongest (address_type
, result
);
753 /* The DW_OP_reg operations are required to occur alone in
754 location expressions. */
787 dwarf_expr_require_composition (op_ptr
, op_end
, "DW_OP_reg");
789 result
= op
- DW_OP_reg0
;
790 result_val
= value_from_ulongest (address_type
, result
);
791 this->location
= DWARF_VALUE_REGISTER
;
795 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, ®
);
796 dwarf_expr_require_composition (op_ptr
, op_end
, "DW_OP_regx");
799 result_val
= value_from_ulongest (address_type
, result
);
800 this->location
= DWARF_VALUE_REGISTER
;
803 case DW_OP_implicit_value
:
807 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, &len
);
808 if (op_ptr
+ len
> op_end
)
809 error (_("DW_OP_implicit_value: too few bytes available."));
812 this->location
= DWARF_VALUE_LITERAL
;
814 dwarf_expr_require_composition (op_ptr
, op_end
,
815 "DW_OP_implicit_value");
819 case DW_OP_stack_value
:
820 this->location
= DWARF_VALUE_STACK
;
821 dwarf_expr_require_composition (op_ptr
, op_end
, "DW_OP_stack_value");
824 case DW_OP_GNU_implicit_pointer
:
828 if (this->ref_addr_size
== -1)
829 error (_("DWARF-2 expression error: DW_OP_GNU_implicit_pointer "
830 "is not allowed in frame context"));
832 /* The referred-to DIE of sect_offset kind. */
833 this->len
= extract_unsigned_integer (op_ptr
, this->ref_addr_size
,
835 op_ptr
+= this->ref_addr_size
;
837 /* The byte offset into the data. */
838 op_ptr
= safe_read_sleb128 (op_ptr
, op_end
, &len
);
839 result
= (ULONGEST
) len
;
840 result_val
= value_from_ulongest (address_type
, result
);
842 this->location
= DWARF_VALUE_IMPLICIT_POINTER
;
843 dwarf_expr_require_composition (op_ptr
, op_end
,
844 "DW_OP_GNU_implicit_pointer");
881 op_ptr
= safe_read_sleb128 (op_ptr
, op_end
, &offset
);
882 result
= this->read_addr_from_reg (op
- DW_OP_breg0
);
884 result_val
= value_from_ulongest (address_type
, result
);
889 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, ®
);
890 op_ptr
= safe_read_sleb128 (op_ptr
, op_end
, &offset
);
891 result
= this->read_addr_from_reg (reg
);
893 result_val
= value_from_ulongest (address_type
, result
);
898 const gdb_byte
*datastart
;
900 unsigned int before_stack_len
;
902 op_ptr
= safe_read_sleb128 (op_ptr
, op_end
, &offset
);
903 /* Rather than create a whole new context, we simply
904 record the stack length before execution, then reset it
905 afterwards, effectively erasing whatever the recursive
907 before_stack_len
= this->stack_len
;
908 /* FIXME: cagney/2003-03-26: This code should be using
909 get_frame_base_address(), and then implement a dwarf2
910 specific this_base method. */
911 this->get_frame_base (&datastart
, &datalen
);
912 eval (datastart
, datalen
);
913 if (this->location
== DWARF_VALUE_MEMORY
)
914 result
= fetch_address (0);
915 else if (this->location
== DWARF_VALUE_REGISTER
)
916 result
= this->read_addr_from_reg (value_as_long (fetch (0)));
918 error (_("Not implemented: computing frame "
919 "base using explicit value operator"));
920 result
= result
+ offset
;
921 result_val
= value_from_ulongest (address_type
, result
);
923 this->stack_len
= before_stack_len
;
924 this->location
= DWARF_VALUE_MEMORY
;
929 result_val
= fetch (0);
930 in_stack_memory
= fetch_in_stack_memory (0);
939 result_val
= fetch (offset
);
940 in_stack_memory
= fetch_in_stack_memory (offset
);
945 struct dwarf_stack_value t1
, t2
;
947 if (this->stack_len
< 2)
948 error (_("Not enough elements for "
949 "DW_OP_swap. Need 2, have %d."),
951 t1
= this->stack
[this->stack_len
- 1];
952 t2
= this->stack
[this->stack_len
- 2];
953 this->stack
[this->stack_len
- 1] = t2
;
954 this->stack
[this->stack_len
- 2] = t1
;
959 result_val
= fetch (1);
960 in_stack_memory
= fetch_in_stack_memory (1);
965 struct dwarf_stack_value t1
, t2
, t3
;
967 if (this->stack_len
< 3)
968 error (_("Not enough elements for "
969 "DW_OP_rot. Need 3, have %d."),
971 t1
= this->stack
[this->stack_len
- 1];
972 t2
= this->stack
[this->stack_len
- 2];
973 t3
= this->stack
[this->stack_len
- 3];
974 this->stack
[this->stack_len
- 1] = t2
;
975 this->stack
[this->stack_len
- 2] = t3
;
976 this->stack
[this->stack_len
- 3] = t1
;
981 case DW_OP_deref_size
:
982 case DW_OP_GNU_deref_type
:
984 int addr_size
= (op
== DW_OP_deref
? this->addr_size
: *op_ptr
++);
985 gdb_byte
*buf
= (gdb_byte
*) alloca (addr_size
);
986 CORE_ADDR addr
= fetch_address (0);
991 if (op
== DW_OP_GNU_deref_type
)
995 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, &uoffset
);
996 type_die
.cu_off
= uoffset
;
997 type
= get_base_type (type_die
, 0);
1000 type
= address_type
;
1002 this->read_mem (buf
, addr
, addr_size
);
1004 /* If the size of the object read from memory is different
1005 from the type length, we need to zero-extend it. */
1006 if (TYPE_LENGTH (type
) != addr_size
)
1009 extract_unsigned_integer (buf
, addr_size
, byte_order
);
1011 buf
= (gdb_byte
*) alloca (TYPE_LENGTH (type
));
1012 store_unsigned_integer (buf
, TYPE_LENGTH (type
),
1013 byte_order
, result
);
1016 result_val
= value_from_contents_and_address (type
, buf
, addr
);
1023 case DW_OP_plus_uconst
:
1025 /* Unary operations. */
1026 result_val
= fetch (0);
1032 if (value_less (result_val
,
1033 value_zero (value_type (result_val
), not_lval
)))
1034 result_val
= value_neg (result_val
);
1037 result_val
= value_neg (result_val
);
1040 dwarf_require_integral (value_type (result_val
));
1041 result_val
= value_complement (result_val
);
1043 case DW_OP_plus_uconst
:
1044 dwarf_require_integral (value_type (result_val
));
1045 result
= value_as_long (result_val
);
1046 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, ®
);
1048 result_val
= value_from_ulongest (address_type
, result
);
1072 /* Binary operations. */
1073 struct value
*first
, *second
;
1081 if (! base_types_equal_p (value_type (first
), value_type (second
)))
1082 error (_("Incompatible types on DWARF stack"));
1087 dwarf_require_integral (value_type (first
));
1088 dwarf_require_integral (value_type (second
));
1089 result_val
= value_binop (first
, second
, BINOP_BITWISE_AND
);
1092 result_val
= value_binop (first
, second
, BINOP_DIV
);
1095 result_val
= value_binop (first
, second
, BINOP_SUB
);
1100 struct type
*orig_type
= value_type (first
);
1102 /* We have to special-case "old-style" untyped values
1103 -- these must have mod computed using unsigned
1105 if (orig_type
== address_type
)
1108 = get_unsigned_type (this->gdbarch
, orig_type
);
1111 first
= value_cast (utype
, first
);
1112 second
= value_cast (utype
, second
);
1114 /* Note that value_binop doesn't handle float or
1115 decimal float here. This seems unimportant. */
1116 result_val
= value_binop (first
, second
, BINOP_MOD
);
1118 result_val
= value_cast (orig_type
, result_val
);
1122 result_val
= value_binop (first
, second
, BINOP_MUL
);
1125 dwarf_require_integral (value_type (first
));
1126 dwarf_require_integral (value_type (second
));
1127 result_val
= value_binop (first
, second
, BINOP_BITWISE_IOR
);
1130 result_val
= value_binop (first
, second
, BINOP_ADD
);
1133 dwarf_require_integral (value_type (first
));
1134 dwarf_require_integral (value_type (second
));
1135 result_val
= value_binop (first
, second
, BINOP_LSH
);
1138 dwarf_require_integral (value_type (first
));
1139 dwarf_require_integral (value_type (second
));
1140 if (!TYPE_UNSIGNED (value_type (first
)))
1143 = get_unsigned_type (this->gdbarch
, value_type (first
));
1145 first
= value_cast (utype
, first
);
1148 result_val
= value_binop (first
, second
, BINOP_RSH
);
1149 /* Make sure we wind up with the same type we started
1151 if (value_type (result_val
) != value_type (second
))
1152 result_val
= value_cast (value_type (second
), result_val
);
1155 dwarf_require_integral (value_type (first
));
1156 dwarf_require_integral (value_type (second
));
1157 if (TYPE_UNSIGNED (value_type (first
)))
1160 = get_signed_type (this->gdbarch
, value_type (first
));
1162 first
= value_cast (stype
, first
);
1165 result_val
= value_binop (first
, second
, BINOP_RSH
);
1166 /* Make sure we wind up with the same type we started
1168 if (value_type (result_val
) != value_type (second
))
1169 result_val
= value_cast (value_type (second
), result_val
);
1172 dwarf_require_integral (value_type (first
));
1173 dwarf_require_integral (value_type (second
));
1174 result_val
= value_binop (first
, second
, BINOP_BITWISE_XOR
);
1177 /* A <= B is !(B < A). */
1178 result
= ! value_less (second
, first
);
1179 result_val
= value_from_ulongest (address_type
, result
);
1182 /* A >= B is !(A < B). */
1183 result
= ! value_less (first
, second
);
1184 result_val
= value_from_ulongest (address_type
, result
);
1187 result
= value_equal (first
, second
);
1188 result_val
= value_from_ulongest (address_type
, result
);
1191 result
= value_less (first
, second
);
1192 result_val
= value_from_ulongest (address_type
, result
);
1195 /* A > B is B < A. */
1196 result
= value_less (second
, first
);
1197 result_val
= value_from_ulongest (address_type
, result
);
1200 result
= ! value_equal (first
, second
);
1201 result_val
= value_from_ulongest (address_type
, result
);
1204 internal_error (__FILE__
, __LINE__
,
1205 _("Can't be reached."));
1210 case DW_OP_call_frame_cfa
:
1211 result
= this->get_frame_cfa ();
1212 result_val
= value_from_ulongest (address_type
, result
);
1213 in_stack_memory
= 1;
1216 case DW_OP_GNU_push_tls_address
:
1217 case DW_OP_form_tls_address
:
1218 /* Variable is at a constant offset in the thread-local
1219 storage block into the objfile for the current thread and
1220 the dynamic linker module containing this expression. Here
1221 we return returns the offset from that base. The top of the
1222 stack has the offset from the beginning of the thread
1223 control block at which the variable is located. Nothing
1224 should follow this operator, so the top of stack would be
1226 result
= value_as_long (fetch (0));
1228 result
= this->get_tls_address (result
);
1229 result_val
= value_from_ulongest (address_type
, result
);
1233 offset
= extract_signed_integer (op_ptr
, 2, byte_order
);
1242 offset
= extract_signed_integer (op_ptr
, 2, byte_order
);
1245 dwarf_require_integral (value_type (val
));
1246 if (value_as_long (val
) != 0)
1259 /* Record the piece. */
1260 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, &size
);
1261 add_piece (8 * size
, 0);
1263 /* Pop off the address/regnum, and reset the location
1265 if (this->location
!= DWARF_VALUE_LITERAL
1266 && this->location
!= DWARF_VALUE_OPTIMIZED_OUT
)
1268 this->location
= DWARF_VALUE_MEMORY
;
1272 case DW_OP_bit_piece
:
1274 uint64_t size
, offset
;
1276 /* Record the piece. */
1277 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, &size
);
1278 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, &offset
);
1279 add_piece (size
, offset
);
1281 /* Pop off the address/regnum, and reset the location
1283 if (this->location
!= DWARF_VALUE_LITERAL
1284 && this->location
!= DWARF_VALUE_OPTIMIZED_OUT
)
1286 this->location
= DWARF_VALUE_MEMORY
;
1290 case DW_OP_GNU_uninit
:
1291 if (op_ptr
!= op_end
)
1292 error (_("DWARF-2 expression error: DW_OP_GNU_uninit must always "
1293 "be the very last op."));
1295 this->initialized
= 0;
1302 offset
.cu_off
= extract_unsigned_integer (op_ptr
, 2, byte_order
);
1304 this->dwarf_call (offset
);
1312 offset
.cu_off
= extract_unsigned_integer (op_ptr
, 4, byte_order
);
1314 this->dwarf_call (offset
);
1318 case DW_OP_GNU_entry_value
:
1321 CORE_ADDR deref_size
;
1322 union call_site_parameter_u kind_u
;
1324 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, &len
);
1325 if (op_ptr
+ len
> op_end
)
1326 error (_("DW_OP_GNU_entry_value: too few bytes available."));
1328 kind_u
.dwarf_reg
= dwarf_block_to_dwarf_reg (op_ptr
, op_ptr
+ len
);
1329 if (kind_u
.dwarf_reg
!= -1)
1332 this->push_dwarf_reg_entry_value (CALL_SITE_PARAMETER_DWARF_REG
,
1334 -1 /* deref_size */);
1338 kind_u
.dwarf_reg
= dwarf_block_to_dwarf_reg_deref (op_ptr
,
1341 if (kind_u
.dwarf_reg
!= -1)
1343 if (deref_size
== -1)
1344 deref_size
= this->addr_size
;
1346 this->push_dwarf_reg_entry_value (CALL_SITE_PARAMETER_DWARF_REG
,
1347 kind_u
, deref_size
);
1351 error (_("DWARF-2 expression error: DW_OP_GNU_entry_value is "
1352 "supported only for single DW_OP_reg* "
1353 "or for DW_OP_breg*(0)+DW_OP_deref*"));
1356 case DW_OP_GNU_parameter_ref
:
1358 union call_site_parameter_u kind_u
;
1360 kind_u
.param_offset
.cu_off
= extract_unsigned_integer (op_ptr
, 4,
1363 this->push_dwarf_reg_entry_value (CALL_SITE_PARAMETER_PARAM_OFFSET
,
1365 -1 /* deref_size */);
1369 case DW_OP_GNU_const_type
:
1373 const gdb_byte
*data
;
1376 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, &uoffset
);
1377 type_die
.cu_off
= uoffset
;
1382 type
= get_base_type (type_die
, n
);
1383 result_val
= value_from_contents (type
, data
);
1387 case DW_OP_GNU_regval_type
:
1392 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, ®
);
1393 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, &uoffset
);
1394 type_die
.cu_off
= uoffset
;
1396 type
= get_base_type (type_die
, 0);
1397 result_val
= this->get_reg_value (type
, reg
);
1401 case DW_OP_GNU_convert
:
1402 case DW_OP_GNU_reinterpret
:
1407 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, &uoffset
);
1408 type_die
.cu_off
= uoffset
;
1410 if (type_die
.cu_off
== 0)
1411 type
= address_type
;
1413 type
= get_base_type (type_die
, 0);
1415 result_val
= fetch (0);
1418 if (op
== DW_OP_GNU_convert
)
1419 result_val
= value_cast (type
, result_val
);
1420 else if (type
== value_type (result_val
))
1424 else if (TYPE_LENGTH (type
)
1425 != TYPE_LENGTH (value_type (result_val
)))
1426 error (_("DW_OP_GNU_reinterpret has wrong size"));
1429 = value_from_contents (type
,
1430 value_contents_all (result_val
));
1434 case DW_OP_push_object_address
:
1435 /* Return the address of the object we are currently observing. */
1436 result
= this->get_object_address ();
1437 result_val
= value_from_ulongest (address_type
, result
);
1441 error (_("Unhandled dwarf expression opcode 0x%x"), op
);
1444 /* Most things push a result value. */
1445 gdb_assert (result_val
!= NULL
);
1446 push (result_val
, in_stack_memory
);
1451 /* To simplify our main caller, if the result is an implicit
1452 pointer, then make a pieced value. This is ok because we can't
1453 have implicit pointers in contexts where pieces are invalid. */
1454 if (this->location
== DWARF_VALUE_IMPLICIT_POINTER
)
1455 add_piece (8 * this->addr_size
, 0);
1458 this->recursion_depth
--;
1459 gdb_assert (this->recursion_depth
>= 0);
1462 /* Provide a prototype to silence -Wmissing-prototypes. */
1463 extern initialize_file_ftype _initialize_dwarf2expr
;
1466 _initialize_dwarf2expr (void)
1469 = gdbarch_data_register_post_init (dwarf_gdbarch_types_init
);