1 /* Dwarf2 Expression Evaluator
2 Copyright 2001, 2002, 2003 Free Software Foundation, Inc.
3 Contributed by Daniel Berlin ([email protected])
4
5 This file is part of GDB.
6
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.
11
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.
16
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. */
21
22 #include "defs.h"
23 #include "symtab.h"
24 #include "gdbtypes.h"
25 #include "value.h"
26 #include "gdbcore.h"
27 #include "elf/dwarf2.h"
28 #include "dwarf2expr.h"
29
30 /* Local prototypes. */
31
32 static void execute_stack_op (struct dwarf_expr_context *,
33 unsigned char *, unsigned char *);
34
35 /* Create a new context for the expression evaluator. */
36
37 struct dwarf_expr_context *
new_dwarf_expr_context(void)38 new_dwarf_expr_context (void)
39 {
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;
46 retval->pieces = 0;
47 return retval;
48 }
49
50 /* Release the memory allocated to CTX. */
51
52 void
free_dwarf_expr_context(struct dwarf_expr_context * ctx)53 free_dwarf_expr_context (struct dwarf_expr_context *ctx)
54 {
55 xfree (ctx->stack);
56 xfree (ctx->pieces);
57 xfree (ctx);
58 }
59
60 /* Expand the memory allocated to CTX's stack to contain at least
61 NEED more elements than are currently used. */
62
63 static void
dwarf_expr_grow_stack(struct dwarf_expr_context * ctx,size_t need)64 dwarf_expr_grow_stack (struct dwarf_expr_context *ctx, size_t need)
65 {
66 if (ctx->stack_len + need > ctx->stack_allocated)
67 {
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;
72 }
73 }
74
75 /* Push VALUE onto CTX's stack. */
76
77 void
dwarf_expr_push(struct dwarf_expr_context * ctx,CORE_ADDR value)78 dwarf_expr_push (struct dwarf_expr_context *ctx, CORE_ADDR value)
79 {
80 dwarf_expr_grow_stack (ctx, 1);
81 ctx->stack[ctx->stack_len++] = value;
82 }
83
84 /* Pop the top item off of CTX's stack. */
85
86 void
dwarf_expr_pop(struct dwarf_expr_context * ctx)87 dwarf_expr_pop (struct dwarf_expr_context *ctx)
88 {
89 if (ctx->stack_len <= 0)
90 error ("dwarf expression stack underflow");
91 ctx->stack_len--;
92 }
93
94 /* Retrieve the N'th item on CTX's stack. */
95
96 CORE_ADDR
dwarf_expr_fetch(struct dwarf_expr_context * ctx,int n)97 dwarf_expr_fetch (struct dwarf_expr_context *ctx, int n)
98 {
99 if (ctx->stack_len < n)
100 error ("Asked for position %d of stack, stack only has %d elements on it\n",
101 n, ctx->stack_len);
102 return ctx->stack[ctx->stack_len - (1 + n)];
103
104 }
105
106 /* Add a new piece to CTX's piece list. */
107 static void
add_piece(struct dwarf_expr_context * ctx,int in_reg,CORE_ADDR value,ULONGEST size)108 add_piece (struct dwarf_expr_context *ctx,
109 int in_reg, CORE_ADDR value, ULONGEST size)
110 {
111 struct dwarf_expr_piece *p;
112
113 ctx->num_pieces++;
114
115 if (ctx->pieces)
116 ctx->pieces = xrealloc (ctx->pieces,
117 (ctx->num_pieces
118 * sizeof (struct dwarf_expr_piece)));
119 else
120 ctx->pieces = xmalloc (ctx->num_pieces
121 * sizeof (struct dwarf_expr_piece));
122
123 p = &ctx->pieces[ctx->num_pieces - 1];
124 p->in_reg = in_reg;
125 p->value = value;
126 p->size = size;
127 }
128
129 /* Evaluate the expression at ADDR (LEN bytes long) using the context
130 CTX. */
131
132 void
dwarf_expr_eval(struct dwarf_expr_context * ctx,unsigned char * addr,size_t len)133 dwarf_expr_eval (struct dwarf_expr_context *ctx, unsigned char *addr,
134 size_t len)
135 {
136 execute_stack_op (ctx, addr, addr + len);
137 }
138
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
141 past BUF_END. */
142
143 unsigned char *
read_uleb128(unsigned char * buf,unsigned char * buf_end,ULONGEST * r)144 read_uleb128 (unsigned char *buf, unsigned char *buf_end, ULONGEST * r)
145 {
146 unsigned shift = 0;
147 ULONGEST result = 0;
148 unsigned char byte;
149
150 while (1)
151 {
152 if (buf >= buf_end)
153 error ("read_uleb128: Corrupted DWARF expression.");
154
155 byte = *buf++;
156 result |= (byte & 0x7f) << shift;
157 if ((byte & 0x80) == 0)
158 break;
159 shift += 7;
160 }
161 *r = result;
162 return buf;
163 }
164
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
167 past BUF_END. */
168
169 unsigned char *
read_sleb128(unsigned char * buf,unsigned char * buf_end,LONGEST * r)170 read_sleb128 (unsigned char *buf, unsigned char *buf_end, LONGEST * r)
171 {
172 unsigned shift = 0;
173 LONGEST result = 0;
174 unsigned char byte;
175
176 while (1)
177 {
178 if (buf >= buf_end)
179 error ("read_sleb128: Corrupted DWARF expression.");
180
181 byte = *buf++;
182 result |= (byte & 0x7f) << shift;
183 shift += 7;
184 if ((byte & 0x80) == 0)
185 break;
186 }
187 if (shift < (sizeof (*r) * 8) && (byte & 0x40) != 0)
188 result |= -(1 << shift);
189
190 *r = result;
191 return buf;
192 }
193
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. */
197
198 CORE_ADDR
dwarf2_read_address(unsigned char * buf,unsigned char * buf_end,int * bytes_read)199 dwarf2_read_address (unsigned char *buf, unsigned char *buf_end, int *bytes_read)
200 {
201 CORE_ADDR result;
202
203 if (buf_end - buf < TARGET_ADDR_BIT / TARGET_CHAR_BIT)
204 error ("dwarf2_read_address: Corrupted DWARF expression.");
205
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);
210 return result;
211 }
212
213 /* Return the type of an address, for unsigned arithmetic. */
214
215 static struct type *
unsigned_address_type(void)216 unsigned_address_type (void)
217 {
218 switch (TARGET_ADDR_BIT / TARGET_CHAR_BIT)
219 {
220 case 2:
221 return builtin_type_uint16;
222 case 4:
223 return builtin_type_uint32;
224 case 8:
225 return builtin_type_uint64;
226 default:
227 internal_error (__FILE__, __LINE__,
228 "Unsupported address size.\n");
229 }
230 }
231
232 /* Return the type of an address, for signed arithmetic. */
233
234 static struct type *
signed_address_type(void)235 signed_address_type (void)
236 {
237 switch (TARGET_ADDR_BIT / TARGET_CHAR_BIT)
238 {
239 case 2:
240 return builtin_type_int16;
241 case 4:
242 return builtin_type_int32;
243 case 8:
244 return builtin_type_int64;
245 default:
246 internal_error (__FILE__, __LINE__,
247 "Unsupported address size.\n");
248 }
249 }
250
251 /* The engine for the expression evaluator. Using the context in CTX,
252 evaluate the expression between OP_PTR and OP_END. */
253
254 static void
execute_stack_op(struct dwarf_expr_context * ctx,unsigned char * op_ptr,unsigned char * op_end)255 execute_stack_op (struct dwarf_expr_context *ctx, unsigned char *op_ptr,
256 unsigned char *op_end)
257 {
258 ctx->in_reg = 0;
259 ctx->initialized = 1; /* Default is initialized. */
260
261 while (op_ptr < op_end)
262 {
263 enum dwarf_location_atom op = *op_ptr++;
264 CORE_ADDR result;
265 ULONGEST uoffset, reg;
266 LONGEST offset;
267 int bytes_read;
268
269 switch (op)
270 {
271 case DW_OP_lit0:
272 case DW_OP_lit1:
273 case DW_OP_lit2:
274 case DW_OP_lit3:
275 case DW_OP_lit4:
276 case DW_OP_lit5:
277 case DW_OP_lit6:
278 case DW_OP_lit7:
279 case DW_OP_lit8:
280 case DW_OP_lit9:
281 case DW_OP_lit10:
282 case DW_OP_lit11:
283 case DW_OP_lit12:
284 case DW_OP_lit13:
285 case DW_OP_lit14:
286 case DW_OP_lit15:
287 case DW_OP_lit16:
288 case DW_OP_lit17:
289 case DW_OP_lit18:
290 case DW_OP_lit19:
291 case DW_OP_lit20:
292 case DW_OP_lit21:
293 case DW_OP_lit22:
294 case DW_OP_lit23:
295 case DW_OP_lit24:
296 case DW_OP_lit25:
297 case DW_OP_lit26:
298 case DW_OP_lit27:
299 case DW_OP_lit28:
300 case DW_OP_lit29:
301 case DW_OP_lit30:
302 case DW_OP_lit31:
303 result = op - DW_OP_lit0;
304 break;
305
306 case DW_OP_addr:
307 result = dwarf2_read_address (op_ptr, op_end, &bytes_read);
308 op_ptr += bytes_read;
309 break;
310
311 case DW_OP_const1u:
312 result = extract_unsigned_integer (op_ptr, 1);
313 op_ptr += 1;
314 break;
315 case DW_OP_const1s:
316 result = extract_signed_integer (op_ptr, 1);
317 op_ptr += 1;
318 break;
319 case DW_OP_const2u:
320 result = extract_unsigned_integer (op_ptr, 2);
321 op_ptr += 2;
322 break;
323 case DW_OP_const2s:
324 result = extract_signed_integer (op_ptr, 2);
325 op_ptr += 2;
326 break;
327 case DW_OP_const4u:
328 result = extract_unsigned_integer (op_ptr, 4);
329 op_ptr += 4;
330 break;
331 case DW_OP_const4s:
332 result = extract_signed_integer (op_ptr, 4);
333 op_ptr += 4;
334 break;
335 case DW_OP_const8u:
336 result = extract_unsigned_integer (op_ptr, 8);
337 op_ptr += 8;
338 break;
339 case DW_OP_const8s:
340 result = extract_signed_integer (op_ptr, 8);
341 op_ptr += 8;
342 break;
343 case DW_OP_constu:
344 op_ptr = read_uleb128 (op_ptr, op_end, &uoffset);
345 result = uoffset;
346 break;
347 case DW_OP_consts:
348 op_ptr = read_sleb128 (op_ptr, op_end, &offset);
349 result = offset;
350 break;
351
352 /* The DW_OP_reg operations are required to occur alone in
353 location expressions. */
354 case DW_OP_reg0:
355 case DW_OP_reg1:
356 case DW_OP_reg2:
357 case DW_OP_reg3:
358 case DW_OP_reg4:
359 case DW_OP_reg5:
360 case DW_OP_reg6:
361 case DW_OP_reg7:
362 case DW_OP_reg8:
363 case DW_OP_reg9:
364 case DW_OP_reg10:
365 case DW_OP_reg11:
366 case DW_OP_reg12:
367 case DW_OP_reg13:
368 case DW_OP_reg14:
369 case DW_OP_reg15:
370 case DW_OP_reg16:
371 case DW_OP_reg17:
372 case DW_OP_reg18:
373 case DW_OP_reg19:
374 case DW_OP_reg20:
375 case DW_OP_reg21:
376 case DW_OP_reg22:
377 case DW_OP_reg23:
378 case DW_OP_reg24:
379 case DW_OP_reg25:
380 case DW_OP_reg26:
381 case DW_OP_reg27:
382 case DW_OP_reg28:
383 case DW_OP_reg29:
384 case DW_OP_reg30:
385 case DW_OP_reg31:
386 if (op_ptr != op_end
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."));
392
393 result = op - DW_OP_reg0;
394 ctx->in_reg = 1;
395
396 break;
397
398 case DW_OP_regx:
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.");
403
404 result = reg;
405 ctx->in_reg = 1;
406 break;
407
408 case DW_OP_breg0:
409 case DW_OP_breg1:
410 case DW_OP_breg2:
411 case DW_OP_breg3:
412 case DW_OP_breg4:
413 case DW_OP_breg5:
414 case DW_OP_breg6:
415 case DW_OP_breg7:
416 case DW_OP_breg8:
417 case DW_OP_breg9:
418 case DW_OP_breg10:
419 case DW_OP_breg11:
420 case DW_OP_breg12:
421 case DW_OP_breg13:
422 case DW_OP_breg14:
423 case DW_OP_breg15:
424 case DW_OP_breg16:
425 case DW_OP_breg17:
426 case DW_OP_breg18:
427 case DW_OP_breg19:
428 case DW_OP_breg20:
429 case DW_OP_breg21:
430 case DW_OP_breg22:
431 case DW_OP_breg23:
432 case DW_OP_breg24:
433 case DW_OP_breg25:
434 case DW_OP_breg26:
435 case DW_OP_breg27:
436 case DW_OP_breg28:
437 case DW_OP_breg29:
438 case DW_OP_breg30:
439 case DW_OP_breg31:
440 {
441 op_ptr = read_sleb128 (op_ptr, op_end, &offset);
442 result = (ctx->read_reg) (ctx->baton, op - DW_OP_breg0);
443 result += offset;
444 }
445 break;
446 case DW_OP_bregx:
447 {
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);
451 result += offset;
452 }
453 break;
454 case DW_OP_fbreg:
455 {
456 unsigned char *datastart;
457 size_t datalen;
458 unsigned int before_stack_len;
459
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
464 call put there. */
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);
472 if (ctx->in_reg)
473 result = (ctx->read_reg) (ctx->baton, result);
474 result = result + offset;
475 ctx->stack_len = before_stack_len;
476 ctx->in_reg = 0;
477 }
478 break;
479 case DW_OP_dup:
480 result = dwarf_expr_fetch (ctx, 0);
481 break;
482
483 case DW_OP_drop:
484 dwarf_expr_pop (ctx);
485 goto no_push;
486
487 case DW_OP_pick:
488 offset = *op_ptr++;
489 result = dwarf_expr_fetch (ctx, offset);
490 break;
491
492 case DW_OP_over:
493 result = dwarf_expr_fetch (ctx, 1);
494 break;
495
496 case DW_OP_rot:
497 {
498 CORE_ADDR t1, t2, t3;
499
500 if (ctx->stack_len < 3)
501 error ("Not enough elements for DW_OP_rot. Need 3, have %d\n",
502 ctx->stack_len);
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;
509 goto no_push;
510 }
511
512 case DW_OP_deref:
513 case DW_OP_deref_size:
514 case DW_OP_abs:
515 case DW_OP_neg:
516 case DW_OP_not:
517 case DW_OP_plus_uconst:
518 /* Unary operations. */
519 result = dwarf_expr_fetch (ctx, 0);
520 dwarf_expr_pop (ctx);
521
522 switch (op)
523 {
524 case DW_OP_deref:
525 {
526 char *buf = alloca (TARGET_ADDR_BIT / TARGET_CHAR_BIT);
527 int bytes_read;
528
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
533 / TARGET_CHAR_BIT),
534 &bytes_read);
535 }
536 break;
537
538 case DW_OP_deref_size:
539 {
540 char *buf = alloca (TARGET_ADDR_BIT / TARGET_CHAR_BIT);
541 int bytes_read;
542
543 (ctx->read_mem) (ctx->baton, buf, result, *op_ptr++);
544 result = dwarf2_read_address (buf,
545 buf + (TARGET_ADDR_BIT
546 / TARGET_CHAR_BIT),
547 &bytes_read);
548 }
549 break;
550
551 case DW_OP_abs:
552 if ((signed int) result < 0)
553 result = -result;
554 break;
555 case DW_OP_neg:
556 result = -result;
557 break;
558 case DW_OP_not:
559 result = ~result;
560 break;
561 case DW_OP_plus_uconst:
562 op_ptr = read_uleb128 (op_ptr, op_end, ®);
563 result += reg;
564 break;
565 }
566 break;
567
568 case DW_OP_and:
569 case DW_OP_div:
570 case DW_OP_minus:
571 case DW_OP_mod:
572 case DW_OP_mul:
573 case DW_OP_or:
574 case DW_OP_plus:
575 case DW_OP_shl:
576 case DW_OP_shr:
577 case DW_OP_shra:
578 case DW_OP_xor:
579 case DW_OP_le:
580 case DW_OP_ge:
581 case DW_OP_eq:
582 case DW_OP_lt:
583 case DW_OP_gt:
584 case DW_OP_ne:
585 {
586 /* Binary operations. Use the value engine to do computations in
587 the right width. */
588 CORE_ADDR first, second;
589 enum exp_opcode binop;
590 struct value *val1, *val2;
591
592 second = dwarf_expr_fetch (ctx, 0);
593 dwarf_expr_pop (ctx);
594
595 first = dwarf_expr_fetch (ctx, 0);
596 dwarf_expr_pop (ctx);
597
598 val1 = value_from_longest (unsigned_address_type (), first);
599 val2 = value_from_longest (unsigned_address_type (), second);
600
601 switch (op)
602 {
603 case DW_OP_and:
604 binop = BINOP_BITWISE_AND;
605 break;
606 case DW_OP_div:
607 binop = BINOP_DIV;
608 break;
609 case DW_OP_minus:
610 binop = BINOP_SUB;
611 break;
612 case DW_OP_mod:
613 binop = BINOP_MOD;
614 break;
615 case DW_OP_mul:
616 binop = BINOP_MUL;
617 break;
618 case DW_OP_or:
619 binop = BINOP_BITWISE_IOR;
620 break;
621 case DW_OP_plus:
622 binop = BINOP_ADD;
623 break;
624 case DW_OP_shl:
625 binop = BINOP_LSH;
626 break;
627 case DW_OP_shr:
628 binop = BINOP_RSH;
629 break;
630 case DW_OP_shra:
631 binop = BINOP_RSH;
632 val1 = value_from_longest (signed_address_type (), first);
633 break;
634 case DW_OP_xor:
635 binop = BINOP_BITWISE_XOR;
636 break;
637 case DW_OP_le:
638 binop = BINOP_LEQ;
639 break;
640 case DW_OP_ge:
641 binop = BINOP_GEQ;
642 break;
643 case DW_OP_eq:
644 binop = BINOP_EQUAL;
645 break;
646 case DW_OP_lt:
647 binop = BINOP_LESS;
648 break;
649 case DW_OP_gt:
650 binop = BINOP_GTR;
651 break;
652 case DW_OP_ne:
653 binop = BINOP_NOTEQUAL;
654 break;
655 default:
656 internal_error (__FILE__, __LINE__,
657 "Can't be reached.");
658 }
659 result = value_as_long (value_binop (val1, val2, binop));
660 }
661 break;
662
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
671 returned. */
672 result = dwarf_expr_fetch (ctx, 0);
673 dwarf_expr_pop (ctx);
674 result = (ctx->get_tls_address) (ctx->baton, result);
675 break;
676
677 case DW_OP_skip:
678 offset = extract_signed_integer (op_ptr, 2);
679 op_ptr += 2;
680 op_ptr += offset;
681 goto no_push;
682
683 case DW_OP_bra:
684 offset = extract_signed_integer (op_ptr, 2);
685 op_ptr += 2;
686 if (dwarf_expr_fetch (ctx, 0) != 0)
687 op_ptr += offset;
688 dwarf_expr_pop (ctx);
689 goto no_push;
690
691 case DW_OP_nop:
692 goto no_push;
693
694 case DW_OP_piece:
695 {
696 ULONGEST size;
697 CORE_ADDR addr_or_regnum;
698
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);
703
704 /* Pop off the address/regnum, and clear the in_reg flag. */
705 dwarf_expr_pop (ctx);
706 ctx->in_reg = 0;
707 }
708 goto no_push;
709
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."));
714
715 ctx->initialized = 0;
716 goto no_push;
717
718 default:
719 error ("Unhandled dwarf expression opcode 0x%x", op);
720 }
721
722 /* Most things push a result value. */
723 dwarf_expr_push (ctx, result);
724 no_push:;
725 }
726 }
727