1 /* Dwarf2 Expression Evaluator
2 Copyright 2001, 2002, 2003 Free Software Foundation, Inc.
3 Contributed by Daniel Berlin (dan@dberlin.org)
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
27 #include "elf/dwarf2.h"
28 #include "dwarf2expr.h"
30 /* Local prototypes. */
32 static void execute_stack_op (struct dwarf_expr_context *,
33 unsigned char *, unsigned char *);
35 /* Create a new context for the expression evaluator. */
37 struct dwarf_expr_context *
38 new_dwarf_expr_context (void)
40 struct dwarf_expr_context *retval;
41 retval = xcalloc (1, sizeof (struct dwarf_expr_context));
42 retval->stack_len = 0;
43 retval->stack_allocated = 10;
44 retval->stack = xmalloc (retval->stack_allocated * sizeof (CORE_ADDR));
45 retval->num_pieces = 0;
50 /* Release the memory allocated to CTX. */
53 free_dwarf_expr_context (struct dwarf_expr_context *ctx)
60 /* Expand the memory allocated to CTX's stack to contain at least
61 NEED more elements than are currently used. */
64 dwarf_expr_grow_stack (struct dwarf_expr_context *ctx, size_t need)
66 if (ctx->stack_len + need > ctx->stack_allocated)
68 size_t newlen = ctx->stack_len + need + 10;
69 ctx->stack = xrealloc (ctx->stack,
70 newlen * sizeof (CORE_ADDR));
71 ctx->stack_allocated = newlen;
75 /* Push VALUE onto CTX's stack. */
78 dwarf_expr_push (struct dwarf_expr_context *ctx, CORE_ADDR value)
80 dwarf_expr_grow_stack (ctx, 1);
81 ctx->stack[ctx->stack_len++] = value;
84 /* Pop the top item off of CTX's stack. */
87 dwarf_expr_pop (struct dwarf_expr_context *ctx)
89 if (ctx->stack_len <= 0)
90 error ("dwarf expression stack underflow");
94 /* Retrieve the N'th item on CTX's stack. */
97 dwarf_expr_fetch (struct dwarf_expr_context *ctx, int n)
99 if (ctx->stack_len < n)
100 error ("Asked for position %d of stack, stack only has %d elements on it\n",
102 return ctx->stack[ctx->stack_len - (1 + n)];
106 /* Add a new piece to CTX's piece list. */
108 add_piece (struct dwarf_expr_context *ctx,
109 int in_reg, CORE_ADDR value, ULONGEST size)
111 struct dwarf_expr_piece *p;
116 ctx->pieces = xrealloc (ctx->pieces,
118 * sizeof (struct dwarf_expr_piece)));
120 ctx->pieces = xmalloc (ctx->num_pieces
121 * sizeof (struct dwarf_expr_piece));
123 p = &ctx->pieces[ctx->num_pieces - 1];
129 /* Evaluate the expression at ADDR (LEN bytes long) using the context
133 dwarf_expr_eval (struct dwarf_expr_context *ctx, unsigned char *addr,
136 execute_stack_op (ctx, addr, addr + len);
139 /* Decode the unsigned LEB128 constant at BUF into the variable pointed to
140 by R, and return the new value of BUF. Verify that it doesn't extend
144 read_uleb128 (unsigned char *buf, unsigned char *buf_end, ULONGEST * r)
153 error ("read_uleb128: Corrupted DWARF expression.");
156 result |= (byte & 0x7f) << shift;
157 if ((byte & 0x80) == 0)
165 /* Decode the signed LEB128 constant at BUF into the variable pointed to
166 by R, and return the new value of BUF. Verify that it doesn't extend
170 read_sleb128 (unsigned char *buf, unsigned char *buf_end, LONGEST * r)
179 error ("read_sleb128: Corrupted DWARF expression.");
182 result |= (byte & 0x7f) << shift;
184 if ((byte & 0x80) == 0)
187 if (shift < (sizeof (*r) * 8) && (byte & 0x40) != 0)
188 result |= -(1 << shift);
194 /* Read an address from BUF, and verify that it doesn't extend past
195 BUF_END. The address is returned, and *BYTES_READ is set to the
196 number of bytes read from BUF. */
199 dwarf2_read_address (unsigned char *buf, unsigned char *buf_end, int *bytes_read)
203 if (buf_end - buf < TARGET_ADDR_BIT / TARGET_CHAR_BIT)
204 error ("dwarf2_read_address: Corrupted DWARF expression.");
206 *bytes_read = TARGET_ADDR_BIT / TARGET_CHAR_BIT;
207 /* NOTE: cagney/2003-05-22: This extract is assuming that a DWARF 2
208 address is always unsigned. That may or may not be true. */
209 result = extract_unsigned_integer (buf, TARGET_ADDR_BIT / TARGET_CHAR_BIT);
213 /* Return the type of an address, for unsigned arithmetic. */
216 unsigned_address_type (void)
218 switch (TARGET_ADDR_BIT / TARGET_CHAR_BIT)
221 return builtin_type_uint16;
223 return builtin_type_uint32;
225 return builtin_type_uint64;
227 internal_error (__FILE__, __LINE__,
228 "Unsupported address size.\n");
232 /* Return the type of an address, for signed arithmetic. */
235 signed_address_type (void)
237 switch (TARGET_ADDR_BIT / TARGET_CHAR_BIT)
240 return builtin_type_int16;
242 return builtin_type_int32;
244 return builtin_type_int64;
246 internal_error (__FILE__, __LINE__,
247 "Unsupported address size.\n");
251 /* The engine for the expression evaluator. Using the context in CTX,
252 evaluate the expression between OP_PTR and OP_END. */
255 execute_stack_op (struct dwarf_expr_context *ctx, unsigned char *op_ptr,
256 unsigned char *op_end)
259 ctx->initialized = 1; /* Default is initialized. */
261 while (op_ptr < op_end)
263 enum dwarf_location_atom op = *op_ptr++;
265 ULONGEST uoffset, reg;
303 result = op - DW_OP_lit0;
307 result = dwarf2_read_address (op_ptr, op_end, &bytes_read);
308 op_ptr += bytes_read;
312 result = extract_unsigned_integer (op_ptr, 1);
316 result = extract_signed_integer (op_ptr, 1);
320 result = extract_unsigned_integer (op_ptr, 2);
324 result = extract_signed_integer (op_ptr, 2);
328 result = extract_unsigned_integer (op_ptr, 4);
332 result = extract_signed_integer (op_ptr, 4);
336 result = extract_unsigned_integer (op_ptr, 8);
340 result = extract_signed_integer (op_ptr, 8);
344 op_ptr = read_uleb128 (op_ptr, op_end, &uoffset);
348 op_ptr = read_sleb128 (op_ptr, op_end, &offset);
352 /* The DW_OP_reg operations are required to occur alone in
353 location expressions. */
387 && *op_ptr != DW_OP_piece
388 && *op_ptr != DW_OP_bit_piece
389 && *op_ptr != DW_OP_GNU_uninit)
390 error (_("DWARF-2 expression error: DW_OP_reg operations must be "
391 "used either alone or in conjuction with DW_OP_piece."));
393 result = op - DW_OP_reg0;
399 op_ptr = read_uleb128 (op_ptr, op_end, ®);
400 if (op_ptr != op_end && *op_ptr != DW_OP_piece)
401 error ("DWARF-2 expression error: DW_OP_reg operations must be "
402 "used either alone or in conjuction with DW_OP_piece.");
441 op_ptr = read_sleb128 (op_ptr, op_end, &offset);
442 result = (ctx->read_reg) (ctx->baton, op - DW_OP_breg0);
448 op_ptr = read_uleb128 (op_ptr, op_end, ®);
449 op_ptr = read_sleb128 (op_ptr, op_end, &offset);
450 result = (ctx->read_reg) (ctx->baton, reg);
456 unsigned char *datastart;
458 unsigned int before_stack_len;
460 op_ptr = read_sleb128 (op_ptr, op_end, &offset);
461 /* Rather than create a whole new context, we simply
462 record the stack length before execution, then reset it
463 afterwards, effectively erasing whatever the recursive
465 before_stack_len = ctx->stack_len;
466 /* FIXME: cagney/2003-03-26: This code should be using
467 get_frame_base_address(), and then implement a dwarf2
468 specific this_base method. */
469 (ctx->get_frame_base) (ctx->baton, &datastart, &datalen);
470 dwarf_expr_eval (ctx, datastart, datalen);
471 result = dwarf_expr_fetch (ctx, 0);
473 result = (ctx->read_reg) (ctx->baton, result);
474 result = result + offset;
475 ctx->stack_len = before_stack_len;
480 result = dwarf_expr_fetch (ctx, 0);
484 dwarf_expr_pop (ctx);
489 result = dwarf_expr_fetch (ctx, offset);
493 result = dwarf_expr_fetch (ctx, 1);
498 CORE_ADDR t1, t2, t3;
500 if (ctx->stack_len < 3)
501 error ("Not enough elements for DW_OP_rot. Need 3, have %d\n",
503 t1 = ctx->stack[ctx->stack_len - 1];
504 t2 = ctx->stack[ctx->stack_len - 2];
505 t3 = ctx->stack[ctx->stack_len - 3];
506 ctx->stack[ctx->stack_len - 1] = t2;
507 ctx->stack[ctx->stack_len - 2] = t3;
508 ctx->stack[ctx->stack_len - 3] = t1;
513 case DW_OP_deref_size:
517 case DW_OP_plus_uconst:
518 /* Unary operations. */
519 result = dwarf_expr_fetch (ctx, 0);
520 dwarf_expr_pop (ctx);
526 char *buf = alloca (TARGET_ADDR_BIT / TARGET_CHAR_BIT);
529 (ctx->read_mem) (ctx->baton, buf, result,
530 TARGET_ADDR_BIT / TARGET_CHAR_BIT);
531 result = dwarf2_read_address (buf,
532 buf + (TARGET_ADDR_BIT
538 case DW_OP_deref_size:
540 char *buf = alloca (TARGET_ADDR_BIT / TARGET_CHAR_BIT);
543 (ctx->read_mem) (ctx->baton, buf, result, *op_ptr++);
544 result = dwarf2_read_address (buf,
545 buf + (TARGET_ADDR_BIT
552 if ((signed int) result < 0)
561 case DW_OP_plus_uconst:
562 op_ptr = read_uleb128 (op_ptr, op_end, ®);
586 /* Binary operations. Use the value engine to do computations in
588 CORE_ADDR first, second;
589 enum exp_opcode binop;
590 struct value *val1, *val2;
592 second = dwarf_expr_fetch (ctx, 0);
593 dwarf_expr_pop (ctx);
595 first = dwarf_expr_fetch (ctx, 0);
596 dwarf_expr_pop (ctx);
598 val1 = value_from_longest (unsigned_address_type (), first);
599 val2 = value_from_longest (unsigned_address_type (), second);
604 binop = BINOP_BITWISE_AND;
619 binop = BINOP_BITWISE_IOR;
632 val1 = value_from_longest (signed_address_type (), first);
635 binop = BINOP_BITWISE_XOR;
653 binop = BINOP_NOTEQUAL;
656 internal_error (__FILE__, __LINE__,
657 "Can't be reached.");
659 result = value_as_long (value_binop (val1, val2, binop));
663 case DW_OP_GNU_push_tls_address:
664 /* Variable is at a constant offset in the thread-local
665 storage block into the objfile for the current thread and
666 the dynamic linker module containing this expression. Here
667 we return returns the offset from that base. The top of the
668 stack has the offset from the beginning of the thread
669 control block at which the variable is located. Nothing
670 should follow this operator, so the top of stack would be
672 result = dwarf_expr_fetch (ctx, 0);
673 dwarf_expr_pop (ctx);
674 result = (ctx->get_tls_address) (ctx->baton, result);
678 offset = extract_signed_integer (op_ptr, 2);
684 offset = extract_signed_integer (op_ptr, 2);
686 if (dwarf_expr_fetch (ctx, 0) != 0)
688 dwarf_expr_pop (ctx);
697 CORE_ADDR addr_or_regnum;
699 /* Record the piece. */
700 op_ptr = read_uleb128 (op_ptr, op_end, &size);
701 addr_or_regnum = dwarf_expr_fetch (ctx, 0);
702 add_piece (ctx, ctx->in_reg, addr_or_regnum, size);
704 /* Pop off the address/regnum, and clear the in_reg flag. */
705 dwarf_expr_pop (ctx);
710 case DW_OP_GNU_uninit:
711 if (op_ptr != op_end)
712 error (_("DWARF-2 expression error: DW_OP_GNU_unint must always "
713 "be the very last op."));
715 ctx->initialized = 0;
719 error ("Unhandled dwarf expression opcode 0x%x", op);
722 /* Most things push a result value. */
723 dwarf_expr_push (ctx, result);