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 dwarf_expr_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 dwarf_expr_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 dwarf_expr_require_composition (op_ptr
, op_end
,
532 "DW_OP_implicit_value");
536 case DW_OP_stack_value
:
537 ctx
->location
= DWARF_VALUE_STACK
;
538 dwarf_expr_require_composition (op_ptr
, op_end
, "DW_OP_stack_value");
574 op_ptr
= read_sleb128 (op_ptr
, op_end
, &offset
);
575 result
= (ctx
->read_reg
) (ctx
->baton
, op
- DW_OP_breg0
);
581 op_ptr
= read_uleb128 (op_ptr
, op_end
, ®
);
582 op_ptr
= read_sleb128 (op_ptr
, op_end
, &offset
);
583 result
= (ctx
->read_reg
) (ctx
->baton
, reg
);
589 const gdb_byte
*datastart
;
591 unsigned int before_stack_len
;
593 op_ptr
= read_sleb128 (op_ptr
, op_end
, &offset
);
594 /* Rather than create a whole new context, we simply
595 record the stack length before execution, then reset it
596 afterwards, effectively erasing whatever the recursive
598 before_stack_len
= ctx
->stack_len
;
599 /* FIXME: cagney/2003-03-26: This code should be using
600 get_frame_base_address(), and then implement a dwarf2
601 specific this_base method. */
602 (ctx
->get_frame_base
) (ctx
->baton
, &datastart
, &datalen
);
603 dwarf_expr_eval (ctx
, datastart
, datalen
);
604 if (ctx
->location
== DWARF_VALUE_LITERAL
605 || ctx
->location
== DWARF_VALUE_STACK
)
606 error (_("Not implemented: computing frame base using explicit value operator"));
607 result
= dwarf_expr_fetch (ctx
, 0);
608 if (ctx
->location
== DWARF_VALUE_REGISTER
)
609 result
= (ctx
->read_reg
) (ctx
->baton
, result
);
610 result
= result
+ offset
;
612 ctx
->stack_len
= before_stack_len
;
613 ctx
->location
= DWARF_VALUE_MEMORY
;
618 result
= dwarf_expr_fetch (ctx
, 0);
619 in_stack_memory
= dwarf_expr_fetch_in_stack_memory (ctx
, 0);
623 dwarf_expr_pop (ctx
);
628 result
= dwarf_expr_fetch (ctx
, offset
);
629 in_stack_memory
= dwarf_expr_fetch_in_stack_memory (ctx
, offset
);
634 struct dwarf_stack_value t1
, t2
;
636 if (ctx
->stack_len
< 2)
637 error (_("Not enough elements for DW_OP_swap. Need 2, have %d."),
639 t1
= ctx
->stack
[ctx
->stack_len
- 1];
640 t2
= ctx
->stack
[ctx
->stack_len
- 2];
641 ctx
->stack
[ctx
->stack_len
- 1] = t2
;
642 ctx
->stack
[ctx
->stack_len
- 2] = t1
;
647 result
= dwarf_expr_fetch (ctx
, 1);
648 in_stack_memory
= dwarf_expr_fetch_in_stack_memory (ctx
, 1);
653 struct dwarf_stack_value t1
, t2
, t3
;
655 if (ctx
->stack_len
< 3)
656 error (_("Not enough elements for DW_OP_rot. Need 3, have %d."),
658 t1
= ctx
->stack
[ctx
->stack_len
- 1];
659 t2
= ctx
->stack
[ctx
->stack_len
- 2];
660 t3
= ctx
->stack
[ctx
->stack_len
- 3];
661 ctx
->stack
[ctx
->stack_len
- 1] = t2
;
662 ctx
->stack
[ctx
->stack_len
- 2] = t3
;
663 ctx
->stack
[ctx
->stack_len
- 3] = t1
;
668 case DW_OP_deref_size
:
672 case DW_OP_plus_uconst
:
673 /* Unary operations. */
674 result
= dwarf_expr_fetch (ctx
, 0);
675 dwarf_expr_pop (ctx
);
681 gdb_byte
*buf
= alloca (ctx
->addr_size
);
683 (ctx
->read_mem
) (ctx
->baton
, buf
, result
, ctx
->addr_size
);
684 result
= dwarf2_read_address (ctx
->gdbarch
,
685 buf
, buf
+ ctx
->addr_size
,
690 case DW_OP_deref_size
:
692 int addr_size
= *op_ptr
++;
693 gdb_byte
*buf
= alloca (addr_size
);
695 (ctx
->read_mem
) (ctx
->baton
, buf
, result
, addr_size
);
696 result
= dwarf2_read_address (ctx
->gdbarch
,
697 buf
, buf
+ addr_size
,
703 if ((signed int) result
< 0)
712 case DW_OP_plus_uconst
:
713 op_ptr
= read_uleb128 (op_ptr
, op_end
, ®
);
737 /* Binary operations. Use the value engine to do computations in
739 CORE_ADDR first
, second
;
740 enum exp_opcode binop
;
741 struct value
*val1
= NULL
, *val2
= NULL
;
742 struct type
*stype
, *utype
;
744 second
= dwarf_expr_fetch (ctx
, 0);
745 dwarf_expr_pop (ctx
);
747 first
= dwarf_expr_fetch (ctx
, 0);
748 dwarf_expr_pop (ctx
);
750 utype
= unsigned_address_type (ctx
->gdbarch
, ctx
->addr_size
);
751 stype
= signed_address_type (ctx
->gdbarch
, ctx
->addr_size
);
756 binop
= BINOP_BITWISE_AND
;
760 val1
= value_from_longest (stype
, first
);
761 val2
= value_from_longest (stype
, second
);
773 binop
= BINOP_BITWISE_IOR
;
786 val1
= value_from_longest (stype
, first
);
789 binop
= BINOP_BITWISE_XOR
;
793 val1
= value_from_longest (stype
, first
);
794 val2
= value_from_longest (stype
, second
);
798 val1
= value_from_longest (stype
, first
);
799 val2
= value_from_longest (stype
, second
);
803 val1
= value_from_longest (stype
, first
);
804 val2
= value_from_longest (stype
, second
);
808 val1
= value_from_longest (stype
, first
);
809 val2
= value_from_longest (stype
, second
);
813 val1
= value_from_longest (stype
, first
);
814 val2
= value_from_longest (stype
, second
);
817 binop
= BINOP_NOTEQUAL
;
818 val1
= value_from_longest (stype
, first
);
819 val2
= value_from_longest (stype
, second
);
822 internal_error (__FILE__
, __LINE__
,
823 _("Can't be reached."));
826 /* We use unsigned operands by default. */
828 val1
= value_from_longest (utype
, first
);
830 val2
= value_from_longest (utype
, second
);
832 result
= value_as_long (value_binop (val1
, val2
, binop
));
836 case DW_OP_call_frame_cfa
:
837 result
= (ctx
->get_frame_cfa
) (ctx
->baton
);
841 case DW_OP_GNU_push_tls_address
:
842 /* Variable is at a constant offset in the thread-local
843 storage block into the objfile for the current thread and
844 the dynamic linker module containing this expression. Here
845 we return returns the offset from that base. The top of the
846 stack has the offset from the beginning of the thread
847 control block at which the variable is located. Nothing
848 should follow this operator, so the top of stack would be
850 result
= dwarf_expr_fetch (ctx
, 0);
851 dwarf_expr_pop (ctx
);
852 result
= (ctx
->get_tls_address
) (ctx
->baton
, result
);
856 offset
= extract_signed_integer (op_ptr
, 2, byte_order
);
862 offset
= extract_signed_integer (op_ptr
, 2, byte_order
);
864 if (dwarf_expr_fetch (ctx
, 0) != 0)
866 dwarf_expr_pop (ctx
);
876 /* Record the piece. */
877 op_ptr
= read_uleb128 (op_ptr
, op_end
, &size
);
878 add_piece (ctx
, 8 * size
, 0);
880 /* Pop off the address/regnum, and reset the location
882 if (ctx
->location
!= DWARF_VALUE_LITERAL
883 && ctx
->location
!= DWARF_VALUE_OPTIMIZED_OUT
)
884 dwarf_expr_pop (ctx
);
885 ctx
->location
= DWARF_VALUE_MEMORY
;
889 case DW_OP_bit_piece
:
891 ULONGEST size
, offset
;
893 /* Record the piece. */
894 op_ptr
= read_uleb128 (op_ptr
, op_end
, &size
);
895 op_ptr
= read_uleb128 (op_ptr
, op_end
, &offset
);
896 add_piece (ctx
, size
, offset
);
898 /* Pop off the address/regnum, and reset the location
900 if (ctx
->location
!= DWARF_VALUE_LITERAL
901 && ctx
->location
!= DWARF_VALUE_OPTIMIZED_OUT
)
902 dwarf_expr_pop (ctx
);
903 ctx
->location
= DWARF_VALUE_MEMORY
;
907 case DW_OP_GNU_uninit
:
908 if (op_ptr
!= op_end
)
909 error (_("DWARF-2 expression error: DW_OP_GNU_uninit must always "
910 "be the very last op."));
912 ctx
->initialized
= 0;
916 result
= extract_unsigned_integer (op_ptr
, 2, byte_order
);
918 ctx
->dwarf_call (ctx
, result
);
922 result
= extract_unsigned_integer (op_ptr
, 4, byte_order
);
924 ctx
->dwarf_call (ctx
, result
);
928 error (_("Unhandled dwarf expression opcode 0x%x"), op
);
931 /* Most things push a result value. */
932 dwarf_expr_push (ctx
, result
, in_stack_memory
);
936 ctx
->recursion_depth
--;
937 gdb_assert (ctx
->recursion_depth
>= 0);