1 /* DWARF 2 Expression Evaluator.
3 Copyright (C) 2001, 2002, 2003, 2005, 2007, 2008, 2009, 2010, 2011
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 /* Cookie for gdbarch data. */
39 static struct gdbarch_data
*dwarf_arch_cookie
;
41 /* This holds gdbarch-specific types used by the DWARF expression
42 evaluator. See comments in execute_stack_op. */
44 struct dwarf_gdbarch_types
46 struct type
*dw_types
[3];
49 /* Allocate and fill in dwarf_gdbarch_types for an arch. */
52 dwarf_gdbarch_types_init (struct gdbarch
*gdbarch
)
54 struct dwarf_gdbarch_types
*types
55 = GDBARCH_OBSTACK_ZALLOC (gdbarch
, struct dwarf_gdbarch_types
);
57 /* The types themselves are lazily initialized. */
62 /* Return the type used for DWARF operations where the type is
63 unspecified in the DWARF spec. Only certain sizes are
67 dwarf_expr_address_type (struct dwarf_expr_context
*ctx
)
69 struct dwarf_gdbarch_types
*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
= xcalloc (1, sizeof (struct dwarf_expr_context
));
100 retval
->stack_len
= 0;
101 retval
->stack_allocated
= 10;
102 retval
->stack
= xmalloc (retval
->stack_allocated
103 * sizeof (struct dwarf_stack_value
));
104 retval
->num_pieces
= 0;
106 retval
->max_recursion_depth
= 0x100;
110 /* Release the memory allocated to CTX. */
113 free_dwarf_expr_context (struct dwarf_expr_context
*ctx
)
120 /* Helper for make_cleanup_free_dwarf_expr_context. */
123 free_dwarf_expr_context_cleanup (void *arg
)
125 free_dwarf_expr_context (arg
);
128 /* Return a cleanup that calls free_dwarf_expr_context. */
131 make_cleanup_free_dwarf_expr_context (struct dwarf_expr_context
*ctx
)
133 return make_cleanup (free_dwarf_expr_context_cleanup
, ctx
);
136 /* Expand the memory allocated to CTX's stack to contain at least
137 NEED more elements than are currently used. */
140 dwarf_expr_grow_stack (struct dwarf_expr_context
*ctx
, size_t need
)
142 if (ctx
->stack_len
+ need
> ctx
->stack_allocated
)
144 size_t newlen
= ctx
->stack_len
+ need
+ 10;
146 ctx
->stack
= xrealloc (ctx
->stack
,
147 newlen
* sizeof (struct dwarf_stack_value
));
148 ctx
->stack_allocated
= newlen
;
152 /* Push VALUE onto CTX's stack. */
155 dwarf_expr_push (struct dwarf_expr_context
*ctx
, struct value
*value
,
158 struct dwarf_stack_value
*v
;
160 dwarf_expr_grow_stack (ctx
, 1);
161 v
= &ctx
->stack
[ctx
->stack_len
++];
163 v
->in_stack_memory
= in_stack_memory
;
166 /* Push VALUE onto CTX's stack. */
169 dwarf_expr_push_address (struct dwarf_expr_context
*ctx
, CORE_ADDR value
,
172 dwarf_expr_push (ctx
,
173 value_from_ulongest (dwarf_expr_address_type (ctx
), value
),
177 /* Pop the top item off of CTX's stack. */
180 dwarf_expr_pop (struct dwarf_expr_context
*ctx
)
182 if (ctx
->stack_len
<= 0)
183 error (_("dwarf expression stack underflow"));
187 /* Retrieve the N'th item on CTX's stack. */
190 dwarf_expr_fetch (struct dwarf_expr_context
*ctx
, int n
)
192 if (ctx
->stack_len
<= n
)
193 error (_("Asked for position %d of stack, "
194 "stack only has %d elements on it."),
196 return ctx
->stack
[ctx
->stack_len
- (1 + n
)].value
;
199 /* Require that TYPE be an integral type; throw an exception if not. */
202 dwarf_require_integral (struct type
*type
)
204 if (TYPE_CODE (type
) != TYPE_CODE_INT
205 && TYPE_CODE (type
) != TYPE_CODE_CHAR
206 && TYPE_CODE (type
) != TYPE_CODE_BOOL
)
207 error (_("integral type expected in DWARF expression"));
210 /* Return the unsigned form of TYPE. TYPE is necessarily an integral
214 get_unsigned_type (struct gdbarch
*gdbarch
, struct type
*type
)
216 switch (TYPE_LENGTH (type
))
219 return builtin_type (gdbarch
)->builtin_uint8
;
221 return builtin_type (gdbarch
)->builtin_uint16
;
223 return builtin_type (gdbarch
)->builtin_uint32
;
225 return builtin_type (gdbarch
)->builtin_uint64
;
227 error (_("no unsigned variant found for type, while evaluating "
228 "DWARF expression"));
232 /* Return the signed form of TYPE. TYPE is necessarily an integral
236 get_signed_type (struct gdbarch
*gdbarch
, struct type
*type
)
238 switch (TYPE_LENGTH (type
))
241 return builtin_type (gdbarch
)->builtin_int8
;
243 return builtin_type (gdbarch
)->builtin_int16
;
245 return builtin_type (gdbarch
)->builtin_int32
;
247 return builtin_type (gdbarch
)->builtin_int64
;
249 error (_("no signed variant found for type, while evaluating "
250 "DWARF expression"));
254 /* Retrieve the N'th item on CTX's stack, converted to an address. */
257 dwarf_expr_fetch_address (struct dwarf_expr_context
*ctx
, int n
)
259 struct value
*result_val
= dwarf_expr_fetch (ctx
, n
);
260 enum bfd_endian byte_order
= gdbarch_byte_order (ctx
->gdbarch
);
263 dwarf_require_integral (value_type (result_val
));
264 result
= extract_unsigned_integer (value_contents (result_val
),
265 TYPE_LENGTH (value_type (result_val
)),
268 /* For most architectures, calling extract_unsigned_integer() alone
269 is sufficient for extracting an address. However, some
270 architectures (e.g. MIPS) use signed addresses and using
271 extract_unsigned_integer() will not produce a correct
272 result. Make sure we invoke gdbarch_integer_to_address()
273 for those architectures which require it. */
274 if (gdbarch_integer_to_address_p (ctx
->gdbarch
))
276 gdb_byte
*buf
= alloca (ctx
->addr_size
);
277 struct type
*int_type
= get_unsigned_type (ctx
->gdbarch
,
278 value_type (result_val
));
280 store_unsigned_integer (buf
, ctx
->addr_size
, byte_order
, result
);
281 return gdbarch_integer_to_address (ctx
->gdbarch
, int_type
, buf
);
284 return (CORE_ADDR
) result
;
287 /* Retrieve the in_stack_memory flag of the N'th item on CTX's stack. */
290 dwarf_expr_fetch_in_stack_memory (struct dwarf_expr_context
*ctx
, int n
)
292 if (ctx
->stack_len
<= n
)
293 error (_("Asked for position %d of stack, "
294 "stack only has %d elements on it."),
296 return ctx
->stack
[ctx
->stack_len
- (1 + n
)].in_stack_memory
;
299 /* Return true if the expression stack is empty. */
302 dwarf_expr_stack_empty_p (struct dwarf_expr_context
*ctx
)
304 return ctx
->stack_len
== 0;
307 /* Add a new piece to CTX's piece list. */
309 add_piece (struct dwarf_expr_context
*ctx
, ULONGEST size
, ULONGEST offset
)
311 struct dwarf_expr_piece
*p
;
315 ctx
->pieces
= xrealloc (ctx
->pieces
,
317 * sizeof (struct dwarf_expr_piece
)));
319 p
= &ctx
->pieces
[ctx
->num_pieces
- 1];
320 p
->location
= ctx
->location
;
324 if (p
->location
== DWARF_VALUE_LITERAL
)
326 p
->v
.literal
.data
= ctx
->data
;
327 p
->v
.literal
.length
= ctx
->len
;
329 else if (dwarf_expr_stack_empty_p (ctx
))
331 p
->location
= DWARF_VALUE_OPTIMIZED_OUT
;
332 /* Also reset the context's location, for our callers. This is
333 a somewhat strange approach, but this lets us avoid setting
334 the location to DWARF_VALUE_MEMORY in all the individual
335 cases in the evaluator. */
336 ctx
->location
= DWARF_VALUE_OPTIMIZED_OUT
;
338 else if (p
->location
== DWARF_VALUE_MEMORY
)
340 p
->v
.mem
.addr
= dwarf_expr_fetch_address (ctx
, 0);
341 p
->v
.mem
.in_stack_memory
= dwarf_expr_fetch_in_stack_memory (ctx
, 0);
343 else if (p
->location
== DWARF_VALUE_IMPLICIT_POINTER
)
345 p
->v
.ptr
.die
= ctx
->len
;
346 p
->v
.ptr
.offset
= value_as_long (dwarf_expr_fetch (ctx
, 0));
348 else if (p
->location
== DWARF_VALUE_REGISTER
)
349 p
->v
.regno
= value_as_long (dwarf_expr_fetch (ctx
, 0));
352 p
->v
.value
= dwarf_expr_fetch (ctx
, 0);
356 /* Evaluate the expression at ADDR (LEN bytes long) using the context
360 dwarf_expr_eval (struct dwarf_expr_context
*ctx
, const gdb_byte
*addr
,
363 int old_recursion_depth
= ctx
->recursion_depth
;
365 execute_stack_op (ctx
, addr
, addr
+ len
);
367 /* CTX RECURSION_DEPTH becomes invalid if an exception was thrown here. */
369 gdb_assert (ctx
->recursion_depth
== old_recursion_depth
);
372 /* Decode the unsigned LEB128 constant at BUF into the variable pointed to
373 by R, and return the new value of BUF. Verify that it doesn't extend
374 past BUF_END. R can be NULL, the constant is then only skipped. */
377 read_uleb128 (const gdb_byte
*buf
, const gdb_byte
*buf_end
, ULONGEST
* r
)
386 error (_("read_uleb128: Corrupted DWARF expression."));
389 result
|= ((ULONGEST
) (byte
& 0x7f)) << shift
;
390 if ((byte
& 0x80) == 0)
399 /* Decode the signed LEB128 constant at BUF into the variable pointed to
400 by R, and return the new value of BUF. Verify that it doesn't extend
401 past BUF_END. R can be NULL, the constant is then only skipped. */
404 read_sleb128 (const gdb_byte
*buf
, const gdb_byte
*buf_end
, LONGEST
* r
)
413 error (_("read_sleb128: Corrupted DWARF expression."));
416 result
|= ((ULONGEST
) (byte
& 0x7f)) << shift
;
418 if ((byte
& 0x80) == 0)
421 if (shift
< (sizeof (*r
) * 8) && (byte
& 0x40) != 0)
422 result
|= -(((LONGEST
) 1) << shift
);
430 /* Check that the current operator is either at the end of an
431 expression, or that it is followed by a composition operator. */
434 dwarf_expr_require_composition (const gdb_byte
*op_ptr
, const gdb_byte
*op_end
,
437 /* It seems like DW_OP_GNU_uninit should be handled here. However,
438 it doesn't seem to make sense for DW_OP_*_value, and it was not
439 checked at the other place that this function is called. */
440 if (op_ptr
!= op_end
&& *op_ptr
!= DW_OP_piece
&& *op_ptr
!= DW_OP_bit_piece
)
441 error (_("DWARF-2 expression error: `%s' operations must be "
442 "used either alone or in conjunction with DW_OP_piece "
443 "or DW_OP_bit_piece."),
447 /* Return true iff the types T1 and T2 are "the same". This only does
448 checks that might reasonably be needed to compare DWARF base
452 base_types_equal_p (struct type
*t1
, struct type
*t2
)
454 if (TYPE_CODE (t1
) != TYPE_CODE (t2
))
456 if (TYPE_UNSIGNED (t1
) != TYPE_UNSIGNED (t2
))
458 return TYPE_LENGTH (t1
) == TYPE_LENGTH (t2
);
461 /* A convenience function to call get_base_type on CTX and return the
462 result. DIE is the DIE whose type we need. SIZE is non-zero if
463 this function should verify that the resulting type has the correct
467 dwarf_get_base_type (struct dwarf_expr_context
*ctx
, ULONGEST die
, int size
)
471 if (ctx
->funcs
->get_base_type
)
473 result
= ctx
->funcs
->get_base_type (ctx
, die
);
475 error (_("Could not find type for DW_OP_GNU_const_type"));
476 if (size
!= 0 && TYPE_LENGTH (result
) != size
)
477 error (_("DW_OP_GNU_const_type has different sizes for type and data"));
480 /* Anything will do. */
481 result
= builtin_type (ctx
->gdbarch
)->builtin_int
;
486 /* If <BUF..BUF_END] contains DW_FORM_block* with single DW_OP_reg* return the
487 DWARF register number. Otherwise return -1. */
490 dwarf_block_to_dwarf_reg (const gdb_byte
*buf
, const gdb_byte
*buf_end
)
496 if (*buf
>= DW_OP_reg0
&& *buf
<= DW_OP_reg31
)
498 if (buf_end
- buf
!= 1)
500 return *buf
- DW_OP_reg0
;
503 if (*buf
== DW_OP_GNU_regval_type
)
506 buf
= read_uleb128 (buf
, buf_end
, &dwarf_reg
);
507 buf
= read_uleb128 (buf
, buf_end
, NULL
);
509 else if (*buf
== DW_OP_regx
)
512 buf
= read_uleb128 (buf
, buf_end
, &dwarf_reg
);
516 if (buf
!= buf_end
|| (int) dwarf_reg
!= dwarf_reg
)
521 /* The engine for the expression evaluator. Using the context in CTX,
522 evaluate the expression between OP_PTR and OP_END. */
525 execute_stack_op (struct dwarf_expr_context
*ctx
,
526 const gdb_byte
*op_ptr
, const gdb_byte
*op_end
)
528 enum bfd_endian byte_order
= gdbarch_byte_order (ctx
->gdbarch
);
529 /* Old-style "untyped" DWARF values need special treatment in a
530 couple of places, specifically DW_OP_mod and DW_OP_shr. We need
531 a special type for these values so we can distinguish them from
532 values that have an explicit type, because explicitly-typed
533 values do not need special treatment. This special type must be
534 different (in the `==' sense) from any base type coming from the
536 struct type
*address_type
= dwarf_expr_address_type (ctx
);
538 ctx
->location
= DWARF_VALUE_MEMORY
;
539 ctx
->initialized
= 1; /* Default is initialized. */
541 if (ctx
->recursion_depth
> ctx
->max_recursion_depth
)
542 error (_("DWARF-2 expression error: Loop detected (%d)."),
543 ctx
->recursion_depth
);
544 ctx
->recursion_depth
++;
546 while (op_ptr
< op_end
)
548 enum dwarf_location_atom op
= *op_ptr
++;
550 /* Assume the value is not in stack memory.
551 Code that knows otherwise sets this to 1.
552 Some arithmetic on stack addresses can probably be assumed to still
553 be a stack address, but we skip this complication for now.
554 This is just an optimization, so it's always ok to punt
555 and leave this as 0. */
556 int in_stack_memory
= 0;
557 ULONGEST uoffset
, reg
;
559 struct value
*result_val
= NULL
;
561 /* The DWARF expression might have a bug causing an infinite
562 loop. In that case, quitting is the only way out. */
599 result
= op
- DW_OP_lit0
;
600 result_val
= value_from_ulongest (address_type
, result
);
604 result
= extract_unsigned_integer (op_ptr
,
605 ctx
->addr_size
, byte_order
);
606 op_ptr
+= ctx
->addr_size
;
607 /* Some versions of GCC emit DW_OP_addr before
608 DW_OP_GNU_push_tls_address. In this case the value is an
609 index, not an address. We don't support things like
610 branching between the address and the TLS op. */
611 if (op_ptr
>= op_end
|| *op_ptr
!= DW_OP_GNU_push_tls_address
)
612 result
+= ctx
->offset
;
613 result_val
= value_from_ulongest (address_type
, result
);
617 result
= extract_unsigned_integer (op_ptr
, 1, byte_order
);
618 result_val
= value_from_ulongest (address_type
, result
);
622 result
= extract_signed_integer (op_ptr
, 1, byte_order
);
623 result_val
= value_from_ulongest (address_type
, result
);
627 result
= extract_unsigned_integer (op_ptr
, 2, byte_order
);
628 result_val
= value_from_ulongest (address_type
, result
);
632 result
= extract_signed_integer (op_ptr
, 2, byte_order
);
633 result_val
= value_from_ulongest (address_type
, result
);
637 result
= extract_unsigned_integer (op_ptr
, 4, byte_order
);
638 result_val
= value_from_ulongest (address_type
, result
);
642 result
= extract_signed_integer (op_ptr
, 4, byte_order
);
643 result_val
= value_from_ulongest (address_type
, result
);
647 result
= extract_unsigned_integer (op_ptr
, 8, byte_order
);
648 result_val
= value_from_ulongest (address_type
, result
);
652 result
= extract_signed_integer (op_ptr
, 8, byte_order
);
653 result_val
= value_from_ulongest (address_type
, result
);
657 op_ptr
= read_uleb128 (op_ptr
, op_end
, &uoffset
);
659 result_val
= value_from_ulongest (address_type
, result
);
662 op_ptr
= read_sleb128 (op_ptr
, op_end
, &offset
);
664 result_val
= value_from_ulongest (address_type
, result
);
667 /* The DW_OP_reg operations are required to occur alone in
668 location expressions. */
702 && *op_ptr
!= DW_OP_piece
703 && *op_ptr
!= DW_OP_bit_piece
704 && *op_ptr
!= DW_OP_GNU_uninit
)
705 error (_("DWARF-2 expression error: DW_OP_reg operations must be "
706 "used either alone or in conjunction with DW_OP_piece "
707 "or DW_OP_bit_piece."));
709 result
= op
- DW_OP_reg0
;
710 result_val
= value_from_ulongest (address_type
, result
);
711 ctx
->location
= DWARF_VALUE_REGISTER
;
715 op_ptr
= read_uleb128 (op_ptr
, op_end
, ®
);
716 dwarf_expr_require_composition (op_ptr
, op_end
, "DW_OP_regx");
719 result_val
= value_from_ulongest (address_type
, result
);
720 ctx
->location
= DWARF_VALUE_REGISTER
;
723 case DW_OP_implicit_value
:
727 op_ptr
= read_uleb128 (op_ptr
, op_end
, &len
);
728 if (op_ptr
+ len
> op_end
)
729 error (_("DW_OP_implicit_value: too few bytes available."));
732 ctx
->location
= DWARF_VALUE_LITERAL
;
734 dwarf_expr_require_composition (op_ptr
, op_end
,
735 "DW_OP_implicit_value");
739 case DW_OP_stack_value
:
740 ctx
->location
= DWARF_VALUE_STACK
;
741 dwarf_expr_require_composition (op_ptr
, op_end
, "DW_OP_stack_value");
744 case DW_OP_GNU_implicit_pointer
:
749 if (ctx
->ref_addr_size
== -1)
750 error (_("DWARF-2 expression error: DW_OP_GNU_implicit_pointer "
751 "is not allowed in frame context"));
753 /* The referred-to DIE. */
754 ctx
->len
= extract_unsigned_integer (op_ptr
, ctx
->ref_addr_size
,
756 op_ptr
+= ctx
->ref_addr_size
;
758 /* The byte offset into the data. */
759 op_ptr
= read_sleb128 (op_ptr
, op_end
, &len
);
760 result
= (ULONGEST
) len
;
761 result_val
= value_from_ulongest (address_type
, result
);
763 ctx
->location
= DWARF_VALUE_IMPLICIT_POINTER
;
764 dwarf_expr_require_composition (op_ptr
, op_end
,
765 "DW_OP_GNU_implicit_pointer");
802 op_ptr
= read_sleb128 (op_ptr
, op_end
, &offset
);
803 result
= (ctx
->funcs
->read_reg
) (ctx
->baton
, op
- DW_OP_breg0
);
805 result_val
= value_from_ulongest (address_type
, result
);
810 op_ptr
= read_uleb128 (op_ptr
, op_end
, ®
);
811 op_ptr
= read_sleb128 (op_ptr
, op_end
, &offset
);
812 result
= (ctx
->funcs
->read_reg
) (ctx
->baton
, reg
);
814 result_val
= value_from_ulongest (address_type
, result
);
819 const gdb_byte
*datastart
;
821 unsigned int before_stack_len
;
823 op_ptr
= read_sleb128 (op_ptr
, op_end
, &offset
);
824 /* Rather than create a whole new context, we simply
825 record the stack length before execution, then reset it
826 afterwards, effectively erasing whatever the recursive
828 before_stack_len
= ctx
->stack_len
;
829 /* FIXME: cagney/2003-03-26: This code should be using
830 get_frame_base_address(), and then implement a dwarf2
831 specific this_base method. */
832 (ctx
->funcs
->get_frame_base
) (ctx
->baton
, &datastart
, &datalen
);
833 dwarf_expr_eval (ctx
, datastart
, datalen
);
834 if (ctx
->location
== DWARF_VALUE_MEMORY
)
835 result
= dwarf_expr_fetch_address (ctx
, 0);
836 else if (ctx
->location
== DWARF_VALUE_REGISTER
)
837 result
= (ctx
->funcs
->read_reg
) (ctx
->baton
,
838 value_as_long (dwarf_expr_fetch (ctx
, 0)));
840 error (_("Not implemented: computing frame "
841 "base using explicit value operator"));
842 result
= result
+ offset
;
843 result_val
= value_from_ulongest (address_type
, result
);
845 ctx
->stack_len
= before_stack_len
;
846 ctx
->location
= DWARF_VALUE_MEMORY
;
851 result_val
= dwarf_expr_fetch (ctx
, 0);
852 in_stack_memory
= dwarf_expr_fetch_in_stack_memory (ctx
, 0);
856 dwarf_expr_pop (ctx
);
861 result_val
= dwarf_expr_fetch (ctx
, offset
);
862 in_stack_memory
= dwarf_expr_fetch_in_stack_memory (ctx
, offset
);
867 struct dwarf_stack_value t1
, t2
;
869 if (ctx
->stack_len
< 2)
870 error (_("Not enough elements for "
871 "DW_OP_swap. Need 2, have %d."),
873 t1
= ctx
->stack
[ctx
->stack_len
- 1];
874 t2
= ctx
->stack
[ctx
->stack_len
- 2];
875 ctx
->stack
[ctx
->stack_len
- 1] = t2
;
876 ctx
->stack
[ctx
->stack_len
- 2] = t1
;
881 result_val
= dwarf_expr_fetch (ctx
, 1);
882 in_stack_memory
= dwarf_expr_fetch_in_stack_memory (ctx
, 1);
887 struct dwarf_stack_value t1
, t2
, t3
;
889 if (ctx
->stack_len
< 3)
890 error (_("Not enough elements for "
891 "DW_OP_rot. Need 3, have %d."),
893 t1
= ctx
->stack
[ctx
->stack_len
- 1];
894 t2
= ctx
->stack
[ctx
->stack_len
- 2];
895 t3
= ctx
->stack
[ctx
->stack_len
- 3];
896 ctx
->stack
[ctx
->stack_len
- 1] = t2
;
897 ctx
->stack
[ctx
->stack_len
- 2] = t3
;
898 ctx
->stack
[ctx
->stack_len
- 3] = t1
;
903 case DW_OP_deref_size
:
904 case DW_OP_GNU_deref_type
:
906 int addr_size
= (op
== DW_OP_deref
? ctx
->addr_size
: *op_ptr
++);
907 gdb_byte
*buf
= alloca (addr_size
);
908 CORE_ADDR addr
= dwarf_expr_fetch_address (ctx
, 0);
911 dwarf_expr_pop (ctx
);
913 if (op
== DW_OP_GNU_deref_type
)
917 op_ptr
= read_uleb128 (op_ptr
, op_end
, &type_die
);
918 type
= dwarf_get_base_type (ctx
, type_die
, 0);
923 (ctx
->funcs
->read_mem
) (ctx
->baton
, buf
, addr
, addr_size
);
925 /* If the size of the object read from memory is different
926 from the type length, we need to zero-extend it. */
927 if (TYPE_LENGTH (type
) != addr_size
)
930 extract_unsigned_integer (buf
, addr_size
, byte_order
);
932 buf
= alloca (TYPE_LENGTH (type
));
933 store_unsigned_integer (buf
, TYPE_LENGTH (type
),
937 result_val
= value_from_contents_and_address (type
, buf
, addr
);
944 case DW_OP_plus_uconst
:
946 /* Unary operations. */
947 result_val
= dwarf_expr_fetch (ctx
, 0);
948 dwarf_expr_pop (ctx
);
953 if (value_less (result_val
,
954 value_zero (value_type (result_val
), not_lval
)))
955 result_val
= value_neg (result_val
);
958 result_val
= value_neg (result_val
);
961 dwarf_require_integral (value_type (result_val
));
962 result_val
= value_complement (result_val
);
964 case DW_OP_plus_uconst
:
965 dwarf_require_integral (value_type (result_val
));
966 result
= value_as_long (result_val
);
967 op_ptr
= read_uleb128 (op_ptr
, op_end
, ®
);
969 result_val
= value_from_ulongest (address_type
, result
);
993 /* Binary operations. */
994 struct value
*first
, *second
;
996 second
= dwarf_expr_fetch (ctx
, 0);
997 dwarf_expr_pop (ctx
);
999 first
= dwarf_expr_fetch (ctx
, 0);
1000 dwarf_expr_pop (ctx
);
1002 if (! base_types_equal_p (value_type (first
), value_type (second
)))
1003 error (_("Incompatible types on DWARF stack"));
1008 dwarf_require_integral (value_type (first
));
1009 dwarf_require_integral (value_type (second
));
1010 result_val
= value_binop (first
, second
, BINOP_BITWISE_AND
);
1013 result_val
= value_binop (first
, second
, BINOP_DIV
);
1016 result_val
= value_binop (first
, second
, BINOP_SUB
);
1021 struct type
*orig_type
= value_type (first
);
1023 /* We have to special-case "old-style" untyped values
1024 -- these must have mod computed using unsigned
1026 if (orig_type
== address_type
)
1029 = get_unsigned_type (ctx
->gdbarch
, orig_type
);
1032 first
= value_cast (utype
, first
);
1033 second
= value_cast (utype
, second
);
1035 /* Note that value_binop doesn't handle float or
1036 decimal float here. This seems unimportant. */
1037 result_val
= value_binop (first
, second
, BINOP_MOD
);
1039 result_val
= value_cast (orig_type
, result_val
);
1043 result_val
= value_binop (first
, second
, BINOP_MUL
);
1046 dwarf_require_integral (value_type (first
));
1047 dwarf_require_integral (value_type (second
));
1048 result_val
= value_binop (first
, second
, BINOP_BITWISE_IOR
);
1051 result_val
= value_binop (first
, second
, BINOP_ADD
);
1054 dwarf_require_integral (value_type (first
));
1055 dwarf_require_integral (value_type (second
));
1056 result_val
= value_binop (first
, second
, BINOP_LSH
);
1059 dwarf_require_integral (value_type (first
));
1060 dwarf_require_integral (value_type (second
));
1061 if (!TYPE_UNSIGNED (value_type (first
)))
1064 = get_unsigned_type (ctx
->gdbarch
, value_type (first
));
1066 first
= value_cast (utype
, first
);
1069 result_val
= value_binop (first
, second
, BINOP_RSH
);
1070 /* Make sure we wind up with the same type we started
1072 if (value_type (result_val
) != value_type (second
))
1073 result_val
= value_cast (value_type (second
), result_val
);
1076 dwarf_require_integral (value_type (first
));
1077 dwarf_require_integral (value_type (second
));
1078 if (TYPE_UNSIGNED (value_type (first
)))
1081 = get_signed_type (ctx
->gdbarch
, value_type (first
));
1083 first
= value_cast (stype
, first
);
1086 result_val
= value_binop (first
, second
, BINOP_RSH
);
1087 /* Make sure we wind up with the same type we started
1089 if (value_type (result_val
) != value_type (second
))
1090 result_val
= value_cast (value_type (second
), result_val
);
1093 dwarf_require_integral (value_type (first
));
1094 dwarf_require_integral (value_type (second
));
1095 result_val
= value_binop (first
, second
, BINOP_BITWISE_XOR
);
1098 /* A <= B is !(B < A). */
1099 result
= ! value_less (second
, first
);
1100 result_val
= value_from_ulongest (address_type
, result
);
1103 /* A >= B is !(A < B). */
1104 result
= ! value_less (first
, second
);
1105 result_val
= value_from_ulongest (address_type
, result
);
1108 result
= value_equal (first
, second
);
1109 result_val
= value_from_ulongest (address_type
, result
);
1112 result
= value_less (first
, second
);
1113 result_val
= value_from_ulongest (address_type
, result
);
1116 /* A > B is B < A. */
1117 result
= value_less (second
, first
);
1118 result_val
= value_from_ulongest (address_type
, result
);
1121 result
= ! value_equal (first
, second
);
1122 result_val
= value_from_ulongest (address_type
, result
);
1125 internal_error (__FILE__
, __LINE__
,
1126 _("Can't be reached."));
1131 case DW_OP_call_frame_cfa
:
1132 result
= (ctx
->funcs
->get_frame_cfa
) (ctx
->baton
);
1133 result_val
= value_from_ulongest (address_type
, result
);
1134 in_stack_memory
= 1;
1137 case DW_OP_GNU_push_tls_address
:
1138 /* Variable is at a constant offset in the thread-local
1139 storage block into the objfile for the current thread and
1140 the dynamic linker module containing this expression. Here
1141 we return returns the offset from that base. The top of the
1142 stack has the offset from the beginning of the thread
1143 control block at which the variable is located. Nothing
1144 should follow this operator, so the top of stack would be
1146 result
= value_as_long (dwarf_expr_fetch (ctx
, 0));
1147 dwarf_expr_pop (ctx
);
1148 result
= (ctx
->funcs
->get_tls_address
) (ctx
->baton
, result
);
1149 result_val
= value_from_ulongest (address_type
, result
);
1153 offset
= extract_signed_integer (op_ptr
, 2, byte_order
);
1162 offset
= extract_signed_integer (op_ptr
, 2, byte_order
);
1164 val
= dwarf_expr_fetch (ctx
, 0);
1165 dwarf_require_integral (value_type (val
));
1166 if (value_as_long (val
) != 0)
1168 dwarf_expr_pop (ctx
);
1179 /* Record the piece. */
1180 op_ptr
= read_uleb128 (op_ptr
, op_end
, &size
);
1181 add_piece (ctx
, 8 * size
, 0);
1183 /* Pop off the address/regnum, and reset the location
1185 if (ctx
->location
!= DWARF_VALUE_LITERAL
1186 && ctx
->location
!= DWARF_VALUE_OPTIMIZED_OUT
)
1187 dwarf_expr_pop (ctx
);
1188 ctx
->location
= DWARF_VALUE_MEMORY
;
1192 case DW_OP_bit_piece
:
1194 ULONGEST size
, offset
;
1196 /* Record the piece. */
1197 op_ptr
= read_uleb128 (op_ptr
, op_end
, &size
);
1198 op_ptr
= read_uleb128 (op_ptr
, op_end
, &offset
);
1199 add_piece (ctx
, size
, offset
);
1201 /* Pop off the address/regnum, and reset the location
1203 if (ctx
->location
!= DWARF_VALUE_LITERAL
1204 && ctx
->location
!= DWARF_VALUE_OPTIMIZED_OUT
)
1205 dwarf_expr_pop (ctx
);
1206 ctx
->location
= DWARF_VALUE_MEMORY
;
1210 case DW_OP_GNU_uninit
:
1211 if (op_ptr
!= op_end
)
1212 error (_("DWARF-2 expression error: DW_OP_GNU_uninit must always "
1213 "be the very last op."));
1215 ctx
->initialized
= 0;
1219 result
= extract_unsigned_integer (op_ptr
, 2, byte_order
);
1221 ctx
->funcs
->dwarf_call (ctx
, result
);
1225 result
= extract_unsigned_integer (op_ptr
, 4, byte_order
);
1227 ctx
->funcs
->dwarf_call (ctx
, result
);
1230 case DW_OP_GNU_entry_value
:
1234 CORE_ADDR deref_size
;
1236 op_ptr
= read_uleb128 (op_ptr
, op_end
, &len
);
1237 if (op_ptr
+ len
> op_end
)
1238 error (_("DW_OP_GNU_entry_value: too few bytes available."));
1240 dwarf_reg
= dwarf_block_to_dwarf_reg (op_ptr
, op_ptr
+ len
);
1241 if (dwarf_reg
!= -1)
1244 ctx
->funcs
->push_dwarf_reg_entry_value (ctx
, dwarf_reg
,
1249 error (_("DWARF-2 expression error: DW_OP_GNU_entry_value is "
1250 "supported only for single DW_OP_reg*"));
1253 case DW_OP_GNU_const_type
:
1257 const gdb_byte
*data
;
1260 op_ptr
= read_uleb128 (op_ptr
, op_end
, &type_die
);
1265 type
= dwarf_get_base_type (ctx
, type_die
, n
);
1266 result_val
= value_from_contents (type
, data
);
1270 case DW_OP_GNU_regval_type
:
1275 op_ptr
= read_uleb128 (op_ptr
, op_end
, ®
);
1276 op_ptr
= read_uleb128 (op_ptr
, op_end
, &type_die
);
1278 type
= dwarf_get_base_type (ctx
, type_die
, 0);
1279 result
= (ctx
->funcs
->read_reg
) (ctx
->baton
, reg
);
1280 result_val
= value_from_ulongest (address_type
, result
);
1281 result_val
= value_from_contents (type
,
1282 value_contents_all (result_val
));
1286 case DW_OP_GNU_convert
:
1287 case DW_OP_GNU_reinterpret
:
1292 op_ptr
= read_uleb128 (op_ptr
, op_end
, &type_die
);
1295 type
= address_type
;
1297 type
= dwarf_get_base_type (ctx
, type_die
, 0);
1299 result_val
= dwarf_expr_fetch (ctx
, 0);
1300 dwarf_expr_pop (ctx
);
1302 if (op
== DW_OP_GNU_convert
)
1303 result_val
= value_cast (type
, result_val
);
1304 else if (type
== value_type (result_val
))
1308 else if (TYPE_LENGTH (type
)
1309 != TYPE_LENGTH (value_type (result_val
)))
1310 error (_("DW_OP_GNU_reinterpret has wrong size"));
1313 = value_from_contents (type
,
1314 value_contents_all (result_val
));
1319 error (_("Unhandled dwarf expression opcode 0x%x"), op
);
1322 /* Most things push a result value. */
1323 gdb_assert (result_val
!= NULL
);
1324 dwarf_expr_push (ctx
, result_val
, in_stack_memory
);
1329 /* To simplify our main caller, if the result is an implicit
1330 pointer, then make a pieced value. This is ok because we can't
1331 have implicit pointers in contexts where pieces are invalid. */
1332 if (ctx
->location
== DWARF_VALUE_IMPLICIT_POINTER
)
1333 add_piece (ctx
, 8 * ctx
->addr_size
, 0);
1336 ctx
->recursion_depth
--;
1337 gdb_assert (ctx
->recursion_depth
>= 0);
1340 /* Stub dwarf_expr_context_funcs.read_reg implementation. */
1343 ctx_no_read_reg (void *baton
, int regnum
)
1345 error (_("Registers access is invalid in this context"));
1348 /* Stub dwarf_expr_context_funcs.get_frame_base implementation. */
1351 ctx_no_get_frame_base (void *baton
, const gdb_byte
**start
, size_t *length
)
1353 error (_("%s is invalid in this context"), "DW_OP_fbreg");
1356 /* Stub dwarf_expr_context_funcs.get_frame_cfa implementation. */
1359 ctx_no_get_frame_cfa (void *baton
)
1361 error (_("%s is invalid in this context"), "DW_OP_call_frame_cfa");
1364 /* Stub dwarf_expr_context_funcs.get_frame_pc implementation. */
1367 ctx_no_get_frame_pc (void *baton
)
1369 error (_("%s is invalid in this context"), "DW_OP_GNU_implicit_pointer");
1372 /* Stub dwarf_expr_context_funcs.get_tls_address implementation. */
1375 ctx_no_get_tls_address (void *baton
, CORE_ADDR offset
)
1377 error (_("%s is invalid in this context"), "DW_OP_GNU_push_tls_address");
1380 /* Stub dwarf_expr_context_funcs.dwarf_call implementation. */
1383 ctx_no_dwarf_call (struct dwarf_expr_context
*ctx
, size_t die_offset
)
1385 error (_("%s is invalid in this context"), "DW_OP_call*");
1388 /* Stub dwarf_expr_context_funcs.get_base_type implementation. */
1391 ctx_no_get_base_type (struct dwarf_expr_context
*ctx
, size_t die
)
1393 error (_("Support for typed DWARF is not supported in this context"));
1396 /* Stub dwarf_expr_context_funcs.push_dwarf_block_entry_value
1400 ctx_no_push_dwarf_reg_entry_value (struct dwarf_expr_context
*ctx
,
1401 int dwarf_reg
, CORE_ADDR fb_offset
)
1403 internal_error (__FILE__
, __LINE__
,
1404 _("Support for DW_OP_GNU_entry_value is unimplemented"));
1408 _initialize_dwarf2expr (void)
1411 = gdbarch_data_register_post_init (dwarf_gdbarch_types_init
);