1 /* DWARF 2 Expression Evaluator.
3 Copyright (C) 2001, 2002, 2003, 2005, 2007, 2008, 2009, 2010
4 Free Software Foundation, Inc.
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 /* Create a new context for the expression evaluator. */
39 struct dwarf_expr_context
*
40 new_dwarf_expr_context (void)
42 struct dwarf_expr_context
*retval
;
44 retval
= xcalloc (1, sizeof (struct dwarf_expr_context
));
45 retval
->stack_len
= 0;
46 retval
->stack_allocated
= 10;
47 retval
->stack
= xmalloc (retval
->stack_allocated
48 * sizeof (struct dwarf_stack_value
));
49 retval
->num_pieces
= 0;
51 retval
->max_recursion_depth
= 0x100;
55 /* Release the memory allocated to CTX. */
58 free_dwarf_expr_context (struct dwarf_expr_context
*ctx
)
65 /* Helper for make_cleanup_free_dwarf_expr_context. */
68 free_dwarf_expr_context_cleanup (void *arg
)
70 free_dwarf_expr_context (arg
);
73 /* Return a cleanup that calls free_dwarf_expr_context. */
76 make_cleanup_free_dwarf_expr_context (struct dwarf_expr_context
*ctx
)
78 return make_cleanup (free_dwarf_expr_context_cleanup
, ctx
);
81 /* Expand the memory allocated to CTX's stack to contain at least
82 NEED more elements than are currently used. */
85 dwarf_expr_grow_stack (struct dwarf_expr_context
*ctx
, size_t need
)
87 if (ctx
->stack_len
+ need
> ctx
->stack_allocated
)
89 size_t newlen
= ctx
->stack_len
+ need
+ 10;
91 ctx
->stack
= xrealloc (ctx
->stack
,
92 newlen
* sizeof (struct dwarf_stack_value
));
93 ctx
->stack_allocated
= newlen
;
97 /* Push VALUE onto CTX's stack. */
100 dwarf_expr_push (struct dwarf_expr_context
*ctx
, ULONGEST value
,
103 struct dwarf_stack_value
*v
;
105 /* We keep all stack elements within the range defined by the
106 DWARF address size. */
107 if (ctx
->addr_size
< sizeof (ULONGEST
))
108 value
&= ((ULONGEST
) 1 << (ctx
->addr_size
* HOST_CHAR_BIT
)) - 1;
110 dwarf_expr_grow_stack (ctx
, 1);
111 v
= &ctx
->stack
[ctx
->stack_len
++];
113 v
->in_stack_memory
= in_stack_memory
;
116 /* Pop the top item off of CTX's stack. */
119 dwarf_expr_pop (struct dwarf_expr_context
*ctx
)
121 if (ctx
->stack_len
<= 0)
122 error (_("dwarf expression stack underflow"));
126 /* Retrieve the N'th item on CTX's stack. */
129 dwarf_expr_fetch (struct dwarf_expr_context
*ctx
, int n
)
131 if (ctx
->stack_len
<= n
)
132 error (_("Asked for position %d of stack, stack only has %d elements on it."),
134 return ctx
->stack
[ctx
->stack_len
- (1 + n
)].value
;
138 /* Retrieve the N'th item on CTX's stack, converted to an address. */
141 dwarf_expr_fetch_address (struct dwarf_expr_context
*ctx
, int n
)
143 ULONGEST result
= dwarf_expr_fetch (ctx
, n
);
145 /* For most architectures, calling extract_unsigned_integer() alone
146 is sufficient for extracting an address. However, some
147 architectures (e.g. MIPS) use signed addresses and using
148 extract_unsigned_integer() will not produce a correct
149 result. Make sure we invoke gdbarch_integer_to_address()
150 for those architectures which require it. */
151 if (gdbarch_integer_to_address_p (ctx
->gdbarch
))
153 enum bfd_endian byte_order
= gdbarch_byte_order (ctx
->gdbarch
);
154 gdb_byte
*buf
= alloca (ctx
->addr_size
);
155 struct type
*int_type
;
157 switch (ctx
->addr_size
)
160 int_type
= builtin_type (ctx
->gdbarch
)->builtin_uint16
;
163 int_type
= builtin_type (ctx
->gdbarch
)->builtin_uint32
;
166 int_type
= builtin_type (ctx
->gdbarch
)->builtin_uint64
;
169 internal_error (__FILE__
, __LINE__
,
170 _("Unsupported address size.\n"));
173 store_unsigned_integer (buf
, ctx
->addr_size
, byte_order
, result
);
174 return gdbarch_integer_to_address (ctx
->gdbarch
, int_type
, buf
);
177 return (CORE_ADDR
) result
;
180 /* Retrieve the in_stack_memory flag of the N'th item on CTX's stack. */
183 dwarf_expr_fetch_in_stack_memory (struct dwarf_expr_context
*ctx
, int n
)
185 if (ctx
->stack_len
<= n
)
186 error (_("Asked for position %d of stack, stack only has %d elements on it."),
188 return ctx
->stack
[ctx
->stack_len
- (1 + n
)].in_stack_memory
;
192 /* Return true if the expression stack is empty. */
195 dwarf_expr_stack_empty_p (struct dwarf_expr_context
*ctx
)
197 return ctx
->stack_len
== 0;
200 /* Add a new piece to CTX's piece list. */
202 add_piece (struct dwarf_expr_context
*ctx
, ULONGEST size
, ULONGEST offset
)
204 struct dwarf_expr_piece
*p
;
208 ctx
->pieces
= xrealloc (ctx
->pieces
,
210 * sizeof (struct dwarf_expr_piece
)));
212 p
= &ctx
->pieces
[ctx
->num_pieces
- 1];
213 p
->location
= ctx
->location
;
217 if (p
->location
== DWARF_VALUE_LITERAL
)
219 p
->v
.literal
.data
= ctx
->data
;
220 p
->v
.literal
.length
= ctx
->len
;
222 else if (dwarf_expr_stack_empty_p (ctx
))
224 p
->location
= DWARF_VALUE_OPTIMIZED_OUT
;
225 /* Also reset the context's location, for our callers. This is
226 a somewhat strange approach, but this lets us avoid setting
227 the location to DWARF_VALUE_MEMORY in all the individual
228 cases in the evaluator. */
229 ctx
->location
= DWARF_VALUE_OPTIMIZED_OUT
;
231 else if (p
->location
== DWARF_VALUE_MEMORY
)
233 p
->v
.mem
.addr
= dwarf_expr_fetch_address (ctx
, 0);
234 p
->v
.mem
.in_stack_memory
= dwarf_expr_fetch_in_stack_memory (ctx
, 0);
236 else if (p
->location
== DWARF_VALUE_IMPLICIT_POINTER
)
238 p
->v
.ptr
.die
= ctx
->len
;
239 p
->v
.ptr
.offset
= (LONGEST
) dwarf_expr_fetch (ctx
, 0);
243 p
->v
.value
= dwarf_expr_fetch (ctx
, 0);
247 /* Evaluate the expression at ADDR (LEN bytes long) using the context
251 dwarf_expr_eval (struct dwarf_expr_context
*ctx
, const gdb_byte
*addr
,
254 int old_recursion_depth
= ctx
->recursion_depth
;
256 execute_stack_op (ctx
, addr
, addr
+ len
);
258 /* CTX RECURSION_DEPTH becomes invalid if an exception was thrown here. */
260 gdb_assert (ctx
->recursion_depth
== old_recursion_depth
);
263 /* Decode the unsigned LEB128 constant at BUF into the variable pointed to
264 by R, and return the new value of BUF. Verify that it doesn't extend
268 read_uleb128 (const gdb_byte
*buf
, const gdb_byte
*buf_end
, ULONGEST
* r
)
277 error (_("read_uleb128: Corrupted DWARF expression."));
280 result
|= (byte
& 0x7f) << shift
;
281 if ((byte
& 0x80) == 0)
289 /* Decode the signed LEB128 constant at BUF into the variable pointed to
290 by R, and return the new value of BUF. Verify that it doesn't extend
294 read_sleb128 (const gdb_byte
*buf
, const gdb_byte
*buf_end
, LONGEST
* r
)
303 error (_("read_sleb128: Corrupted DWARF expression."));
306 result
|= (byte
& 0x7f) << shift
;
308 if ((byte
& 0x80) == 0)
311 if (shift
< (sizeof (*r
) * 8) && (byte
& 0x40) != 0)
312 result
|= -(1 << shift
);
319 /* Check that the current operator is either at the end of an
320 expression, or that it is followed by a composition operator. */
323 dwarf_expr_require_composition (const gdb_byte
*op_ptr
, const gdb_byte
*op_end
,
326 /* It seems like DW_OP_GNU_uninit should be handled here. However,
327 it doesn't seem to make sense for DW_OP_*_value, and it was not
328 checked at the other place that this function is called. */
329 if (op_ptr
!= op_end
&& *op_ptr
!= DW_OP_piece
&& *op_ptr
!= DW_OP_bit_piece
)
330 error (_("DWARF-2 expression error: `%s' operations must be "
331 "used either alone or in conjuction with DW_OP_piece "
332 "or DW_OP_bit_piece."),
336 /* The engine for the expression evaluator. Using the context in CTX,
337 evaluate the expression between OP_PTR and OP_END. */
340 execute_stack_op (struct dwarf_expr_context
*ctx
,
341 const gdb_byte
*op_ptr
, const gdb_byte
*op_end
)
343 #define sign_ext(x) ((LONGEST) (((x) ^ sign_bit) - sign_bit))
344 ULONGEST sign_bit
= (ctx
->addr_size
>= sizeof (ULONGEST
) ? 0
345 : ((ULONGEST
) 1) << (ctx
->addr_size
* 8 - 1));
346 enum bfd_endian byte_order
= gdbarch_byte_order (ctx
->gdbarch
);
348 ctx
->location
= DWARF_VALUE_MEMORY
;
349 ctx
->initialized
= 1; /* Default is initialized. */
351 if (ctx
->recursion_depth
> ctx
->max_recursion_depth
)
352 error (_("DWARF-2 expression error: Loop detected (%d)."),
353 ctx
->recursion_depth
);
354 ctx
->recursion_depth
++;
356 while (op_ptr
< op_end
)
358 enum dwarf_location_atom op
= *op_ptr
++;
360 /* Assume the value is not in stack memory.
361 Code that knows otherwise sets this to 1.
362 Some arithmetic on stack addresses can probably be assumed to still
363 be a stack address, but we skip this complication for now.
364 This is just an optimization, so it's always ok to punt
365 and leave this as 0. */
366 int in_stack_memory
= 0;
367 ULONGEST uoffset
, reg
;
404 result
= op
- DW_OP_lit0
;
408 result
= extract_unsigned_integer (op_ptr
,
409 ctx
->addr_size
, byte_order
);
410 op_ptr
+= ctx
->addr_size
;
411 /* Some versions of GCC emit DW_OP_addr before
412 DW_OP_GNU_push_tls_address. In this case the value is an
413 index, not an address. We don't support things like
414 branching between the address and the TLS op. */
415 if (op_ptr
>= op_end
|| *op_ptr
!= DW_OP_GNU_push_tls_address
)
416 result
+= ctx
->offset
;
420 result
= extract_unsigned_integer (op_ptr
, 1, byte_order
);
424 result
= extract_signed_integer (op_ptr
, 1, byte_order
);
428 result
= extract_unsigned_integer (op_ptr
, 2, byte_order
);
432 result
= extract_signed_integer (op_ptr
, 2, byte_order
);
436 result
= extract_unsigned_integer (op_ptr
, 4, byte_order
);
440 result
= extract_signed_integer (op_ptr
, 4, byte_order
);
444 result
= extract_unsigned_integer (op_ptr
, 8, byte_order
);
448 result
= extract_signed_integer (op_ptr
, 8, byte_order
);
452 op_ptr
= read_uleb128 (op_ptr
, op_end
, &uoffset
);
456 op_ptr
= read_sleb128 (op_ptr
, op_end
, &offset
);
460 /* The DW_OP_reg operations are required to occur alone in
461 location expressions. */
495 && *op_ptr
!= DW_OP_piece
496 && *op_ptr
!= DW_OP_bit_piece
497 && *op_ptr
!= DW_OP_GNU_uninit
)
498 error (_("DWARF-2 expression error: DW_OP_reg operations must be "
499 "used either alone or in conjuction with DW_OP_piece "
500 "or DW_OP_bit_piece."));
502 result
= op
- DW_OP_reg0
;
503 ctx
->location
= DWARF_VALUE_REGISTER
;
507 op_ptr
= read_uleb128 (op_ptr
, op_end
, ®
);
508 dwarf_expr_require_composition (op_ptr
, op_end
, "DW_OP_regx");
511 ctx
->location
= DWARF_VALUE_REGISTER
;
514 case DW_OP_implicit_value
:
518 op_ptr
= read_uleb128 (op_ptr
, op_end
, &len
);
519 if (op_ptr
+ len
> op_end
)
520 error (_("DW_OP_implicit_value: too few bytes available."));
523 ctx
->location
= DWARF_VALUE_LITERAL
;
525 dwarf_expr_require_composition (op_ptr
, op_end
,
526 "DW_OP_implicit_value");
530 case DW_OP_stack_value
:
531 ctx
->location
= DWARF_VALUE_STACK
;
532 dwarf_expr_require_composition (op_ptr
, op_end
, "DW_OP_stack_value");
535 case DW_OP_GNU_implicit_pointer
:
540 /* The referred-to DIE. */
541 ctx
->len
= extract_unsigned_integer (op_ptr
, ctx
->addr_size
,
543 op_ptr
+= ctx
->addr_size
;
545 /* The byte offset into the data. */
546 op_ptr
= read_sleb128 (op_ptr
, op_end
, &len
);
547 result
= (ULONGEST
) len
;
549 ctx
->location
= DWARF_VALUE_IMPLICIT_POINTER
;
550 dwarf_expr_require_composition (op_ptr
, op_end
,
551 "DW_OP_GNU_implicit_pointer");
588 op_ptr
= read_sleb128 (op_ptr
, op_end
, &offset
);
589 result
= (ctx
->read_reg
) (ctx
->baton
, op
- DW_OP_breg0
);
595 op_ptr
= read_uleb128 (op_ptr
, op_end
, ®
);
596 op_ptr
= read_sleb128 (op_ptr
, op_end
, &offset
);
597 result
= (ctx
->read_reg
) (ctx
->baton
, reg
);
603 const gdb_byte
*datastart
;
605 unsigned int before_stack_len
;
607 op_ptr
= read_sleb128 (op_ptr
, op_end
, &offset
);
608 /* Rather than create a whole new context, we simply
609 record the stack length before execution, then reset it
610 afterwards, effectively erasing whatever the recursive
612 before_stack_len
= ctx
->stack_len
;
613 /* FIXME: cagney/2003-03-26: This code should be using
614 get_frame_base_address(), and then implement a dwarf2
615 specific this_base method. */
616 (ctx
->get_frame_base
) (ctx
->baton
, &datastart
, &datalen
);
617 dwarf_expr_eval (ctx
, datastart
, datalen
);
618 if (ctx
->location
== DWARF_VALUE_MEMORY
)
619 result
= dwarf_expr_fetch_address (ctx
, 0);
620 else if (ctx
->location
== DWARF_VALUE_REGISTER
)
621 result
= (ctx
->read_reg
) (ctx
->baton
, dwarf_expr_fetch (ctx
, 0));
623 error (_("Not implemented: computing frame base using explicit value operator"));
624 result
= result
+ offset
;
626 ctx
->stack_len
= before_stack_len
;
627 ctx
->location
= DWARF_VALUE_MEMORY
;
632 result
= dwarf_expr_fetch (ctx
, 0);
633 in_stack_memory
= dwarf_expr_fetch_in_stack_memory (ctx
, 0);
637 dwarf_expr_pop (ctx
);
642 result
= dwarf_expr_fetch (ctx
, offset
);
643 in_stack_memory
= dwarf_expr_fetch_in_stack_memory (ctx
, offset
);
648 struct dwarf_stack_value t1
, t2
;
650 if (ctx
->stack_len
< 2)
651 error (_("Not enough elements for DW_OP_swap. Need 2, have %d."),
653 t1
= ctx
->stack
[ctx
->stack_len
- 1];
654 t2
= ctx
->stack
[ctx
->stack_len
- 2];
655 ctx
->stack
[ctx
->stack_len
- 1] = t2
;
656 ctx
->stack
[ctx
->stack_len
- 2] = t1
;
661 result
= dwarf_expr_fetch (ctx
, 1);
662 in_stack_memory
= dwarf_expr_fetch_in_stack_memory (ctx
, 1);
667 struct dwarf_stack_value t1
, t2
, t3
;
669 if (ctx
->stack_len
< 3)
670 error (_("Not enough elements for DW_OP_rot. Need 3, have %d."),
672 t1
= ctx
->stack
[ctx
->stack_len
- 1];
673 t2
= ctx
->stack
[ctx
->stack_len
- 2];
674 t3
= ctx
->stack
[ctx
->stack_len
- 3];
675 ctx
->stack
[ctx
->stack_len
- 1] = t2
;
676 ctx
->stack
[ctx
->stack_len
- 2] = t3
;
677 ctx
->stack
[ctx
->stack_len
- 3] = t1
;
682 case DW_OP_deref_size
:
684 int addr_size
= (op
== DW_OP_deref
? ctx
->addr_size
: *op_ptr
++);
685 gdb_byte
*buf
= alloca (addr_size
);
686 CORE_ADDR addr
= dwarf_expr_fetch_address (ctx
, 0);
687 dwarf_expr_pop (ctx
);
689 (ctx
->read_mem
) (ctx
->baton
, buf
, addr
, addr_size
);
690 result
= extract_unsigned_integer (buf
, addr_size
, byte_order
);
697 case DW_OP_plus_uconst
:
698 /* Unary operations. */
699 result
= dwarf_expr_fetch (ctx
, 0);
700 dwarf_expr_pop (ctx
);
705 if (sign_ext (result
) < 0)
714 case DW_OP_plus_uconst
:
715 op_ptr
= read_uleb128 (op_ptr
, op_end
, ®
);
739 /* Binary operations. */
740 ULONGEST first
, second
;
742 second
= dwarf_expr_fetch (ctx
, 0);
743 dwarf_expr_pop (ctx
);
745 first
= dwarf_expr_fetch (ctx
, 0);
746 dwarf_expr_pop (ctx
);
751 result
= first
& second
;
755 error (_("Division by zero"));
756 result
= sign_ext (first
) / sign_ext (second
);
759 result
= first
- second
;
763 error (_("Division by zero"));
764 result
= first
% second
;
767 result
= first
* second
;
770 result
= first
| second
;
773 result
= first
+ second
;
776 result
= first
<< second
;
779 result
= first
>> second
;
782 result
= sign_ext (first
) >> second
;
785 result
= first
^ second
;
788 result
= sign_ext (first
) <= sign_ext (second
);
791 result
= sign_ext (first
) >= sign_ext (second
);
794 result
= sign_ext (first
) == sign_ext (second
);
797 result
= sign_ext (first
) < sign_ext (second
);
800 result
= sign_ext (first
) > sign_ext (second
);
803 result
= sign_ext (first
) != sign_ext (second
);
806 internal_error (__FILE__
, __LINE__
,
807 _("Can't be reached."));
812 case DW_OP_call_frame_cfa
:
813 result
= (ctx
->get_frame_cfa
) (ctx
->baton
);
817 case DW_OP_GNU_push_tls_address
:
818 /* Variable is at a constant offset in the thread-local
819 storage block into the objfile for the current thread and
820 the dynamic linker module containing this expression. Here
821 we return returns the offset from that base. The top of the
822 stack has the offset from the beginning of the thread
823 control block at which the variable is located. Nothing
824 should follow this operator, so the top of stack would be
826 result
= dwarf_expr_fetch (ctx
, 0);
827 dwarf_expr_pop (ctx
);
828 result
= (ctx
->get_tls_address
) (ctx
->baton
, result
);
832 offset
= extract_signed_integer (op_ptr
, 2, byte_order
);
838 offset
= extract_signed_integer (op_ptr
, 2, byte_order
);
840 if (dwarf_expr_fetch (ctx
, 0) != 0)
842 dwarf_expr_pop (ctx
);
852 /* Record the piece. */
853 op_ptr
= read_uleb128 (op_ptr
, op_end
, &size
);
854 add_piece (ctx
, 8 * size
, 0);
856 /* Pop off the address/regnum, and reset the location
858 if (ctx
->location
!= DWARF_VALUE_LITERAL
859 && ctx
->location
!= DWARF_VALUE_OPTIMIZED_OUT
)
860 dwarf_expr_pop (ctx
);
861 ctx
->location
= DWARF_VALUE_MEMORY
;
865 case DW_OP_bit_piece
:
867 ULONGEST size
, offset
;
869 /* Record the piece. */
870 op_ptr
= read_uleb128 (op_ptr
, op_end
, &size
);
871 op_ptr
= read_uleb128 (op_ptr
, op_end
, &offset
);
872 add_piece (ctx
, size
, offset
);
874 /* Pop off the address/regnum, and reset the location
876 if (ctx
->location
!= DWARF_VALUE_LITERAL
877 && ctx
->location
!= DWARF_VALUE_OPTIMIZED_OUT
)
878 dwarf_expr_pop (ctx
);
879 ctx
->location
= DWARF_VALUE_MEMORY
;
883 case DW_OP_GNU_uninit
:
884 if (op_ptr
!= op_end
)
885 error (_("DWARF-2 expression error: DW_OP_GNU_uninit must always "
886 "be the very last op."));
888 ctx
->initialized
= 0;
892 result
= extract_unsigned_integer (op_ptr
, 2, byte_order
);
894 ctx
->dwarf_call (ctx
, result
);
898 result
= extract_unsigned_integer (op_ptr
, 4, byte_order
);
900 ctx
->dwarf_call (ctx
, result
);
904 error (_("Unhandled dwarf expression opcode 0x%x"), op
);
907 /* Most things push a result value. */
908 dwarf_expr_push (ctx
, result
, in_stack_memory
);
912 /* To simplify our main caller, if the result is an implicit
913 pointer, then make a pieced value. This is ok because we can't
914 have implicit pointers in contexts where pieces are invalid. */
915 if (ctx
->location
== DWARF_VALUE_IMPLICIT_POINTER
)
916 add_piece (ctx
, 8 * ctx
->addr_size
, 0);
918 ctx
->recursion_depth
--;
919 gdb_assert (ctx
->recursion_depth
>= 0);