OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [gdb-6.8/] [gdb/] [dwarf2expr.c] - Blame information for rev 840

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 24 jeremybenn
/* DWARF 2 Expression Evaluator.
2
 
3
   Copyright (C) 2001, 2002, 2003, 2005, 2007, 2008
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 "elf/dwarf2.h"
29
#include "dwarf2expr.h"
30
 
31
/* Local prototypes.  */
32
 
33
static void execute_stack_op (struct dwarf_expr_context *,
34
                              gdb_byte *, gdb_byte *);
35
static struct type *unsigned_address_type (void);
36
 
37
/* Create a new context for the expression evaluator.  */
38
 
39
struct dwarf_expr_context *
40
new_dwarf_expr_context (void)
41
{
42
  struct dwarf_expr_context *retval;
43
  retval = xcalloc (1, sizeof (struct dwarf_expr_context));
44
  retval->stack_len = 0;
45
  retval->stack_allocated = 10;
46
  retval->stack = xmalloc (retval->stack_allocated * sizeof (CORE_ADDR));
47
  retval->num_pieces = 0;
48
  retval->pieces = 0;
49
  return retval;
50
}
51
 
52
/* Release the memory allocated to CTX.  */
53
 
54
void
55
free_dwarf_expr_context (struct dwarf_expr_context *ctx)
56
{
57
  xfree (ctx->stack);
58
  xfree (ctx->pieces);
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
 
65
static void
66
dwarf_expr_grow_stack (struct dwarf_expr_context *ctx, size_t need)
67
{
68
  if (ctx->stack_len + need > ctx->stack_allocated)
69
    {
70
      size_t newlen = ctx->stack_len + need + 10;
71
      ctx->stack = xrealloc (ctx->stack,
72
                             newlen * sizeof (CORE_ADDR));
73
      ctx->stack_allocated = newlen;
74
    }
75
}
76
 
77
/* Push VALUE onto CTX's stack.  */
78
 
79
void
80
dwarf_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
 
88
void
89
dwarf_expr_pop (struct dwarf_expr_context *ctx)
90
{
91
  if (ctx->stack_len <= 0)
92
    error (_("dwarf expression stack underflow"));
93
  ctx->stack_len--;
94
}
95
 
96
/* Retrieve the N'th item on CTX's stack.  */
97
 
98
CORE_ADDR
99
dwarf_expr_fetch (struct dwarf_expr_context *ctx, int n)
100
{
101
  if (ctx->stack_len <= n)
102
     error (_("Asked for position %d of stack, stack only has %d elements on it."),
103
            n, ctx->stack_len);
104
  return ctx->stack[ctx->stack_len - (1 + n)];
105
 
106
}
107
 
108
/* Add a new piece to CTX's piece list.  */
109
static void
110
add_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
 
131
/* Evaluate the expression at ADDR (LEN bytes long) using the context
132
   CTX.  */
133
 
134
void
135
dwarf_expr_eval (struct dwarf_expr_context *ctx, gdb_byte *addr, size_t len)
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
 
144
gdb_byte *
145
read_uleb128 (gdb_byte *buf, gdb_byte *buf_end, ULONGEST * r)
146
{
147
  unsigned shift = 0;
148
  ULONGEST result = 0;
149
  gdb_byte byte;
150
 
151
  while (1)
152
    {
153
      if (buf >= buf_end)
154
        error (_("read_uleb128: Corrupted DWARF expression."));
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
 
170
gdb_byte *
171
read_sleb128 (gdb_byte *buf, gdb_byte *buf_end, LONGEST * r)
172
{
173
  unsigned shift = 0;
174
  LONGEST result = 0;
175
  gdb_byte byte;
176
 
177
  while (1)
178
    {
179
      if (buf >= buf_end)
180
        error (_("read_sleb128: Corrupted DWARF expression."));
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
 
199
CORE_ADDR
200
dwarf2_read_address (gdb_byte *buf, gdb_byte *buf_end, int *bytes_read)
201
{
202
  CORE_ADDR result;
203
 
204
  if (buf_end - buf < gdbarch_addr_bit (current_gdbarch) / TARGET_CHAR_BIT)
205
    error (_("dwarf2_read_address: Corrupted DWARF expression."));
206
 
207
  *bytes_read = gdbarch_addr_bit (current_gdbarch) / TARGET_CHAR_BIT;
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,
235
                                  gdbarch_addr_bit (current_gdbarch)
236
                                    / TARGET_CHAR_BIT)));
237
 
238
  return result;
239
}
240
 
241
/* Return the type of an address, for unsigned arithmetic.  */
242
 
243
static struct type *
244
unsigned_address_type (void)
245
{
246
  switch (gdbarch_addr_bit (current_gdbarch) / TARGET_CHAR_BIT)
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__,
256
                      _("Unsupported address size.\n"));
257
    }
258
}
259
 
260
/* Return the type of an address, for signed arithmetic.  */
261
 
262
static struct type *
263
signed_address_type (void)
264
{
265
  switch (gdbarch_addr_bit (current_gdbarch) / TARGET_CHAR_BIT)
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__,
275
                      _("Unsupported address size.\n"));
276
    }
277
}
278
 
279
/* The engine for the expression evaluator.  Using the context in CTX,
280
   evaluate the expression between OP_PTR and OP_END.  */
281
 
282
static void
283
execute_stack_op (struct dwarf_expr_context *ctx,
284
                  gdb_byte *op_ptr, gdb_byte *op_end)
285
{
286
  ctx->in_reg = 0;
287
  ctx->initialized = 1;  /* Default is initialized.  */
288
 
289
  while (op_ptr < op_end)
290
    {
291
      enum dwarf_location_atom op = *op_ptr++;
292
      CORE_ADDR result;
293
      ULONGEST uoffset, reg;
294
      LONGEST offset;
295
      int bytes_read;
296
 
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:
335
          result = dwarf2_read_address (op_ptr, op_end, &bytes_read);
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:
414
          if (op_ptr != op_end
415
              && *op_ptr != DW_OP_piece
416
              && *op_ptr != DW_OP_GNU_uninit)
417
            error (_("DWARF-2 expression error: DW_OP_reg operations must be "
418
                   "used either alone or in conjuction with DW_OP_piece."));
419
 
420
          result = op - DW_OP_reg0;
421
          ctx->in_reg = 1;
422
 
423
          break;
424
 
425
        case DW_OP_regx:
426
          op_ptr = read_uleb128 (op_ptr, op_end, &reg);
427
          if (op_ptr != op_end && *op_ptr != DW_OP_piece)
428
            error (_("DWARF-2 expression error: DW_OP_reg operations must be "
429
                   "used either alone or in conjuction with DW_OP_piece."));
430
 
431
          result = reg;
432
          ctx->in_reg = 1;
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);
469
            result = (ctx->read_reg) (ctx->baton, op - DW_OP_breg0);
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);
477
            result = (ctx->read_reg) (ctx->baton, reg);
478
            result += offset;
479
          }
480
          break;
481
        case DW_OP_fbreg:
482
          {
483
            gdb_byte *datastart;
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;
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.  */
496
            (ctx->get_frame_base) (ctx->baton, &datastart, &datalen);
497
            dwarf_expr_eval (ctx, datastart, datalen);
498
            result = dwarf_expr_fetch (ctx, 0);
499
            if (ctx->in_reg)
500
              result = (ctx->read_reg) (ctx->baton, result);
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)
528
               error (_("Not enough elements for DW_OP_rot. Need 3, have %d."),
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
              {
553
                gdb_byte *buf = alloca (gdbarch_addr_bit (current_gdbarch)
554
                                          / TARGET_CHAR_BIT);
555
                int bytes_read;
556
 
557
                (ctx->read_mem) (ctx->baton, buf, result,
558
                                 gdbarch_addr_bit (current_gdbarch)
559
                                   / TARGET_CHAR_BIT);
560
                result = dwarf2_read_address (buf,
561
                                              buf + (gdbarch_addr_bit
562
                                                       (current_gdbarch)
563
                                                     / TARGET_CHAR_BIT),
564
                                              &bytes_read);
565
              }
566
              break;
567
 
568
            case DW_OP_deref_size:
569
              {
570
                gdb_byte *buf
571
                   = alloca (gdbarch_addr_bit (current_gdbarch)
572
                              / TARGET_CHAR_BIT);
573
                int bytes_read;
574
 
575
                (ctx->read_mem) (ctx->baton, buf, result, *op_ptr++);
576
                result = dwarf2_read_address (buf,
577
                                              buf + (gdbarch_addr_bit
578
                                                      (current_gdbarch)
579
                                                     / TARGET_CHAR_BIT),
580
                                              &bytes_read);
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
 
628
            first = dwarf_expr_fetch (ctx, 0);
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;
641
                break;
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;
662
                break;
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__,
690
                                _("Can't be reached."));
691
              }
692
            result = value_as_long (value_binop (val1, val2, binop));
693
          }
694
          break;
695
 
696
        case DW_OP_GNU_push_tls_address:
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.  */
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
 
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
 
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
 
751
        default:
752
          error (_("Unhandled dwarf expression opcode 0x%x"), op);
753
        }
754
 
755
      /* Most things push a result value.  */
756
      dwarf_expr_push (ctx, result);
757
    no_push:;
758
    }
759
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.