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