projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Fix spelling typo in previous delta
[deliverable/binutils-gdb.git] / gdb / dwarf2expr.c
CommitLineData
852483bc
MK		 1/* DWARF 2 Expression Evaluator.
2
9b254dd1
DJ		 3 Copyright (C) 2001, 2002, 2003, 2005, 2007, 2008
4 Free Software Foundation, Inc.
852483bc 5
4c2df51b
DJ		 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
a9762ec7 12 the Free Software Foundation; either version 3 of the License, or
4c2df51b
DJ		 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
a9762ec7 21 along with this program. If not, see <http://www.gnu.org/licenses/>. */
4c2df51b
DJ		 22
23#include "defs.h"
24#include "symtab.h"
25#include "gdbtypes.h"
26#include "value.h"
27#include "gdbcore.h"
28#include "elf/dwarf2.h"
29#include "dwarf2expr.h"
30
31/* Local prototypes. */
32
33static void execute_stack_op (struct dwarf_expr_context *,
852483bc 34 gdb_byte *, gdb_byte *);
ace186d4 35static struct type *unsigned_address_type (void);
4c2df51b
DJ		 36
37/* Create a new context for the expression evaluator. */
38
39struct dwarf_expr_context *
e4adbba9 40new_dwarf_expr_context (void)
4c2df51b
DJ		 41{
42 struct dwarf_expr_context *retval;
43 retval = xcalloc (1, sizeof (struct dwarf_expr_context));
18ec9831
KB		 44 retval->stack_len = 0;
45 retval->stack_allocated = 10;
46 retval->stack = xmalloc (retval->stack_allocated * sizeof (CORE_ADDR));
87808bd6
JB		 47 retval->num_pieces = 0;
48 retval->pieces = 0;
4c2df51b
DJ		 49 return retval;
50}
51
52/* Release the memory allocated to CTX. */
53
54void
55free_dwarf_expr_context (struct dwarf_expr_context *ctx)
56{
57 xfree (ctx->stack);
87808bd6 58 xfree (ctx->pieces);
4c2df51b
DJ		 59 xfree (ctx);
60}
61
62/* Expand the memory allocated to CTX's stack to contain at least
63 NEED more elements than are currently used. */
64
65static void
66dwarf_expr_grow_stack (struct dwarf_expr_context *ctx, size_t need)
67{
68 if (ctx->stack_len + need > ctx->stack_allocated)
69 {
18ec9831 70 size_t newlen = ctx->stack_len + need + 10;
4c2df51b 71 ctx->stack = xrealloc (ctx->stack,
18ec9831
KB		 72 newlen * sizeof (CORE_ADDR));
73 ctx->stack_allocated = newlen;
4c2df51b
DJ		 74 }
75}
76
77/* Push VALUE onto CTX's stack. */
78
79void
80dwarf_expr_push (struct dwarf_expr_context *ctx, CORE_ADDR value)
81{
82 dwarf_expr_grow_stack (ctx, 1);
83 ctx->stack[ctx->stack_len++] = value;
84}
85
86/* Pop the top item off of CTX's stack. */
87
88void
89dwarf_expr_pop (struct dwarf_expr_context *ctx)
90{
91 if (ctx->stack_len <= 0)
8a3fe4f8 92 error (_("dwarf expression stack underflow"));
4c2df51b
DJ		 93 ctx->stack_len--;
94}
95
96/* Retrieve the N'th item on CTX's stack. */
97
98CORE_ADDR
99dwarf_expr_fetch (struct dwarf_expr_context *ctx, int n)
100{
ef0fdf07 101 if (ctx->stack_len <= n)
8a3fe4f8 102 error (_("Asked for position %d of stack, stack only has %d elements on it."),
4c2df51b
DJ		 103 n, ctx->stack_len);
104 return ctx->stack[ctx->stack_len - (1 + n)];
105
106}
107
87808bd6
JB		 108/* Add a new piece to CTX's piece list. */
109static void
110add_piece (struct dwarf_expr_context *ctx,
111 int in_reg, CORE_ADDR value, ULONGEST size)
112{
113 struct dwarf_expr_piece *p;
114
115 ctx->num_pieces++;
116
117 if (ctx->pieces)
118 ctx->pieces = xrealloc (ctx->pieces,
119 (ctx->num_pieces
120 * sizeof (struct dwarf_expr_piece)));
121 else
122 ctx->pieces = xmalloc (ctx->num_pieces
123 * sizeof (struct dwarf_expr_piece));
124
125 p = &ctx->pieces[ctx->num_pieces - 1];
126 p->in_reg = in_reg;
127 p->value = value;
128 p->size = size;
129}
130
4c2df51b
DJ		 131/* Evaluate the expression at ADDR (LEN bytes long) using the context
132 CTX. */
133
134void
852483bc 135dwarf_expr_eval (struct dwarf_expr_context *ctx, gdb_byte *addr, size_t len)
4c2df51b
DJ		 136{
137 execute_stack_op (ctx, addr, addr + len);
138}
139
140/* Decode the unsigned LEB128 constant at BUF into the variable pointed to
141 by R, and return the new value of BUF. Verify that it doesn't extend
142 past BUF_END. */
143
852483bc
MK		 144gdb_byte *
145read_uleb128 (gdb_byte *buf, gdb_byte *buf_end, ULONGEST * r)
4c2df51b
DJ		 146{
147 unsigned shift = 0;
148 ULONGEST result = 0;
852483bc 149 gdb_byte byte;
4c2df51b
DJ		 150
151 while (1)
152 {
153 if (buf >= buf_end)
8a3fe4f8 154 error (_("read_uleb128: Corrupted DWARF expression."));
4c2df51b
DJ		 155
156 byte = *buf++;
157 result |= (byte & 0x7f) << shift;
158 if ((byte & 0x80) == 0)
159 break;
160 shift += 7;
161 }
162 *r = result;
163 return buf;
164}
165
166/* Decode the signed LEB128 constant at BUF into the variable pointed to
167 by R, and return the new value of BUF. Verify that it doesn't extend
168 past BUF_END. */
169
852483bc
MK		 170gdb_byte *
171read_sleb128 (gdb_byte *buf, gdb_byte *buf_end, LONGEST * r)
4c2df51b
DJ		 172{
173 unsigned shift = 0;
174 LONGEST result = 0;
852483bc 175 gdb_byte byte;
4c2df51b
DJ		 176
177 while (1)
178 {
179 if (buf >= buf_end)
8a3fe4f8 180 error (_("read_sleb128: Corrupted DWARF expression."));
4c2df51b
DJ		 181
182 byte = *buf++;
183 result |= (byte & 0x7f) << shift;
184 shift += 7;
185 if ((byte & 0x80) == 0)
186 break;
187 }
188 if (shift < (sizeof (*r) * 8) && (byte & 0x40) != 0)
189 result |= -(1 << shift);
190
191 *r = result;
192 return buf;
193}
194
195/* Read an address from BUF, and verify that it doesn't extend past
196 BUF_END. The address is returned, and *BYTES_READ is set to the
197 number of bytes read from BUF. */
198
0d53c4c4 199CORE_ADDR
852483bc 200dwarf2_read_address (gdb_byte *buf, gdb_byte *buf_end, int *bytes_read)
4c2df51b
DJ		 201{
202 CORE_ADDR result;
203
17a912b6 204 if (buf_end - buf < gdbarch_addr_bit (current_gdbarch) / TARGET_CHAR_BIT)
8a3fe4f8 205 error (_("dwarf2_read_address: Corrupted DWARF expression."));
4c2df51b 206
17a912b6 207 *bytes_read = gdbarch_addr_bit (current_gdbarch) / TARGET_CHAR_BIT;
ace186d4
KB		 208
209 /* For most architectures, calling extract_unsigned_integer() alone
210 is sufficient for extracting an address. However, some
211 architectures (e.g. MIPS) use signed addresses and using
212 extract_unsigned_integer() will not produce a correct
213 result. Turning the unsigned integer into a value and then
214 decomposing that value as an address will cause
215 gdbarch_integer_to_address() to be invoked for those
216 architectures which require it. Thus, using value_as_address()
217 will produce the correct result for both types of architectures.
218
219 One concern regarding the use of values for this purpose is
220 efficiency. Obviously, these extra calls will take more time to
221 execute and creating a value takes more space, space which will
222 have to be garbage collected at a later time. If constructing
223 and then decomposing a value for this purpose proves to be too
224 inefficient, then gdbarch_integer_to_address() can be called
225 directly.
226
227 The use of `unsigned_address_type' in the code below refers to
228 the type of buf and has no bearing on the signedness of the
229 address being returned. */
230
231 result = value_as_address (value_from_longest
232 (unsigned_address_type (),
233 extract_unsigned_integer
234 (buf,
17a912b6
UW		 235 gdbarch_addr_bit (current_gdbarch)
236 / TARGET_CHAR_BIT)));
ace186d4 237
4c2df51b
DJ		 238 return result;
239}
240
241/* Return the type of an address, for unsigned arithmetic. */
242
243static struct type *
244unsigned_address_type (void)
245{
17a912b6 246 switch (gdbarch_addr_bit (current_gdbarch) / TARGET_CHAR_BIT)
4c2df51b
DJ		 247 {
248 case 2:
249 return builtin_type_uint16;
250 case 4:
251 return builtin_type_uint32;
252 case 8:
253 return builtin_type_uint64;
254 default:
255 internal_error (__FILE__, __LINE__,
e2e0b3e5 256 _("Unsupported address size.\n"));
4c2df51b
DJ		 257 }
258}
259
260/* Return the type of an address, for signed arithmetic. */
261
262static struct type *
263signed_address_type (void)
264{
17a912b6 265 switch (gdbarch_addr_bit (current_gdbarch) / TARGET_CHAR_BIT)
4c2df51b
DJ		 266 {
267 case 2:
268 return builtin_type_int16;
269 case 4:
270 return builtin_type_int32;
271 case 8:
272 return builtin_type_int64;
273 default:
274 internal_error (__FILE__, __LINE__,
e2e0b3e5 275 _("Unsupported address size.\n"));
4c2df51b
DJ		 276 }
277}
278\f
279/* The engine for the expression evaluator. Using the context in CTX,
280 evaluate the expression between OP_PTR and OP_END. */
281
282static void
852483bc
MK		 283execute_stack_op (struct dwarf_expr_context *ctx,
284 gdb_byte *op_ptr, gdb_byte *op_end)
4c2df51b 285{
18ec9831 286 ctx->in_reg = 0;
42be36b3 287 ctx->initialized = 1; /* Default is initialized. */
18ec9831 288
4c2df51b
DJ		 289 while (op_ptr < op_end)
290 {
291 enum dwarf_location_atom op = *op_ptr++;
61fbb938 292 CORE_ADDR result;
4c2df51b
DJ		 293 ULONGEST uoffset, reg;
294 LONGEST offset;
295 int bytes_read;
4c2df51b 296
4c2df51b
DJ		 297 switch (op)
298 {
299 case DW_OP_lit0:
300 case DW_OP_lit1:
301 case DW_OP_lit2:
302 case DW_OP_lit3:
303 case DW_OP_lit4:
304 case DW_OP_lit5:
305 case DW_OP_lit6:
306 case DW_OP_lit7:
307 case DW_OP_lit8:
308 case DW_OP_lit9:
309 case DW_OP_lit10:
310 case DW_OP_lit11:
311 case DW_OP_lit12:
312 case DW_OP_lit13:
313 case DW_OP_lit14:
314 case DW_OP_lit15:
315 case DW_OP_lit16:
316 case DW_OP_lit17:
317 case DW_OP_lit18:
318 case DW_OP_lit19:
319 case DW_OP_lit20:
320 case DW_OP_lit21:
321 case DW_OP_lit22:
322 case DW_OP_lit23:
323 case DW_OP_lit24:
324 case DW_OP_lit25:
325 case DW_OP_lit26:
326 case DW_OP_lit27:
327 case DW_OP_lit28:
328 case DW_OP_lit29:
329 case DW_OP_lit30:
330 case DW_OP_lit31:
331 result = op - DW_OP_lit0;
332 break;
333
334 case DW_OP_addr:
0d53c4c4 335 result = dwarf2_read_address (op_ptr, op_end, &bytes_read);
4c2df51b
DJ		 336 op_ptr += bytes_read;
337 break;
338
339 case DW_OP_const1u:
340 result = extract_unsigned_integer (op_ptr, 1);
341 op_ptr += 1;
342 break;
343 case DW_OP_const1s:
344 result = extract_signed_integer (op_ptr, 1);
345 op_ptr += 1;
346 break;
347 case DW_OP_const2u:
348 result = extract_unsigned_integer (op_ptr, 2);
349 op_ptr += 2;
350 break;
351 case DW_OP_const2s:
352 result = extract_signed_integer (op_ptr, 2);
353 op_ptr += 2;
354 break;
355 case DW_OP_const4u:
356 result = extract_unsigned_integer (op_ptr, 4);
357 op_ptr += 4;
358 break;
359 case DW_OP_const4s:
360 result = extract_signed_integer (op_ptr, 4);
361 op_ptr += 4;
362 break;
363 case DW_OP_const8u:
364 result = extract_unsigned_integer (op_ptr, 8);
365 op_ptr += 8;
366 break;
367 case DW_OP_const8s:
368 result = extract_signed_integer (op_ptr, 8);
369 op_ptr += 8;
370 break;
371 case DW_OP_constu:
372 op_ptr = read_uleb128 (op_ptr, op_end, &uoffset);
373 result = uoffset;
374 break;
375 case DW_OP_consts:
376 op_ptr = read_sleb128 (op_ptr, op_end, &offset);
377 result = offset;
378 break;
379
380 /* The DW_OP_reg operations are required to occur alone in
381 location expressions. */
382 case DW_OP_reg0:
383 case DW_OP_reg1:
384 case DW_OP_reg2:
385 case DW_OP_reg3:
386 case DW_OP_reg4:
387 case DW_OP_reg5:
388 case DW_OP_reg6:
389 case DW_OP_reg7:
390 case DW_OP_reg8:
391 case DW_OP_reg9:
392 case DW_OP_reg10:
393 case DW_OP_reg11:
394 case DW_OP_reg12:
395 case DW_OP_reg13:
396 case DW_OP_reg14:
397 case DW_OP_reg15:
398 case DW_OP_reg16:
399 case DW_OP_reg17:
400 case DW_OP_reg18:
401 case DW_OP_reg19:
402 case DW_OP_reg20:
403 case DW_OP_reg21:
404 case DW_OP_reg22:
405 case DW_OP_reg23:
406 case DW_OP_reg24:
407 case DW_OP_reg25:
408 case DW_OP_reg26:
409 case DW_OP_reg27:
410 case DW_OP_reg28:
411 case DW_OP_reg29:
412 case DW_OP_reg30:
413 case DW_OP_reg31:
42be36b3
CT		 414 if (op_ptr != op_end
415 && *op_ptr != DW_OP_piece
416 && *op_ptr != DW_OP_GNU_uninit)
8a3fe4f8
AC		 417 error (_("DWARF-2 expression error: DW_OP_reg operations must be "
418 "used either alone or in conjuction with DW_OP_piece."));
4c2df51b 419
61fbb938
DJ		 420 result = op - DW_OP_reg0;
421 ctx->in_reg = 1;
4c2df51b
DJ		 422
423 break;
424
425 case DW_OP_regx:
426 op_ptr = read_uleb128 (op_ptr, op_end, &reg);
18ec9831 427 if (op_ptr != op_end && *op_ptr != DW_OP_piece)
8a3fe4f8
AC		 428 error (_("DWARF-2 expression error: DW_OP_reg operations must be "
429 "used either alone or in conjuction with DW_OP_piece."));
4c2df51b 430
61fbb938
DJ		 431 result = reg;
432 ctx->in_reg = 1;
4c2df51b
DJ		 433 break;
434
435 case DW_OP_breg0:
436 case DW_OP_breg1:
437 case DW_OP_breg2:
438 case DW_OP_breg3:
439 case DW_OP_breg4:
440 case DW_OP_breg5:
441 case DW_OP_breg6:
442 case DW_OP_breg7:
443 case DW_OP_breg8:
444 case DW_OP_breg9:
445 case DW_OP_breg10:
446 case DW_OP_breg11:
447 case DW_OP_breg12:
448 case DW_OP_breg13:
449 case DW_OP_breg14:
450 case DW_OP_breg15:
451 case DW_OP_breg16:
452 case DW_OP_breg17:
453 case DW_OP_breg18:
454 case DW_OP_breg19:
455 case DW_OP_breg20:
456 case DW_OP_breg21:
457 case DW_OP_breg22:
458 case DW_OP_breg23:
459 case DW_OP_breg24:
460 case DW_OP_breg25:
461 case DW_OP_breg26:
462 case DW_OP_breg27:
463 case DW_OP_breg28:
464 case DW_OP_breg29:
465 case DW_OP_breg30:
466 case DW_OP_breg31:
467 {
468 op_ptr = read_sleb128 (op_ptr, op_end, &offset);
61fbb938 469 result = (ctx->read_reg) (ctx->baton, op - DW_OP_breg0);
4c2df51b
DJ		 470 result += offset;
471 }
472 break;
473 case DW_OP_bregx:
474 {
475 op_ptr = read_uleb128 (op_ptr, op_end, &reg);
476 op_ptr = read_sleb128 (op_ptr, op_end, &offset);
61fbb938 477 result = (ctx->read_reg) (ctx->baton, reg);
4c2df51b
DJ		 478 result += offset;
479 }
480 break;
481 case DW_OP_fbreg:
482 {
852483bc 483 gdb_byte *datastart;
4c2df51b
DJ		 484 size_t datalen;
485 unsigned int before_stack_len;
486
487 op_ptr = read_sleb128 (op_ptr, op_end, &offset);
488 /* Rather than create a whole new context, we simply
489 record the stack length before execution, then reset it
490 afterwards, effectively erasing whatever the recursive
491 call put there. */
492 before_stack_len = ctx->stack_len;
da62e633
AC		 493 /* FIXME: cagney/2003-03-26: This code should be using
494 get_frame_base_address(), and then implement a dwarf2
495 specific this_base method. */
4c2df51b
DJ		 496 (ctx->get_frame_base) (ctx->baton, &datastart, &datalen);
497 dwarf_expr_eval (ctx, datastart, datalen);
498 result = dwarf_expr_fetch (ctx, 0);
61fbb938
DJ		 499 if (ctx->in_reg)
500 result = (ctx->read_reg) (ctx->baton, result);
4c2df51b
DJ		 501 result = result + offset;
502 ctx->stack_len = before_stack_len;
503 ctx->in_reg = 0;
504 }
505 break;
506 case DW_OP_dup:
507 result = dwarf_expr_fetch (ctx, 0);
508 break;
509
510 case DW_OP_drop:
511 dwarf_expr_pop (ctx);
512 goto no_push;
513
514 case DW_OP_pick:
515 offset = *op_ptr++;
516 result = dwarf_expr_fetch (ctx, offset);
517 break;
518
519 case DW_OP_over:
520 result = dwarf_expr_fetch (ctx, 1);
521 break;
522
523 case DW_OP_rot:
524 {
525 CORE_ADDR t1, t2, t3;
526
527 if (ctx->stack_len < 3)
8a3fe4f8 528 error (_("Not enough elements for DW_OP_rot. Need 3, have %d."),
4c2df51b
DJ		 529 ctx->stack_len);
530 t1 = ctx->stack[ctx->stack_len - 1];
531 t2 = ctx->stack[ctx->stack_len - 2];
532 t3 = ctx->stack[ctx->stack_len - 3];
533 ctx->stack[ctx->stack_len - 1] = t2;
534 ctx->stack[ctx->stack_len - 2] = t3;
535 ctx->stack[ctx->stack_len - 3] = t1;
536 goto no_push;
537 }
538
539 case DW_OP_deref:
540 case DW_OP_deref_size:
541 case DW_OP_abs:
542 case DW_OP_neg:
543 case DW_OP_not:
544 case DW_OP_plus_uconst:
545 /* Unary operations. */
546 result = dwarf_expr_fetch (ctx, 0);
547 dwarf_expr_pop (ctx);
548
549 switch (op)
550 {
551 case DW_OP_deref:
552 {
17a912b6
UW		 553 gdb_byte *buf = alloca (gdbarch_addr_bit (current_gdbarch)
554 / TARGET_CHAR_BIT);
4c2df51b
DJ		 555 int bytes_read;
556
557 (ctx->read_mem) (ctx->baton, buf, result,
17a912b6
UW		 558 gdbarch_addr_bit (current_gdbarch)
559 / TARGET_CHAR_BIT);
0d53c4c4 560 result = dwarf2_read_address (buf,
17a912b6
UW		 561 buf + (gdbarch_addr_bit
562 (current_gdbarch)
0d53c4c4
DJ		 563 / TARGET_CHAR_BIT),
564 &bytes_read);
4c2df51b
DJ		 565 }
566 break;
567
568 case DW_OP_deref_size:
569 {
17a912b6
UW		 570 gdb_byte *buf
571 = alloca (gdbarch_addr_bit (current_gdbarch)
572 / TARGET_CHAR_BIT);
4c2df51b
DJ		 573 int bytes_read;
574
575 (ctx->read_mem) (ctx->baton, buf, result, *op_ptr++);
0d53c4c4 576 result = dwarf2_read_address (buf,
17a912b6
UW		 577 buf + (gdbarch_addr_bit
578 (current_gdbarch)
0d53c4c4
DJ		 579 / TARGET_CHAR_BIT),
580 &bytes_read);
4c2df51b
DJ		 581 }
582 break;
583
584 case DW_OP_abs:
585 if ((signed int) result < 0)
586 result = -result;
587 break;
588 case DW_OP_neg:
589 result = -result;
590 break;
591 case DW_OP_not:
592 result = ~result;
593 break;
594 case DW_OP_plus_uconst:
595 op_ptr = read_uleb128 (op_ptr, op_end, &reg);
596 result += reg;
597 break;
598 }
599 break;
600
601 case DW_OP_and:
602 case DW_OP_div:
603 case DW_OP_minus:
604 case DW_OP_mod:
605 case DW_OP_mul:
606 case DW_OP_or:
607 case DW_OP_plus:
608 case DW_OP_shl:
609 case DW_OP_shr:
610 case DW_OP_shra:
611 case DW_OP_xor:
612 case DW_OP_le:
613 case DW_OP_ge:
614 case DW_OP_eq:
615 case DW_OP_lt:
616 case DW_OP_gt:
617 case DW_OP_ne:
618 {
619 /* Binary operations. Use the value engine to do computations in
620 the right width. */
621 CORE_ADDR first, second;
622 enum exp_opcode binop;
623 struct value *val1, *val2;
624
625 second = dwarf_expr_fetch (ctx, 0);
626 dwarf_expr_pop (ctx);
627
b263358a 628 first = dwarf_expr_fetch (ctx, 0);
4c2df51b
DJ		 629 dwarf_expr_pop (ctx);
630
631 val1 = value_from_longest (unsigned_address_type (), first);
632 val2 = value_from_longest (unsigned_address_type (), second);
633
634 switch (op)
635 {
636 case DW_OP_and:
637 binop = BINOP_BITWISE_AND;
638 break;
639 case DW_OP_div:
640 binop = BINOP_DIV;
99c87dab 641 break;
4c2df51b
DJ		 642 case DW_OP_minus:
643 binop = BINOP_SUB;
644 break;
645 case DW_OP_mod:
646 binop = BINOP_MOD;
647 break;
648 case DW_OP_mul:
649 binop = BINOP_MUL;
650 break;
651 case DW_OP_or:
652 binop = BINOP_BITWISE_IOR;
653 break;
654 case DW_OP_plus:
655 binop = BINOP_ADD;
656 break;
657 case DW_OP_shl:
658 binop = BINOP_LSH;
659 break;
660 case DW_OP_shr:
661 binop = BINOP_RSH;
99c87dab 662 break;
4c2df51b
DJ		 663 case DW_OP_shra:
664 binop = BINOP_RSH;
665 val1 = value_from_longest (signed_address_type (), first);
666 break;
667 case DW_OP_xor:
668 binop = BINOP_BITWISE_XOR;
669 break;
670 case DW_OP_le:
671 binop = BINOP_LEQ;
672 break;
673 case DW_OP_ge:
674 binop = BINOP_GEQ;
675 break;
676 case DW_OP_eq:
677 binop = BINOP_EQUAL;
678 break;
679 case DW_OP_lt:
680 binop = BINOP_LESS;
681 break;
682 case DW_OP_gt:
683 binop = BINOP_GTR;
684 break;
685 case DW_OP_ne:
686 binop = BINOP_NOTEQUAL;
687 break;
688 default:
689 internal_error (__FILE__, __LINE__,
e2e0b3e5 690 _("Can't be reached."));
4c2df51b
DJ		 691 }
692 result = value_as_long (value_binop (val1, val2, binop));
693 }
694 break;
695
696 case DW_OP_GNU_push_tls_address:
c3228f12
EZ		 697 /* Variable is at a constant offset in the thread-local
698 storage block into the objfile for the current thread and
699 the dynamic linker module containing this expression. Here
700 we return returns the offset from that base. The top of the
701 stack has the offset from the beginning of the thread
702 control block at which the variable is located. Nothing
703 should follow this operator, so the top of stack would be
704 returned. */
4c2df51b
DJ		 705 result = dwarf_expr_fetch (ctx, 0);
706 dwarf_expr_pop (ctx);
707 result = (ctx->get_tls_address) (ctx->baton, result);
708 break;
709
710 case DW_OP_skip:
711 offset = extract_signed_integer (op_ptr, 2);
712 op_ptr += 2;
713 op_ptr += offset;
714 goto no_push;
715
716 case DW_OP_bra:
717 offset = extract_signed_integer (op_ptr, 2);
718 op_ptr += 2;
719 if (dwarf_expr_fetch (ctx, 0) != 0)
720 op_ptr += offset;
721 dwarf_expr_pop (ctx);
722 goto no_push;
723
724 case DW_OP_nop:
725 goto no_push;
726
87808bd6
JB		 727 case DW_OP_piece:
728 {
729 ULONGEST size;
730 CORE_ADDR addr_or_regnum;
731
732 /* Record the piece. */
733 op_ptr = read_uleb128 (op_ptr, op_end, &size);
734 addr_or_regnum = dwarf_expr_fetch (ctx, 0);
735 add_piece (ctx, ctx->in_reg, addr_or_regnum, size);
736
737 /* Pop off the address/regnum, and clear the in_reg flag. */
738 dwarf_expr_pop (ctx);
739 ctx->in_reg = 0;
740 }
741 goto no_push;
742
42be36b3
CT		 743 case DW_OP_GNU_uninit:
744 if (op_ptr != op_end)
745 error (_("DWARF-2 expression error: DW_OP_GNU_unint must always "
746 "be the very last op."));
747
748 ctx->initialized = 0;
749 goto no_push;
750
4c2df51b 751 default:
8a3fe4f8 752 error (_("Unhandled dwarf expression opcode 0x%x"), op);
4c2df51b
DJ		 753 }
754
755 /* Most things push a result value. */
756 dwarf_expr_push (ctx, result);
757 no_push:;
758 }
759}
GDB Binutils - Deliverables
This page took 0.338412 seconds and 4 git commands to generate.