1 /* DWARF 2 Expression Evaluator.
3 Copyright (C) 2001, 2002, 2003, 2005, 2007, 2008, 2009
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 gdb_byte *, 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;
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 * sizeof (CORE_ADDR));
48 retval->num_pieces = 0;
50 retval->max_recursion_depth = 0x100;
54 /* Release the memory allocated to CTX. */
57 free_dwarf_expr_context (struct dwarf_expr_context *ctx)
64 /* Helper for make_cleanup_free_dwarf_expr_context. */
67 free_dwarf_expr_context_cleanup (void *arg)
69 free_dwarf_expr_context (arg);
72 /* Return a cleanup that calls free_dwarf_expr_context. */
75 make_cleanup_free_dwarf_expr_context (struct dwarf_expr_context *ctx)
77 return make_cleanup (free_dwarf_expr_context_cleanup, ctx);
80 /* Expand the memory allocated to CTX's stack to contain at least
81 NEED more elements than are currently used. */
84 dwarf_expr_grow_stack (struct dwarf_expr_context *ctx, size_t need)
86 if (ctx->stack_len + need > ctx->stack_allocated)
88 size_t newlen = ctx->stack_len + need + 10;
89 ctx->stack = xrealloc (ctx->stack,
90 newlen * sizeof (CORE_ADDR));
91 ctx->stack_allocated = newlen;
95 /* Push VALUE onto CTX's stack. */
98 dwarf_expr_push (struct dwarf_expr_context *ctx, CORE_ADDR value)
100 dwarf_expr_grow_stack (ctx, 1);
101 ctx->stack[ctx->stack_len++] = value;
104 /* Pop the top item off of CTX's stack. */
107 dwarf_expr_pop (struct dwarf_expr_context *ctx)
109 if (ctx->stack_len <= 0)
110 error (_("dwarf expression stack underflow"));
114 /* Retrieve the N'th item on CTX's stack. */
117 dwarf_expr_fetch (struct dwarf_expr_context *ctx, int n)
119 if (ctx->stack_len <= n)
120 error (_("Asked for position %d of stack, stack only has %d elements on it."),
122 return ctx->stack[ctx->stack_len - (1 + n)];
126 /* Add a new piece to CTX's piece list. */
128 add_piece (struct dwarf_expr_context *ctx, ULONGEST size)
130 struct dwarf_expr_piece *p;
135 ctx->pieces = xrealloc (ctx->pieces,
137 * sizeof (struct dwarf_expr_piece)));
139 ctx->pieces = xmalloc (ctx->num_pieces
140 * sizeof (struct dwarf_expr_piece));
142 p = &ctx->pieces[ctx->num_pieces - 1];
143 p->location = ctx->location;
145 if (p->location == DWARF_VALUE_LITERAL)
147 p->v.literal.data = ctx->data;
148 p->v.literal.length = ctx->len;
151 p->v.value = dwarf_expr_fetch (ctx, 0);
154 /* Evaluate the expression at ADDR (LEN bytes long) using the context
158 dwarf_expr_eval (struct dwarf_expr_context *ctx, gdb_byte *addr, size_t len)
160 int old_recursion_depth = ctx->recursion_depth;
162 execute_stack_op (ctx, addr, addr + len);
164 /* CTX RECURSION_DEPTH becomes invalid if an exception was thrown here. */
166 gdb_assert (ctx->recursion_depth == old_recursion_depth);
169 /* Decode the unsigned LEB128 constant at BUF into the variable pointed to
170 by R, and return the new value of BUF. Verify that it doesn't extend
174 read_uleb128 (gdb_byte *buf, gdb_byte *buf_end, ULONGEST * r)
183 error (_("read_uleb128: Corrupted DWARF expression."));
186 result |= (byte & 0x7f) << shift;
187 if ((byte & 0x80) == 0)
195 /* Decode the signed LEB128 constant at BUF into the variable pointed to
196 by R, and return the new value of BUF. Verify that it doesn't extend
200 read_sleb128 (gdb_byte *buf, gdb_byte *buf_end, LONGEST * r)
209 error (_("read_sleb128: Corrupted DWARF expression."));
212 result |= (byte & 0x7f) << shift;
214 if ((byte & 0x80) == 0)
217 if (shift < (sizeof (*r) * 8) && (byte & 0x40) != 0)
218 result |= -(1 << shift);
224 /* Read an address of size ADDR_SIZE from BUF, and verify that it
225 doesn't extend past BUF_END. */
228 dwarf2_read_address (struct gdbarch *gdbarch, gdb_byte *buf,
229 gdb_byte *buf_end, int addr_size)
231 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
234 if (buf_end - buf < addr_size)
235 error (_("dwarf2_read_address: Corrupted DWARF expression."));
237 /* For most architectures, calling extract_unsigned_integer() alone
238 is sufficient for extracting an address. However, some
239 architectures (e.g. MIPS) use signed addresses and using
240 extract_unsigned_integer() will not produce a correct
241 result. Make sure we invoke gdbarch_integer_to_address()
242 for those architectures which require it.
244 The use of `unsigned_address_type' in the code below refers to
245 the type of buf and has no bearing on the signedness of the
246 address being returned. */
248 if (gdbarch_integer_to_address_p (gdbarch))
249 return gdbarch_integer_to_address
250 (gdbarch, unsigned_address_type (gdbarch, addr_size), buf);
252 return extract_unsigned_integer (buf, addr_size, byte_order);
255 /* Return the type of an address of size ADDR_SIZE,
256 for unsigned arithmetic. */
259 unsigned_address_type (struct gdbarch *gdbarch, int addr_size)
264 return builtin_type (gdbarch)->builtin_uint16;
266 return builtin_type (gdbarch)->builtin_uint32;
268 return builtin_type (gdbarch)->builtin_uint64;
270 internal_error (__FILE__, __LINE__,
271 _("Unsupported address size.\n"));
275 /* Return the type of an address of size ADDR_SIZE,
276 for signed arithmetic. */
279 signed_address_type (struct gdbarch *gdbarch, int addr_size)
284 return builtin_type (gdbarch)->builtin_int16;
286 return builtin_type (gdbarch)->builtin_int32;
288 return builtin_type (gdbarch)->builtin_int64;
290 internal_error (__FILE__, __LINE__,
291 _("Unsupported address size.\n"));
296 /* Check that the current operator is either at the end of an
297 expression, or that it is followed by a composition operator. */
300 require_composition (gdb_byte *op_ptr, gdb_byte *op_end, const char *op_name)
302 /* It seems like DW_OP_GNU_uninit should be handled here. However,
303 it doesn't seem to make sense for DW_OP_*_value, and it was not
304 checked at the other place that this function is called. */
305 if (op_ptr != op_end && *op_ptr != DW_OP_piece && *op_ptr != DW_OP_bit_piece)
306 error (_("DWARF-2 expression error: `%s' operations must be "
307 "used either alone or in conjuction with DW_OP_piece "
308 "or DW_OP_bit_piece."),
312 /* The engine for the expression evaluator. Using the context in CTX,
313 evaluate the expression between OP_PTR and OP_END. */
316 execute_stack_op (struct dwarf_expr_context *ctx,
317 gdb_byte *op_ptr, gdb_byte *op_end)
319 enum bfd_endian byte_order = gdbarch_byte_order (ctx->gdbarch);
320 ctx->location = DWARF_VALUE_MEMORY;
321 ctx->initialized = 1; /* Default is initialized. */
323 if (ctx->recursion_depth > ctx->max_recursion_depth)
324 error (_("DWARF-2 expression error: Loop detected (%d)."),
325 ctx->recursion_depth);
326 ctx->recursion_depth++;
328 while (op_ptr < op_end)
330 enum dwarf_location_atom op = *op_ptr++;
332 ULONGEST uoffset, reg;
369 result = op - DW_OP_lit0;
373 result = dwarf2_read_address (ctx->gdbarch,
374 op_ptr, op_end, ctx->addr_size);
375 op_ptr += ctx->addr_size;
379 result = extract_unsigned_integer (op_ptr, 1, byte_order);
383 result = extract_signed_integer (op_ptr, 1, byte_order);
387 result = extract_unsigned_integer (op_ptr, 2, byte_order);
391 result = extract_signed_integer (op_ptr, 2, byte_order);
395 result = extract_unsigned_integer (op_ptr, 4, byte_order);
399 result = extract_signed_integer (op_ptr, 4, byte_order);
403 result = extract_unsigned_integer (op_ptr, 8, byte_order);
407 result = extract_signed_integer (op_ptr, 8, byte_order);
411 op_ptr = read_uleb128 (op_ptr, op_end, &uoffset);
415 op_ptr = read_sleb128 (op_ptr, op_end, &offset);
419 /* The DW_OP_reg operations are required to occur alone in
420 location expressions. */
454 && *op_ptr != DW_OP_piece
455 && *op_ptr != DW_OP_GNU_uninit)
456 error (_("DWARF-2 expression error: DW_OP_reg operations must be "
457 "used either alone or in conjuction with DW_OP_piece."));
459 result = op - DW_OP_reg0;
460 ctx->location = DWARF_VALUE_REGISTER;
464 op_ptr = read_uleb128 (op_ptr, op_end, ®);
465 require_composition (op_ptr, op_end, "DW_OP_regx");
468 ctx->location = DWARF_VALUE_REGISTER;
471 case DW_OP_implicit_value:
474 op_ptr = read_uleb128 (op_ptr, op_end, &len);
475 if (op_ptr + len > op_end)
476 error (_("DW_OP_implicit_value: too few bytes available."));
479 ctx->location = DWARF_VALUE_LITERAL;
481 require_composition (op_ptr, op_end, "DW_OP_implicit_value");
485 case DW_OP_stack_value:
486 ctx->location = DWARF_VALUE_STACK;
487 require_composition (op_ptr, op_end, "DW_OP_stack_value");
523 op_ptr = read_sleb128 (op_ptr, op_end, &offset);
524 result = (ctx->read_reg) (ctx->baton, op - DW_OP_breg0);
530 op_ptr = read_uleb128 (op_ptr, op_end, ®);
531 op_ptr = read_sleb128 (op_ptr, op_end, &offset);
532 result = (ctx->read_reg) (ctx->baton, reg);
540 unsigned int before_stack_len;
542 op_ptr = read_sleb128 (op_ptr, op_end, &offset);
543 /* Rather than create a whole new context, we simply
544 record the stack length before execution, then reset it
545 afterwards, effectively erasing whatever the recursive
547 before_stack_len = ctx->stack_len;
548 /* FIXME: cagney/2003-03-26: This code should be using
549 get_frame_base_address(), and then implement a dwarf2
550 specific this_base method. */
551 (ctx->get_frame_base) (ctx->baton, &datastart, &datalen);
552 dwarf_expr_eval (ctx, datastart, datalen);
553 if (ctx->location == DWARF_VALUE_LITERAL
554 || ctx->location == DWARF_VALUE_STACK)
555 error (_("Not implemented: computing frame base using explicit value operator"));
556 result = dwarf_expr_fetch (ctx, 0);
557 if (ctx->location == DWARF_VALUE_REGISTER)
558 result = (ctx->read_reg) (ctx->baton, result);
559 result = result + offset;
560 ctx->stack_len = before_stack_len;
561 ctx->location = DWARF_VALUE_MEMORY;
565 result = dwarf_expr_fetch (ctx, 0);
569 dwarf_expr_pop (ctx);
574 result = dwarf_expr_fetch (ctx, offset);
581 if (ctx->stack_len < 2)
582 error (_("Not enough elements for DW_OP_swap. Need 2, have %d."),
584 t1 = ctx->stack[ctx->stack_len - 1];
585 t2 = ctx->stack[ctx->stack_len - 2];
586 ctx->stack[ctx->stack_len - 1] = t2;
587 ctx->stack[ctx->stack_len - 2] = t1;
592 result = dwarf_expr_fetch (ctx, 1);
597 CORE_ADDR t1, t2, t3;
599 if (ctx->stack_len < 3)
600 error (_("Not enough elements for DW_OP_rot. Need 3, have %d."),
602 t1 = ctx->stack[ctx->stack_len - 1];
603 t2 = ctx->stack[ctx->stack_len - 2];
604 t3 = ctx->stack[ctx->stack_len - 3];
605 ctx->stack[ctx->stack_len - 1] = t2;
606 ctx->stack[ctx->stack_len - 2] = t3;
607 ctx->stack[ctx->stack_len - 3] = t1;
612 case DW_OP_deref_size:
616 case DW_OP_plus_uconst:
617 /* Unary operations. */
618 result = dwarf_expr_fetch (ctx, 0);
619 dwarf_expr_pop (ctx);
625 gdb_byte *buf = alloca (ctx->addr_size);
626 (ctx->read_mem) (ctx->baton, buf, result, ctx->addr_size);
627 result = dwarf2_read_address (ctx->gdbarch,
628 buf, buf + ctx->addr_size,
633 case DW_OP_deref_size:
635 int addr_size = *op_ptr++;
636 gdb_byte *buf = alloca (addr_size);
637 (ctx->read_mem) (ctx->baton, buf, result, addr_size);
638 result = dwarf2_read_address (ctx->gdbarch,
639 buf, buf + addr_size,
645 if ((signed int) result < 0)
654 case DW_OP_plus_uconst:
655 op_ptr = read_uleb128 (op_ptr, op_end, ®);
679 /* Binary operations. Use the value engine to do computations in
681 CORE_ADDR first, second;
682 enum exp_opcode binop;
683 struct value *val1, *val2;
684 struct type *stype, *utype;
686 second = dwarf_expr_fetch (ctx, 0);
687 dwarf_expr_pop (ctx);
689 first = dwarf_expr_fetch (ctx, 0);
690 dwarf_expr_pop (ctx);
692 utype = unsigned_address_type (ctx->gdbarch, ctx->addr_size);
693 stype = signed_address_type (ctx->gdbarch, ctx->addr_size);
694 val1 = value_from_longest (utype, first);
695 val2 = value_from_longest (utype, second);
700 binop = BINOP_BITWISE_AND;
715 binop = BINOP_BITWISE_IOR;
728 val1 = value_from_longest (stype, first);
731 binop = BINOP_BITWISE_XOR;
749 binop = BINOP_NOTEQUAL;
752 internal_error (__FILE__, __LINE__,
753 _("Can't be reached."));
755 result = value_as_long (value_binop (val1, val2, binop));
759 case DW_OP_call_frame_cfa:
760 result = (ctx->get_frame_cfa) (ctx->baton);
763 case DW_OP_GNU_push_tls_address:
764 /* Variable is at a constant offset in the thread-local
765 storage block into the objfile for the current thread and
766 the dynamic linker module containing this expression. Here
767 we return returns the offset from that base. The top of the
768 stack has the offset from the beginning of the thread
769 control block at which the variable is located. Nothing
770 should follow this operator, so the top of stack would be
772 result = dwarf_expr_fetch (ctx, 0);
773 dwarf_expr_pop (ctx);
774 result = (ctx->get_tls_address) (ctx->baton, result);
778 offset = extract_signed_integer (op_ptr, 2, byte_order);
784 offset = extract_signed_integer (op_ptr, 2, byte_order);
786 if (dwarf_expr_fetch (ctx, 0) != 0)
788 dwarf_expr_pop (ctx);
798 /* Record the piece. */
799 op_ptr = read_uleb128 (op_ptr, op_end, &size);
800 add_piece (ctx, size);
802 /* Pop off the address/regnum, and reset the location
804 if (ctx->location != DWARF_VALUE_LITERAL)
805 dwarf_expr_pop (ctx);
806 ctx->location = DWARF_VALUE_MEMORY;
810 case DW_OP_GNU_uninit:
811 if (op_ptr != op_end)
812 error (_("DWARF-2 expression error: DW_OP_GNU_uninit must always "
813 "be the very last op."));
815 ctx->initialized = 0;
819 error (_("Unhandled dwarf expression opcode 0x%x"), op);
822 /* Most things push a result value. */
823 dwarf_expr_push (ctx, result);
827 ctx->recursion_depth--;
828 gdb_assert (ctx->recursion_depth >= 0);