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

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-7.1/] [gdb/] [dwarf2expr.c] - Blame information for rev 227

Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

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