Import gdb 7.3 into vendor branch
[dragonfly.git] / contrib / gdb-7 / gdb / dwarf2expr.c
CommitLineData
5796c8dc
SS
1/* DWARF 2 Expression Evaluator.
2
c50c785c 3 Copyright (C) 2001, 2002, 2003, 2005, 2007, 2008, 2009, 2010, 2011
5796c8dc
SS
4 Free Software Foundation, Inc.
5
6 Contributed by Daniel Berlin (dan@dberlin.org)
7
8 This file is part of GDB.
9
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.
14
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.
19
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/>. */
22
23#include "defs.h"
24#include "symtab.h"
25#include "gdbtypes.h"
26#include "value.h"
27#include "gdbcore.h"
28#include "dwarf2.h"
29#include "dwarf2expr.h"
30#include "gdb_assert.h"
31
32/* Local prototypes. */
33
34static void execute_stack_op (struct dwarf_expr_context *,
cf7f2e2d 35 const gdb_byte *, const gdb_byte *);
5796c8dc
SS
36
37/* Create a new context for the expression evaluator. */
38
39struct dwarf_expr_context *
40new_dwarf_expr_context (void)
41{
42 struct dwarf_expr_context *retval;
cf7f2e2d 43
5796c8dc
SS
44 retval = xcalloc (1, sizeof (struct dwarf_expr_context));
45 retval->stack_len = 0;
46 retval->stack_allocated = 10;
cf7f2e2d
JM
47 retval->stack = xmalloc (retval->stack_allocated
48 * sizeof (struct dwarf_stack_value));
5796c8dc
SS
49 retval->num_pieces = 0;
50 retval->pieces = 0;
51 retval->max_recursion_depth = 0x100;
52 return retval;
53}
54
55/* Release the memory allocated to CTX. */
56
57void
58free_dwarf_expr_context (struct dwarf_expr_context *ctx)
59{
60 xfree (ctx->stack);
61 xfree (ctx->pieces);
62 xfree (ctx);
63}
64
65/* Helper for make_cleanup_free_dwarf_expr_context. */
66
67static void
68free_dwarf_expr_context_cleanup (void *arg)
69{
70 free_dwarf_expr_context (arg);
71}
72
73/* Return a cleanup that calls free_dwarf_expr_context. */
74
75struct cleanup *
76make_cleanup_free_dwarf_expr_context (struct dwarf_expr_context *ctx)
77{
78 return make_cleanup (free_dwarf_expr_context_cleanup, ctx);
79}
80
81/* Expand the memory allocated to CTX's stack to contain at least
82 NEED more elements than are currently used. */
83
84static void
85dwarf_expr_grow_stack (struct dwarf_expr_context *ctx, size_t need)
86{
87 if (ctx->stack_len + need > ctx->stack_allocated)
88 {
89 size_t newlen = ctx->stack_len + need + 10;
cf7f2e2d 90
5796c8dc
SS
91 ctx->stack = xrealloc (ctx->stack,
92 newlen * sizeof (struct dwarf_stack_value));
93 ctx->stack_allocated = newlen;
94 }
95}
96
97/* Push VALUE onto CTX's stack. */
98
99void
cf7f2e2d 100dwarf_expr_push (struct dwarf_expr_context *ctx, ULONGEST value,
5796c8dc
SS
101 int in_stack_memory)
102{
103 struct dwarf_stack_value *v;
104
cf7f2e2d
JM
105 /* We keep all stack elements within the range defined by the
106 DWARF address size. */
107 if (ctx->addr_size < sizeof (ULONGEST))
108 value &= ((ULONGEST) 1 << (ctx->addr_size * HOST_CHAR_BIT)) - 1;
109
5796c8dc
SS
110 dwarf_expr_grow_stack (ctx, 1);
111 v = &ctx->stack[ctx->stack_len++];
112 v->value = value;
113 v->in_stack_memory = in_stack_memory;
114}
115
116/* Pop the top item off of CTX's stack. */
117
118void
119dwarf_expr_pop (struct dwarf_expr_context *ctx)
120{
121 if (ctx->stack_len <= 0)
122 error (_("dwarf expression stack underflow"));
123 ctx->stack_len--;
124}
125
126/* Retrieve the N'th item on CTX's stack. */
127
cf7f2e2d 128ULONGEST
5796c8dc
SS
129dwarf_expr_fetch (struct dwarf_expr_context *ctx, int n)
130{
131 if (ctx->stack_len <= n)
c50c785c
JM
132 error (_("Asked for position %d of stack, "
133 "stack only has %d elements on it."),
5796c8dc
SS
134 n, ctx->stack_len);
135 return ctx->stack[ctx->stack_len - (1 + n)].value;
136
137}
138
cf7f2e2d
JM
139/* Retrieve the N'th item on CTX's stack, converted to an address. */
140
141CORE_ADDR
142dwarf_expr_fetch_address (struct dwarf_expr_context *ctx, int n)
143{
144 ULONGEST result = dwarf_expr_fetch (ctx, n);
145
146 /* For most architectures, calling extract_unsigned_integer() alone
147 is sufficient for extracting an address. However, some
148 architectures (e.g. MIPS) use signed addresses and using
149 extract_unsigned_integer() will not produce a correct
150 result. Make sure we invoke gdbarch_integer_to_address()
151 for those architectures which require it. */
152 if (gdbarch_integer_to_address_p (ctx->gdbarch))
153 {
154 enum bfd_endian byte_order = gdbarch_byte_order (ctx->gdbarch);
155 gdb_byte *buf = alloca (ctx->addr_size);
156 struct type *int_type;
157
158 switch (ctx->addr_size)
159 {
160 case 2:
161 int_type = builtin_type (ctx->gdbarch)->builtin_uint16;
162 break;
163 case 4:
164 int_type = builtin_type (ctx->gdbarch)->builtin_uint32;
165 break;
166 case 8:
167 int_type = builtin_type (ctx->gdbarch)->builtin_uint64;
168 break;
169 default:
170 internal_error (__FILE__, __LINE__,
171 _("Unsupported address size.\n"));
172 }
173
174 store_unsigned_integer (buf, ctx->addr_size, byte_order, result);
175 return gdbarch_integer_to_address (ctx->gdbarch, int_type, buf);
176 }
177
178 return (CORE_ADDR) result;
179}
180
5796c8dc
SS
181/* Retrieve the in_stack_memory flag of the N'th item on CTX's stack. */
182
183int
184dwarf_expr_fetch_in_stack_memory (struct dwarf_expr_context *ctx, int n)
185{
186 if (ctx->stack_len <= n)
c50c785c
JM
187 error (_("Asked for position %d of stack, "
188 "stack only has %d elements on it."),
5796c8dc
SS
189 n, ctx->stack_len);
190 return ctx->stack[ctx->stack_len - (1 + n)].in_stack_memory;
191
192}
193
cf7f2e2d
JM
194/* Return true if the expression stack is empty. */
195
196static int
197dwarf_expr_stack_empty_p (struct dwarf_expr_context *ctx)
198{
199 return ctx->stack_len == 0;
200}
201
5796c8dc
SS
202/* Add a new piece to CTX's piece list. */
203static void
cf7f2e2d 204add_piece (struct dwarf_expr_context *ctx, ULONGEST size, ULONGEST offset)
5796c8dc
SS
205{
206 struct dwarf_expr_piece *p;
207
208 ctx->num_pieces++;
209
cf7f2e2d
JM
210 ctx->pieces = xrealloc (ctx->pieces,
211 (ctx->num_pieces
212 * sizeof (struct dwarf_expr_piece)));
5796c8dc
SS
213
214 p = &ctx->pieces[ctx->num_pieces - 1];
215 p->location = ctx->location;
216 p->size = size;
cf7f2e2d
JM
217 p->offset = offset;
218
5796c8dc
SS
219 if (p->location == DWARF_VALUE_LITERAL)
220 {
221 p->v.literal.data = ctx->data;
222 p->v.literal.length = ctx->len;
223 }
cf7f2e2d
JM
224 else if (dwarf_expr_stack_empty_p (ctx))
225 {
226 p->location = DWARF_VALUE_OPTIMIZED_OUT;
227 /* Also reset the context's location, for our callers. This is
228 a somewhat strange approach, but this lets us avoid setting
229 the location to DWARF_VALUE_MEMORY in all the individual
230 cases in the evaluator. */
231 ctx->location = DWARF_VALUE_OPTIMIZED_OUT;
232 }
233 else if (p->location == DWARF_VALUE_MEMORY)
234 {
235 p->v.mem.addr = dwarf_expr_fetch_address (ctx, 0);
236 p->v.mem.in_stack_memory = dwarf_expr_fetch_in_stack_memory (ctx, 0);
237 }
c50c785c
JM
238 else if (p->location == DWARF_VALUE_IMPLICIT_POINTER)
239 {
240 p->v.ptr.die = ctx->len;
241 p->v.ptr.offset = (LONGEST) dwarf_expr_fetch (ctx, 0);
242 }
5796c8dc
SS
243 else
244 {
cf7f2e2d 245 p->v.value = dwarf_expr_fetch (ctx, 0);
5796c8dc
SS
246 }
247}
248
249/* Evaluate the expression at ADDR (LEN bytes long) using the context
250 CTX. */
251
252void
cf7f2e2d
JM
253dwarf_expr_eval (struct dwarf_expr_context *ctx, const gdb_byte *addr,
254 size_t len)
5796c8dc
SS
255{
256 int old_recursion_depth = ctx->recursion_depth;
257
258 execute_stack_op (ctx, addr, addr + len);
259
260 /* CTX RECURSION_DEPTH becomes invalid if an exception was thrown here. */
261
262 gdb_assert (ctx->recursion_depth == old_recursion_depth);
263}
264
265/* Decode the unsigned LEB128 constant at BUF into the variable pointed to
266 by R, and return the new value of BUF. Verify that it doesn't extend
267 past BUF_END. */
268
cf7f2e2d
JM
269const gdb_byte *
270read_uleb128 (const gdb_byte *buf, const gdb_byte *buf_end, ULONGEST * r)
5796c8dc
SS
271{
272 unsigned shift = 0;
273 ULONGEST result = 0;
274 gdb_byte byte;
275
276 while (1)
277 {
278 if (buf >= buf_end)
279 error (_("read_uleb128: Corrupted DWARF expression."));
280
281 byte = *buf++;
c50c785c 282 result |= ((ULONGEST) (byte & 0x7f)) << shift;
5796c8dc
SS
283 if ((byte & 0x80) == 0)
284 break;
285 shift += 7;
286 }
287 *r = result;
288 return buf;
289}
290
291/* Decode the signed LEB128 constant at BUF into the variable pointed to
292 by R, and return the new value of BUF. Verify that it doesn't extend
293 past BUF_END. */
294
cf7f2e2d
JM
295const gdb_byte *
296read_sleb128 (const gdb_byte *buf, const gdb_byte *buf_end, LONGEST * r)
5796c8dc
SS
297{
298 unsigned shift = 0;
299 LONGEST result = 0;
300 gdb_byte byte;
301
302 while (1)
303 {
304 if (buf >= buf_end)
305 error (_("read_sleb128: Corrupted DWARF expression."));
306
307 byte = *buf++;
c50c785c 308 result |= ((ULONGEST) (byte & 0x7f)) << shift;
5796c8dc
SS
309 shift += 7;
310 if ((byte & 0x80) == 0)
311 break;
312 }
313 if (shift < (sizeof (*r) * 8) && (byte & 0x40) != 0)
314 result |= -(1 << shift);
315
316 *r = result;
317 return buf;
318}
5796c8dc
SS
319\f
320
321/* Check that the current operator is either at the end of an
322 expression, or that it is followed by a composition operator. */
323
cf7f2e2d
JM
324void
325dwarf_expr_require_composition (const gdb_byte *op_ptr, const gdb_byte *op_end,
326 const char *op_name)
5796c8dc
SS
327{
328 /* It seems like DW_OP_GNU_uninit should be handled here. However,
329 it doesn't seem to make sense for DW_OP_*_value, and it was not
330 checked at the other place that this function is called. */
331 if (op_ptr != op_end && *op_ptr != DW_OP_piece && *op_ptr != DW_OP_bit_piece)
332 error (_("DWARF-2 expression error: `%s' operations must be "
333 "used either alone or in conjuction with DW_OP_piece "
334 "or DW_OP_bit_piece."),
335 op_name);
336}
337
338/* The engine for the expression evaluator. Using the context in CTX,
339 evaluate the expression between OP_PTR and OP_END. */
340
341static void
342execute_stack_op (struct dwarf_expr_context *ctx,
cf7f2e2d 343 const gdb_byte *op_ptr, const gdb_byte *op_end)
5796c8dc 344{
cf7f2e2d
JM
345#define sign_ext(x) ((LONGEST) (((x) ^ sign_bit) - sign_bit))
346 ULONGEST sign_bit = (ctx->addr_size >= sizeof (ULONGEST) ? 0
347 : ((ULONGEST) 1) << (ctx->addr_size * 8 - 1));
5796c8dc 348 enum bfd_endian byte_order = gdbarch_byte_order (ctx->gdbarch);
cf7f2e2d 349
5796c8dc
SS
350 ctx->location = DWARF_VALUE_MEMORY;
351 ctx->initialized = 1; /* Default is initialized. */
352
353 if (ctx->recursion_depth > ctx->max_recursion_depth)
354 error (_("DWARF-2 expression error: Loop detected (%d)."),
355 ctx->recursion_depth);
356 ctx->recursion_depth++;
357
358 while (op_ptr < op_end)
359 {
360 enum dwarf_location_atom op = *op_ptr++;
cf7f2e2d 361 ULONGEST result;
5796c8dc
SS
362 /* Assume the value is not in stack memory.
363 Code that knows otherwise sets this to 1.
364 Some arithmetic on stack addresses can probably be assumed to still
365 be a stack address, but we skip this complication for now.
366 This is just an optimization, so it's always ok to punt
367 and leave this as 0. */
368 int in_stack_memory = 0;
369 ULONGEST uoffset, reg;
370 LONGEST offset;
371
372 switch (op)
373 {
374 case DW_OP_lit0:
375 case DW_OP_lit1:
376 case DW_OP_lit2:
377 case DW_OP_lit3:
378 case DW_OP_lit4:
379 case DW_OP_lit5:
380 case DW_OP_lit6:
381 case DW_OP_lit7:
382 case DW_OP_lit8:
383 case DW_OP_lit9:
384 case DW_OP_lit10:
385 case DW_OP_lit11:
386 case DW_OP_lit12:
387 case DW_OP_lit13:
388 case DW_OP_lit14:
389 case DW_OP_lit15:
390 case DW_OP_lit16:
391 case DW_OP_lit17:
392 case DW_OP_lit18:
393 case DW_OP_lit19:
394 case DW_OP_lit20:
395 case DW_OP_lit21:
396 case DW_OP_lit22:
397 case DW_OP_lit23:
398 case DW_OP_lit24:
399 case DW_OP_lit25:
400 case DW_OP_lit26:
401 case DW_OP_lit27:
402 case DW_OP_lit28:
403 case DW_OP_lit29:
404 case DW_OP_lit30:
405 case DW_OP_lit31:
406 result = op - DW_OP_lit0;
407 break;
408
409 case DW_OP_addr:
cf7f2e2d
JM
410 result = extract_unsigned_integer (op_ptr,
411 ctx->addr_size, byte_order);
5796c8dc 412 op_ptr += ctx->addr_size;
cf7f2e2d
JM
413 /* Some versions of GCC emit DW_OP_addr before
414 DW_OP_GNU_push_tls_address. In this case the value is an
415 index, not an address. We don't support things like
416 branching between the address and the TLS op. */
417 if (op_ptr >= op_end || *op_ptr != DW_OP_GNU_push_tls_address)
418 result += ctx->offset;
5796c8dc
SS
419 break;
420
421 case DW_OP_const1u:
422 result = extract_unsigned_integer (op_ptr, 1, byte_order);
423 op_ptr += 1;
424 break;
425 case DW_OP_const1s:
426 result = extract_signed_integer (op_ptr, 1, byte_order);
427 op_ptr += 1;
428 break;
429 case DW_OP_const2u:
430 result = extract_unsigned_integer (op_ptr, 2, byte_order);
431 op_ptr += 2;
432 break;
433 case DW_OP_const2s:
434 result = extract_signed_integer (op_ptr, 2, byte_order);
435 op_ptr += 2;
436 break;
437 case DW_OP_const4u:
438 result = extract_unsigned_integer (op_ptr, 4, byte_order);
439 op_ptr += 4;
440 break;
441 case DW_OP_const4s:
442 result = extract_signed_integer (op_ptr, 4, byte_order);
443 op_ptr += 4;
444 break;
445 case DW_OP_const8u:
446 result = extract_unsigned_integer (op_ptr, 8, byte_order);
447 op_ptr += 8;
448 break;
449 case DW_OP_const8s:
450 result = extract_signed_integer (op_ptr, 8, byte_order);
451 op_ptr += 8;
452 break;
453 case DW_OP_constu:
454 op_ptr = read_uleb128 (op_ptr, op_end, &uoffset);
455 result = uoffset;
456 break;
457 case DW_OP_consts:
458 op_ptr = read_sleb128 (op_ptr, op_end, &offset);
459 result = offset;
460 break;
461
462 /* The DW_OP_reg operations are required to occur alone in
463 location expressions. */
464 case DW_OP_reg0:
465 case DW_OP_reg1:
466 case DW_OP_reg2:
467 case DW_OP_reg3:
468 case DW_OP_reg4:
469 case DW_OP_reg5:
470 case DW_OP_reg6:
471 case DW_OP_reg7:
472 case DW_OP_reg8:
473 case DW_OP_reg9:
474 case DW_OP_reg10:
475 case DW_OP_reg11:
476 case DW_OP_reg12:
477 case DW_OP_reg13:
478 case DW_OP_reg14:
479 case DW_OP_reg15:
480 case DW_OP_reg16:
481 case DW_OP_reg17:
482 case DW_OP_reg18:
483 case DW_OP_reg19:
484 case DW_OP_reg20:
485 case DW_OP_reg21:
486 case DW_OP_reg22:
487 case DW_OP_reg23:
488 case DW_OP_reg24:
489 case DW_OP_reg25:
490 case DW_OP_reg26:
491 case DW_OP_reg27:
492 case DW_OP_reg28:
493 case DW_OP_reg29:
494 case DW_OP_reg30:
495 case DW_OP_reg31:
496 if (op_ptr != op_end
497 && *op_ptr != DW_OP_piece
cf7f2e2d 498 && *op_ptr != DW_OP_bit_piece
5796c8dc
SS
499 && *op_ptr != DW_OP_GNU_uninit)
500 error (_("DWARF-2 expression error: DW_OP_reg operations must be "
cf7f2e2d
JM
501 "used either alone or in conjuction with DW_OP_piece "
502 "or DW_OP_bit_piece."));
5796c8dc
SS
503
504 result = op - DW_OP_reg0;
505 ctx->location = DWARF_VALUE_REGISTER;
506 break;
507
508 case DW_OP_regx:
509 op_ptr = read_uleb128 (op_ptr, op_end, &reg);
cf7f2e2d 510 dwarf_expr_require_composition (op_ptr, op_end, "DW_OP_regx");
5796c8dc
SS
511
512 result = reg;
513 ctx->location = DWARF_VALUE_REGISTER;
514 break;
515
516 case DW_OP_implicit_value:
517 {
518 ULONGEST len;
cf7f2e2d 519
5796c8dc
SS
520 op_ptr = read_uleb128 (op_ptr, op_end, &len);
521 if (op_ptr + len > op_end)
522 error (_("DW_OP_implicit_value: too few bytes available."));
523 ctx->len = len;
524 ctx->data = op_ptr;
525 ctx->location = DWARF_VALUE_LITERAL;
526 op_ptr += len;
cf7f2e2d
JM
527 dwarf_expr_require_composition (op_ptr, op_end,
528 "DW_OP_implicit_value");
5796c8dc
SS
529 }
530 goto no_push;
531
532 case DW_OP_stack_value:
533 ctx->location = DWARF_VALUE_STACK;
cf7f2e2d 534 dwarf_expr_require_composition (op_ptr, op_end, "DW_OP_stack_value");
5796c8dc
SS
535 goto no_push;
536
c50c785c
JM
537 case DW_OP_GNU_implicit_pointer:
538 {
539 ULONGEST die;
540 LONGEST len;
541
542 /* The referred-to DIE. */
543 ctx->len = extract_unsigned_integer (op_ptr, ctx->addr_size,
544 byte_order);
545 op_ptr += ctx->addr_size;
546
547 /* The byte offset into the data. */
548 op_ptr = read_sleb128 (op_ptr, op_end, &len);
549 result = (ULONGEST) len;
550
551 ctx->location = DWARF_VALUE_IMPLICIT_POINTER;
552 dwarf_expr_require_composition (op_ptr, op_end,
553 "DW_OP_GNU_implicit_pointer");
554 }
555 break;
556
5796c8dc
SS
557 case DW_OP_breg0:
558 case DW_OP_breg1:
559 case DW_OP_breg2:
560 case DW_OP_breg3:
561 case DW_OP_breg4:
562 case DW_OP_breg5:
563 case DW_OP_breg6:
564 case DW_OP_breg7:
565 case DW_OP_breg8:
566 case DW_OP_breg9:
567 case DW_OP_breg10:
568 case DW_OP_breg11:
569 case DW_OP_breg12:
570 case DW_OP_breg13:
571 case DW_OP_breg14:
572 case DW_OP_breg15:
573 case DW_OP_breg16:
574 case DW_OP_breg17:
575 case DW_OP_breg18:
576 case DW_OP_breg19:
577 case DW_OP_breg20:
578 case DW_OP_breg21:
579 case DW_OP_breg22:
580 case DW_OP_breg23:
581 case DW_OP_breg24:
582 case DW_OP_breg25:
583 case DW_OP_breg26:
584 case DW_OP_breg27:
585 case DW_OP_breg28:
586 case DW_OP_breg29:
587 case DW_OP_breg30:
588 case DW_OP_breg31:
589 {
590 op_ptr = read_sleb128 (op_ptr, op_end, &offset);
591 result = (ctx->read_reg) (ctx->baton, op - DW_OP_breg0);
592 result += offset;
593 }
594 break;
595 case DW_OP_bregx:
596 {
597 op_ptr = read_uleb128 (op_ptr, op_end, &reg);
598 op_ptr = read_sleb128 (op_ptr, op_end, &offset);
599 result = (ctx->read_reg) (ctx->baton, reg);
600 result += offset;
601 }
602 break;
603 case DW_OP_fbreg:
604 {
cf7f2e2d 605 const gdb_byte *datastart;
5796c8dc
SS
606 size_t datalen;
607 unsigned int before_stack_len;
608
609 op_ptr = read_sleb128 (op_ptr, op_end, &offset);
610 /* Rather than create a whole new context, we simply
611 record the stack length before execution, then reset it
612 afterwards, effectively erasing whatever the recursive
613 call put there. */
614 before_stack_len = ctx->stack_len;
615 /* FIXME: cagney/2003-03-26: This code should be using
616 get_frame_base_address(), and then implement a dwarf2
617 specific this_base method. */
618 (ctx->get_frame_base) (ctx->baton, &datastart, &datalen);
619 dwarf_expr_eval (ctx, datastart, datalen);
cf7f2e2d
JM
620 if (ctx->location == DWARF_VALUE_MEMORY)
621 result = dwarf_expr_fetch_address (ctx, 0);
622 else if (ctx->location == DWARF_VALUE_REGISTER)
623 result = (ctx->read_reg) (ctx->baton, dwarf_expr_fetch (ctx, 0));
624 else
c50c785c
JM
625 error (_("Not implemented: computing frame "
626 "base using explicit value operator"));
5796c8dc
SS
627 result = result + offset;
628 in_stack_memory = 1;
629 ctx->stack_len = before_stack_len;
630 ctx->location = DWARF_VALUE_MEMORY;
631 }
632 break;
633
634 case DW_OP_dup:
635 result = dwarf_expr_fetch (ctx, 0);
636 in_stack_memory = dwarf_expr_fetch_in_stack_memory (ctx, 0);
637 break;
638
639 case DW_OP_drop:
640 dwarf_expr_pop (ctx);
641 goto no_push;
642
643 case DW_OP_pick:
644 offset = *op_ptr++;
645 result = dwarf_expr_fetch (ctx, offset);
646 in_stack_memory = dwarf_expr_fetch_in_stack_memory (ctx, offset);
647 break;
648
649 case DW_OP_swap:
650 {
651 struct dwarf_stack_value t1, t2;
652
653 if (ctx->stack_len < 2)
c50c785c
JM
654 error (_("Not enough elements for "
655 "DW_OP_swap. Need 2, have %d."),
5796c8dc
SS
656 ctx->stack_len);
657 t1 = ctx->stack[ctx->stack_len - 1];
658 t2 = ctx->stack[ctx->stack_len - 2];
659 ctx->stack[ctx->stack_len - 1] = t2;
660 ctx->stack[ctx->stack_len - 2] = t1;
661 goto no_push;
662 }
663
664 case DW_OP_over:
665 result = dwarf_expr_fetch (ctx, 1);
666 in_stack_memory = dwarf_expr_fetch_in_stack_memory (ctx, 1);
667 break;
668
669 case DW_OP_rot:
670 {
671 struct dwarf_stack_value t1, t2, t3;
672
673 if (ctx->stack_len < 3)
c50c785c
JM
674 error (_("Not enough elements for "
675 "DW_OP_rot. Need 3, have %d."),
5796c8dc
SS
676 ctx->stack_len);
677 t1 = ctx->stack[ctx->stack_len - 1];
678 t2 = ctx->stack[ctx->stack_len - 2];
679 t3 = ctx->stack[ctx->stack_len - 3];
680 ctx->stack[ctx->stack_len - 1] = t2;
681 ctx->stack[ctx->stack_len - 2] = t3;
682 ctx->stack[ctx->stack_len - 3] = t1;
683 goto no_push;
684 }
685
686 case DW_OP_deref:
687 case DW_OP_deref_size:
cf7f2e2d
JM
688 {
689 int addr_size = (op == DW_OP_deref ? ctx->addr_size : *op_ptr++);
690 gdb_byte *buf = alloca (addr_size);
691 CORE_ADDR addr = dwarf_expr_fetch_address (ctx, 0);
692 dwarf_expr_pop (ctx);
693
694 (ctx->read_mem) (ctx->baton, buf, addr, addr_size);
695 result = extract_unsigned_integer (buf, addr_size, byte_order);
696 break;
697 }
698
5796c8dc
SS
699 case DW_OP_abs:
700 case DW_OP_neg:
701 case DW_OP_not:
702 case DW_OP_plus_uconst:
703 /* Unary operations. */
704 result = dwarf_expr_fetch (ctx, 0);
705 dwarf_expr_pop (ctx);
706
707 switch (op)
708 {
5796c8dc 709 case DW_OP_abs:
cf7f2e2d 710 if (sign_ext (result) < 0)
5796c8dc
SS
711 result = -result;
712 break;
713 case DW_OP_neg:
714 result = -result;
715 break;
716 case DW_OP_not:
717 result = ~result;
718 break;
719 case DW_OP_plus_uconst:
720 op_ptr = read_uleb128 (op_ptr, op_end, &reg);
721 result += reg;
722 break;
723 }
724 break;
725
726 case DW_OP_and:
727 case DW_OP_div:
728 case DW_OP_minus:
729 case DW_OP_mod:
730 case DW_OP_mul:
731 case DW_OP_or:
732 case DW_OP_plus:
733 case DW_OP_shl:
734 case DW_OP_shr:
735 case DW_OP_shra:
736 case DW_OP_xor:
737 case DW_OP_le:
738 case DW_OP_ge:
739 case DW_OP_eq:
740 case DW_OP_lt:
741 case DW_OP_gt:
742 case DW_OP_ne:
743 {
cf7f2e2d
JM
744 /* Binary operations. */
745 ULONGEST first, second;
5796c8dc
SS
746
747 second = dwarf_expr_fetch (ctx, 0);
748 dwarf_expr_pop (ctx);
749
750 first = dwarf_expr_fetch (ctx, 0);
751 dwarf_expr_pop (ctx);
752
5796c8dc
SS
753 switch (op)
754 {
755 case DW_OP_and:
cf7f2e2d 756 result = first & second;
5796c8dc
SS
757 break;
758 case DW_OP_div:
cf7f2e2d
JM
759 if (!second)
760 error (_("Division by zero"));
761 result = sign_ext (first) / sign_ext (second);
5796c8dc
SS
762 break;
763 case DW_OP_minus:
cf7f2e2d 764 result = first - second;
5796c8dc
SS
765 break;
766 case DW_OP_mod:
cf7f2e2d
JM
767 if (!second)
768 error (_("Division by zero"));
769 result = first % second;
5796c8dc
SS
770 break;
771 case DW_OP_mul:
cf7f2e2d 772 result = first * second;
5796c8dc
SS
773 break;
774 case DW_OP_or:
cf7f2e2d 775 result = first | second;
5796c8dc
SS
776 break;
777 case DW_OP_plus:
cf7f2e2d 778 result = first + second;
5796c8dc
SS
779 break;
780 case DW_OP_shl:
cf7f2e2d 781 result = first << second;
5796c8dc
SS
782 break;
783 case DW_OP_shr:
cf7f2e2d 784 result = first >> second;
5796c8dc
SS
785 break;
786 case DW_OP_shra:
cf7f2e2d 787 result = sign_ext (first) >> second;
5796c8dc
SS
788 break;
789 case DW_OP_xor:
cf7f2e2d 790 result = first ^ second;
5796c8dc
SS
791 break;
792 case DW_OP_le:
cf7f2e2d 793 result = sign_ext (first) <= sign_ext (second);
5796c8dc
SS
794 break;
795 case DW_OP_ge:
cf7f2e2d 796 result = sign_ext (first) >= sign_ext (second);
5796c8dc
SS
797 break;
798 case DW_OP_eq:
cf7f2e2d 799 result = sign_ext (first) == sign_ext (second);
5796c8dc
SS
800 break;
801 case DW_OP_lt:
cf7f2e2d 802 result = sign_ext (first) < sign_ext (second);
5796c8dc
SS
803 break;
804 case DW_OP_gt:
cf7f2e2d 805 result = sign_ext (first) > sign_ext (second);
5796c8dc
SS
806 break;
807 case DW_OP_ne:
cf7f2e2d 808 result = sign_ext (first) != sign_ext (second);
5796c8dc
SS
809 break;
810 default:
811 internal_error (__FILE__, __LINE__,
812 _("Can't be reached."));
813 }
5796c8dc
SS
814 }
815 break;
816
817 case DW_OP_call_frame_cfa:
818 result = (ctx->get_frame_cfa) (ctx->baton);
819 in_stack_memory = 1;
820 break;
821
822 case DW_OP_GNU_push_tls_address:
823 /* Variable is at a constant offset in the thread-local
824 storage block into the objfile for the current thread and
c50c785c 825 the dynamic linker module containing this expression. Here
5796c8dc
SS
826 we return returns the offset from that base. The top of the
827 stack has the offset from the beginning of the thread
828 control block at which the variable is located. Nothing
829 should follow this operator, so the top of stack would be
830 returned. */
831 result = dwarf_expr_fetch (ctx, 0);
832 dwarf_expr_pop (ctx);
833 result = (ctx->get_tls_address) (ctx->baton, result);
834 break;
835
836 case DW_OP_skip:
837 offset = extract_signed_integer (op_ptr, 2, byte_order);
838 op_ptr += 2;
839 op_ptr += offset;
840 goto no_push;
841
842 case DW_OP_bra:
843 offset = extract_signed_integer (op_ptr, 2, byte_order);
844 op_ptr += 2;
845 if (dwarf_expr_fetch (ctx, 0) != 0)
846 op_ptr += offset;
847 dwarf_expr_pop (ctx);
848 goto no_push;
849
850 case DW_OP_nop:
851 goto no_push;
852
853 case DW_OP_piece:
854 {
855 ULONGEST size;
856
857 /* Record the piece. */
858 op_ptr = read_uleb128 (op_ptr, op_end, &size);
cf7f2e2d 859 add_piece (ctx, 8 * size, 0);
5796c8dc
SS
860
861 /* Pop off the address/regnum, and reset the location
862 type. */
cf7f2e2d
JM
863 if (ctx->location != DWARF_VALUE_LITERAL
864 && ctx->location != DWARF_VALUE_OPTIMIZED_OUT)
5796c8dc
SS
865 dwarf_expr_pop (ctx);
866 ctx->location = DWARF_VALUE_MEMORY;
867 }
868 goto no_push;
869
cf7f2e2d
JM
870 case DW_OP_bit_piece:
871 {
872 ULONGEST size, offset;
873
874 /* Record the piece. */
875 op_ptr = read_uleb128 (op_ptr, op_end, &size);
876 op_ptr = read_uleb128 (op_ptr, op_end, &offset);
877 add_piece (ctx, size, offset);
878
879 /* Pop off the address/regnum, and reset the location
880 type. */
881 if (ctx->location != DWARF_VALUE_LITERAL
882 && ctx->location != DWARF_VALUE_OPTIMIZED_OUT)
883 dwarf_expr_pop (ctx);
884 ctx->location = DWARF_VALUE_MEMORY;
885 }
886 goto no_push;
887
5796c8dc
SS
888 case DW_OP_GNU_uninit:
889 if (op_ptr != op_end)
890 error (_("DWARF-2 expression error: DW_OP_GNU_uninit must always "
891 "be the very last op."));
892
893 ctx->initialized = 0;
894 goto no_push;
895
cf7f2e2d
JM
896 case DW_OP_call2:
897 result = extract_unsigned_integer (op_ptr, 2, byte_order);
898 op_ptr += 2;
899 ctx->dwarf_call (ctx, result);
900 goto no_push;
901
902 case DW_OP_call4:
903 result = extract_unsigned_integer (op_ptr, 4, byte_order);
904 op_ptr += 4;
905 ctx->dwarf_call (ctx, result);
906 goto no_push;
c50c785c
JM
907
908 case DW_OP_GNU_entry_value:
909 /* This operation is not yet supported by GDB. */
910 ctx->location = DWARF_VALUE_OPTIMIZED_OUT;
911 ctx->stack_len = 0;
912 ctx->num_pieces = 0;
913 goto abort_expression;
cf7f2e2d 914
5796c8dc
SS
915 default:
916 error (_("Unhandled dwarf expression opcode 0x%x"), op);
917 }
918
919 /* Most things push a result value. */
920 dwarf_expr_push (ctx, result, in_stack_memory);
c50c785c
JM
921 no_push:
922 ;
5796c8dc
SS
923 }
924
c50c785c
JM
925 /* To simplify our main caller, if the result is an implicit
926 pointer, then make a pieced value. This is ok because we can't
927 have implicit pointers in contexts where pieces are invalid. */
928 if (ctx->location == DWARF_VALUE_IMPLICIT_POINTER)
929 add_piece (ctx, 8 * ctx->addr_size, 0);
930
931abort_expression:
5796c8dc
SS
932 ctx->recursion_depth--;
933 gdb_assert (ctx->recursion_depth >= 0);
cf7f2e2d 934#undef sign_ext
5796c8dc 935}