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
*);
36 static struct type
*unsigned_address_type (struct gdbarch
*, int);
38 /* Create a new context for the expression evaluator. */
40 struct dwarf_expr_context
*
41 new_dwarf_expr_context (void)
43 struct dwarf_expr_context
*retval
;
45 retval
= xcalloc (1, sizeof (struct dwarf_expr_context
));
46 retval
->stack_len
= 0;
47 retval
->stack_allocated
= 10;
48 retval
->stack
= xmalloc (retval
->stack_allocated
49 * sizeof (struct dwarf_stack_value
));
50 retval
->num_pieces
= 0;
52 retval
->max_recursion_depth
= 0x100;
56 /* Release the memory allocated to CTX. */
59 free_dwarf_expr_context (struct dwarf_expr_context
*ctx
)
66 /* Helper for make_cleanup_free_dwarf_expr_context. */
69 free_dwarf_expr_context_cleanup (void *arg
)
71 free_dwarf_expr_context (arg
);
74 /* Return a cleanup that calls free_dwarf_expr_context. */
77 make_cleanup_free_dwarf_expr_context (struct dwarf_expr_context
*ctx
)
79 return make_cleanup (free_dwarf_expr_context_cleanup
, ctx
);
82 /* Expand the memory allocated to CTX's stack to contain at least
83 NEED more elements than are currently used. */
86 dwarf_expr_grow_stack (struct dwarf_expr_context
*ctx
, size_t need
)
88 if (ctx
->stack_len
+ need
> ctx
->stack_allocated
)
90 size_t newlen
= ctx
->stack_len
+ need
+ 10;
92 ctx
->stack
= xrealloc (ctx
->stack
,
93 newlen
* sizeof (struct dwarf_stack_value
));
94 ctx
->stack_allocated
= newlen
;
98 /* Push VALUE onto CTX's stack. */
101 dwarf_expr_push (struct dwarf_expr_context
*ctx
, CORE_ADDR value
,
104 struct dwarf_stack_value
*v
;
106 dwarf_expr_grow_stack (ctx
, 1);
107 v
= &ctx
->stack
[ctx
->stack_len
++];
109 v
->in_stack_memory
= in_stack_memory
;
112 /* Pop the top item off of CTX's stack. */
115 dwarf_expr_pop (struct dwarf_expr_context
*ctx
)
117 if (ctx
->stack_len
<= 0)
118 error (_("dwarf expression stack underflow"));
122 /* Retrieve the N'th item on CTX's stack. */
125 dwarf_expr_fetch (struct dwarf_expr_context
*ctx
, int n
)
127 if (ctx
->stack_len
<= n
)
128 error (_("Asked for position %d of stack, stack only has %d elements on it."),
130 return ctx
->stack
[ctx
->stack_len
- (1 + n
)].value
;
134 /* Retrieve the in_stack_memory flag of the N'th item on CTX's stack. */
137 dwarf_expr_fetch_in_stack_memory (struct dwarf_expr_context
*ctx
, int n
)
139 if (ctx
->stack_len
<= n
)
140 error (_("Asked for position %d of stack, stack only has %d elements on it."),
142 return ctx
->stack
[ctx
->stack_len
- (1 + n
)].in_stack_memory
;
146 /* Return true if the expression stack is empty. */
149 dwarf_expr_stack_empty_p (struct dwarf_expr_context
*ctx
)
151 return ctx
->stack_len
== 0;
154 /* Add a new piece to CTX's piece list. */
156 add_piece (struct dwarf_expr_context
*ctx
, ULONGEST size
, ULONGEST offset
)
158 struct dwarf_expr_piece
*p
;
162 ctx
->pieces
= xrealloc (ctx
->pieces
,
164 * sizeof (struct dwarf_expr_piece
)));
166 p
= &ctx
->pieces
[ctx
->num_pieces
- 1];
167 p
->location
= ctx
->location
;
171 if (p
->location
== DWARF_VALUE_LITERAL
)
173 p
->v
.literal
.data
= ctx
->data
;
174 p
->v
.literal
.length
= ctx
->len
;
176 else if (dwarf_expr_stack_empty_p (ctx
))
178 p
->location
= DWARF_VALUE_OPTIMIZED_OUT
;
179 /* Also reset the context's location, for our callers. This is
180 a somewhat strange approach, but this lets us avoid setting
181 the location to DWARF_VALUE_MEMORY in all the individual
182 cases in the evaluator. */
183 ctx
->location
= DWARF_VALUE_OPTIMIZED_OUT
;
187 p
->v
.expr
.value
= dwarf_expr_fetch (ctx
, 0);
188 p
->v
.expr
.in_stack_memory
= dwarf_expr_fetch_in_stack_memory (ctx
, 0);
192 /* Evaluate the expression at ADDR (LEN bytes long) using the context
196 dwarf_expr_eval (struct dwarf_expr_context
*ctx
, const gdb_byte
*addr
,
199 int old_recursion_depth
= ctx
->recursion_depth
;
201 execute_stack_op (ctx
, addr
, addr
+ len
);
203 /* CTX RECURSION_DEPTH becomes invalid if an exception was thrown here. */
205 gdb_assert (ctx
->recursion_depth
== old_recursion_depth
);
208 /* Decode the unsigned LEB128 constant at BUF into the variable pointed to
209 by R, and return the new value of BUF. Verify that it doesn't extend
213 read_uleb128 (const gdb_byte
*buf
, const gdb_byte
*buf_end
, ULONGEST
* r
)
222 error (_("read_uleb128: Corrupted DWARF expression."));
225 result
|= (byte
& 0x7f) << shift
;
226 if ((byte
& 0x80) == 0)
234 /* Decode the signed LEB128 constant at BUF into the variable pointed to
235 by R, and return the new value of BUF. Verify that it doesn't extend
239 read_sleb128 (const gdb_byte
*buf
, const gdb_byte
*buf_end
, LONGEST
* r
)
248 error (_("read_sleb128: Corrupted DWARF expression."));
251 result
|= (byte
& 0x7f) << shift
;
253 if ((byte
& 0x80) == 0)
256 if (shift
< (sizeof (*r
) * 8) && (byte
& 0x40) != 0)
257 result
|= -(1 << shift
);
263 /* Read an address of size ADDR_SIZE from BUF, and verify that it
264 doesn't extend past BUF_END. */
267 dwarf2_read_address (struct gdbarch
*gdbarch
, const gdb_byte
*buf
,
268 const gdb_byte
*buf_end
, int addr_size
)
270 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
272 if (buf_end
- buf
< addr_size
)
273 error (_("dwarf2_read_address: Corrupted DWARF expression."));
275 /* For most architectures, calling extract_unsigned_integer() alone
276 is sufficient for extracting an address. However, some
277 architectures (e.g. MIPS) use signed addresses and using
278 extract_unsigned_integer() will not produce a correct
279 result. Make sure we invoke gdbarch_integer_to_address()
280 for those architectures which require it.
282 The use of `unsigned_address_type' in the code below refers to
283 the type of buf and has no bearing on the signedness of the
284 address being returned. */
286 if (gdbarch_integer_to_address_p (gdbarch
))
287 return gdbarch_integer_to_address
288 (gdbarch
, unsigned_address_type (gdbarch
, addr_size
), buf
);
290 return extract_unsigned_integer (buf
, addr_size
, byte_order
);
293 /* Return the type of an address of size ADDR_SIZE,
294 for unsigned arithmetic. */
297 unsigned_address_type (struct gdbarch
*gdbarch
, int addr_size
)
302 return builtin_type (gdbarch
)->builtin_uint16
;
304 return builtin_type (gdbarch
)->builtin_uint32
;
306 return builtin_type (gdbarch
)->builtin_uint64
;
308 internal_error (__FILE__
, __LINE__
,
309 _("Unsupported address size.\n"));
313 /* Return the type of an address of size ADDR_SIZE,
314 for signed arithmetic. */
317 signed_address_type (struct gdbarch
*gdbarch
, int addr_size
)
322 return builtin_type (gdbarch
)->builtin_int16
;
324 return builtin_type (gdbarch
)->builtin_int32
;
326 return builtin_type (gdbarch
)->builtin_int64
;
328 internal_error (__FILE__
, __LINE__
,
329 _("Unsupported address size.\n"));
334 /* Check that the current operator is either at the end of an
335 expression, or that it is followed by a composition operator. */
338 require_composition (const gdb_byte
*op_ptr
, const gdb_byte
*op_end
,
341 /* It seems like DW_OP_GNU_uninit should be handled here. However,
342 it doesn't seem to make sense for DW_OP_*_value, and it was not
343 checked at the other place that this function is called. */
344 if (op_ptr
!= op_end
&& *op_ptr
!= DW_OP_piece
&& *op_ptr
!= DW_OP_bit_piece
)
345 error (_("DWARF-2 expression error: `%s' operations must be "
346 "used either alone or in conjuction with DW_OP_piece "
347 "or DW_OP_bit_piece."),
351 /* The engine for the expression evaluator. Using the context in CTX,
352 evaluate the expression between OP_PTR and OP_END. */
355 execute_stack_op (struct dwarf_expr_context
*ctx
,
356 const gdb_byte
*op_ptr
, const gdb_byte
*op_end
)
358 enum bfd_endian byte_order
= gdbarch_byte_order (ctx
->gdbarch
);
360 ctx
->location
= DWARF_VALUE_MEMORY
;
361 ctx
->initialized
= 1; /* Default is initialized. */
363 if (ctx
->recursion_depth
> ctx
->max_recursion_depth
)
364 error (_("DWARF-2 expression error: Loop detected (%d)."),
365 ctx
->recursion_depth
);
366 ctx
->recursion_depth
++;
368 while (op_ptr
< op_end
)
370 enum dwarf_location_atom op
= *op_ptr
++;
372 /* Assume the value is not in stack memory.
373 Code that knows otherwise sets this to 1.
374 Some arithmetic on stack addresses can probably be assumed to still
375 be a stack address, but we skip this complication for now.
376 This is just an optimization, so it's always ok to punt
377 and leave this as 0. */
378 int in_stack_memory
= 0;
379 ULONGEST uoffset
, reg
;
416 result
= op
- DW_OP_lit0
;
420 result
= dwarf2_read_address (ctx
->gdbarch
,
421 op_ptr
, op_end
, ctx
->addr_size
);
422 op_ptr
+= ctx
->addr_size
;
426 result
= extract_unsigned_integer (op_ptr
, 1, byte_order
);
430 result
= extract_signed_integer (op_ptr
, 1, byte_order
);
434 result
= extract_unsigned_integer (op_ptr
, 2, byte_order
);
438 result
= extract_signed_integer (op_ptr
, 2, byte_order
);
442 result
= extract_unsigned_integer (op_ptr
, 4, byte_order
);
446 result
= extract_signed_integer (op_ptr
, 4, byte_order
);
450 result
= extract_unsigned_integer (op_ptr
, 8, byte_order
);
454 result
= extract_signed_integer (op_ptr
, 8, byte_order
);
458 op_ptr
= read_uleb128 (op_ptr
, op_end
, &uoffset
);
462 op_ptr
= read_sleb128 (op_ptr
, op_end
, &offset
);
466 /* The DW_OP_reg operations are required to occur alone in
467 location expressions. */
501 && *op_ptr
!= DW_OP_piece
502 && *op_ptr
!= DW_OP_bit_piece
503 && *op_ptr
!= DW_OP_GNU_uninit
)
504 error (_("DWARF-2 expression error: DW_OP_reg operations must be "
505 "used either alone or in conjuction with DW_OP_piece "
506 "or DW_OP_bit_piece."));
508 result
= op
- DW_OP_reg0
;
509 ctx
->location
= DWARF_VALUE_REGISTER
;
513 op_ptr
= read_uleb128 (op_ptr
, op_end
, ®
);
514 require_composition (op_ptr
, op_end
, "DW_OP_regx");
517 ctx
->location
= DWARF_VALUE_REGISTER
;
520 case DW_OP_implicit_value
:
524 op_ptr
= read_uleb128 (op_ptr
, op_end
, &len
);
525 if (op_ptr
+ len
> op_end
)
526 error (_("DW_OP_implicit_value: too few bytes available."));
529 ctx
->location
= DWARF_VALUE_LITERAL
;
531 require_composition (op_ptr
, op_end
, "DW_OP_implicit_value");
535 case DW_OP_stack_value
:
536 ctx
->location
= DWARF_VALUE_STACK
;
537 require_composition (op_ptr
, op_end
, "DW_OP_stack_value");
573 op_ptr
= read_sleb128 (op_ptr
, op_end
, &offset
);
574 result
= (ctx
->read_reg
) (ctx
->baton
, op
- DW_OP_breg0
);
580 op_ptr
= read_uleb128 (op_ptr
, op_end
, ®
);
581 op_ptr
= read_sleb128 (op_ptr
, op_end
, &offset
);
582 result
= (ctx
->read_reg
) (ctx
->baton
, reg
);
588 const gdb_byte
*datastart
;
590 unsigned int before_stack_len
;
592 op_ptr
= read_sleb128 (op_ptr
, op_end
, &offset
);
593 /* Rather than create a whole new context, we simply
594 record the stack length before execution, then reset it
595 afterwards, effectively erasing whatever the recursive
597 before_stack_len
= ctx
->stack_len
;
598 /* FIXME: cagney/2003-03-26: This code should be using
599 get_frame_base_address(), and then implement a dwarf2
600 specific this_base method. */
601 (ctx
->get_frame_base
) (ctx
->baton
, &datastart
, &datalen
);
602 dwarf_expr_eval (ctx
, datastart
, datalen
);
603 if (ctx
->location
== DWARF_VALUE_LITERAL
604 || ctx
->location
== DWARF_VALUE_STACK
)
605 error (_("Not implemented: computing frame base using explicit value operator"));
606 result
= dwarf_expr_fetch (ctx
, 0);
607 if (ctx
->location
== DWARF_VALUE_REGISTER
)
608 result
= (ctx
->read_reg
) (ctx
->baton
, result
);
609 result
= result
+ offset
;
611 ctx
->stack_len
= before_stack_len
;
612 ctx
->location
= DWARF_VALUE_MEMORY
;
617 result
= dwarf_expr_fetch (ctx
, 0);
618 in_stack_memory
= dwarf_expr_fetch_in_stack_memory (ctx
, 0);
622 dwarf_expr_pop (ctx
);
627 result
= dwarf_expr_fetch (ctx
, offset
);
628 in_stack_memory
= dwarf_expr_fetch_in_stack_memory (ctx
, offset
);
633 struct dwarf_stack_value t1
, t2
;
635 if (ctx
->stack_len
< 2)
636 error (_("Not enough elements for DW_OP_swap. Need 2, have %d."),
638 t1
= ctx
->stack
[ctx
->stack_len
- 1];
639 t2
= ctx
->stack
[ctx
->stack_len
- 2];
640 ctx
->stack
[ctx
->stack_len
- 1] = t2
;
641 ctx
->stack
[ctx
->stack_len
- 2] = t1
;
646 result
= dwarf_expr_fetch (ctx
, 1);
647 in_stack_memory
= dwarf_expr_fetch_in_stack_memory (ctx
, 1);
652 struct dwarf_stack_value t1
, t2
, t3
;
654 if (ctx
->stack_len
< 3)
655 error (_("Not enough elements for DW_OP_rot. Need 3, have %d."),
657 t1
= ctx
->stack
[ctx
->stack_len
- 1];
658 t2
= ctx
->stack
[ctx
->stack_len
- 2];
659 t3
= ctx
->stack
[ctx
->stack_len
- 3];
660 ctx
->stack
[ctx
->stack_len
- 1] = t2
;
661 ctx
->stack
[ctx
->stack_len
- 2] = t3
;
662 ctx
->stack
[ctx
->stack_len
- 3] = t1
;
667 case DW_OP_deref_size
:
671 case DW_OP_plus_uconst
:
672 /* Unary operations. */
673 result
= dwarf_expr_fetch (ctx
, 0);
674 dwarf_expr_pop (ctx
);
680 gdb_byte
*buf
= alloca (ctx
->addr_size
);
682 (ctx
->read_mem
) (ctx
->baton
, buf
, result
, ctx
->addr_size
);
683 result
= dwarf2_read_address (ctx
->gdbarch
,
684 buf
, buf
+ ctx
->addr_size
,
689 case DW_OP_deref_size
:
691 int addr_size
= *op_ptr
++;
692 gdb_byte
*buf
= alloca (addr_size
);
694 (ctx
->read_mem
) (ctx
->baton
, buf
, result
, addr_size
);
695 result
= dwarf2_read_address (ctx
->gdbarch
,
696 buf
, buf
+ addr_size
,
702 if ((signed int) result
< 0)
711 case DW_OP_plus_uconst
:
712 op_ptr
= read_uleb128 (op_ptr
, op_end
, ®
);
736 /* Binary operations. Use the value engine to do computations in
738 CORE_ADDR first
, second
;
739 enum exp_opcode binop
;
740 struct value
*val1
= NULL
, *val2
= NULL
;
741 struct type
*stype
, *utype
;
743 second
= dwarf_expr_fetch (ctx
, 0);
744 dwarf_expr_pop (ctx
);
746 first
= dwarf_expr_fetch (ctx
, 0);
747 dwarf_expr_pop (ctx
);
749 utype
= unsigned_address_type (ctx
->gdbarch
, ctx
->addr_size
);
750 stype
= signed_address_type (ctx
->gdbarch
, ctx
->addr_size
);
755 binop
= BINOP_BITWISE_AND
;
759 val1
= value_from_longest (stype
, first
);
760 val2
= value_from_longest (stype
, second
);
772 binop
= BINOP_BITWISE_IOR
;
785 val1
= value_from_longest (stype
, first
);
788 binop
= BINOP_BITWISE_XOR
;
792 val1
= value_from_longest (stype
, first
);
793 val2
= value_from_longest (stype
, second
);
797 val1
= value_from_longest (stype
, first
);
798 val2
= value_from_longest (stype
, second
);
802 val1
= value_from_longest (stype
, first
);
803 val2
= value_from_longest (stype
, second
);
807 val1
= value_from_longest (stype
, first
);
808 val2
= value_from_longest (stype
, second
);
812 val1
= value_from_longest (stype
, first
);
813 val2
= value_from_longest (stype
, second
);
816 binop
= BINOP_NOTEQUAL
;
817 val1
= value_from_longest (stype
, first
);
818 val2
= value_from_longest (stype
, second
);
821 internal_error (__FILE__
, __LINE__
,
822 _("Can't be reached."));
825 /* We use unsigned operands by default. */
827 val1
= value_from_longest (utype
, first
);
829 val2
= value_from_longest (utype
, second
);
831 result
= value_as_long (value_binop (val1
, val2
, binop
));
835 case DW_OP_call_frame_cfa
:
836 result
= (ctx
->get_frame_cfa
) (ctx
->baton
);
840 case DW_OP_GNU_push_tls_address
:
841 /* Variable is at a constant offset in the thread-local
842 storage block into the objfile for the current thread and
843 the dynamic linker module containing this expression. Here
844 we return returns the offset from that base. The top of the
845 stack has the offset from the beginning of the thread
846 control block at which the variable is located. Nothing
847 should follow this operator, so the top of stack would be
849 result
= dwarf_expr_fetch (ctx
, 0);
850 dwarf_expr_pop (ctx
);
851 result
= (ctx
->get_tls_address
) (ctx
->baton
, result
);
855 offset
= extract_signed_integer (op_ptr
, 2, byte_order
);
861 offset
= extract_signed_integer (op_ptr
, 2, byte_order
);
863 if (dwarf_expr_fetch (ctx
, 0) != 0)
865 dwarf_expr_pop (ctx
);
875 /* Record the piece. */
876 op_ptr
= read_uleb128 (op_ptr
, op_end
, &size
);
877 add_piece (ctx
, 8 * size
, 0);
879 /* Pop off the address/regnum, and reset the location
881 if (ctx
->location
!= DWARF_VALUE_LITERAL
882 && ctx
->location
!= DWARF_VALUE_OPTIMIZED_OUT
)
883 dwarf_expr_pop (ctx
);
884 ctx
->location
= DWARF_VALUE_MEMORY
;
888 case DW_OP_bit_piece
:
890 ULONGEST size
, offset
;
892 /* Record the piece. */
893 op_ptr
= read_uleb128 (op_ptr
, op_end
, &size
);
894 op_ptr
= read_uleb128 (op_ptr
, op_end
, &offset
);
895 add_piece (ctx
, size
, offset
);
897 /* Pop off the address/regnum, and reset the location
899 if (ctx
->location
!= DWARF_VALUE_LITERAL
900 && ctx
->location
!= DWARF_VALUE_OPTIMIZED_OUT
)
901 dwarf_expr_pop (ctx
);
902 ctx
->location
= DWARF_VALUE_MEMORY
;
906 case DW_OP_GNU_uninit
:
907 if (op_ptr
!= op_end
)
908 error (_("DWARF-2 expression error: DW_OP_GNU_uninit must always "
909 "be the very last op."));
911 ctx
->initialized
= 0;
915 result
= extract_unsigned_integer (op_ptr
, 2, byte_order
);
917 ctx
->dwarf_call (ctx
, result
);
921 result
= extract_unsigned_integer (op_ptr
, 4, byte_order
);
923 ctx
->dwarf_call (ctx
, result
);
927 error (_("Unhandled dwarf expression opcode 0x%x"), op
);
930 /* Most things push a result value. */
931 dwarf_expr_push (ctx
, result
, in_stack_memory
);
935 ctx
->recursion_depth
--;
936 gdb_assert (ctx
->recursion_depth
>= 0);