OpenCores
URL https://opencores.org/ocsvn/openrisc_2011-10-31/openrisc_2011-10-31/trunk

Subversion Repositories openrisc_2011-10-31

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

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 227 jeremybenn
/* DWARF 2 location expression support for GDB.
2
 
3
   Copyright (C) 2003, 2005, 2007, 2008, 2009, 2010
4
   Free Software Foundation, Inc.
5
 
6
   Contributed by Daniel Jacobowitz, MontaVista Software, Inc.
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 "ui-out.h"
25
#include "value.h"
26
#include "frame.h"
27
#include "gdbcore.h"
28
#include "target.h"
29
#include "inferior.h"
30
#include "ax.h"
31
#include "ax-gdb.h"
32
#include "regcache.h"
33
#include "objfiles.h"
34
#include "exceptions.h"
35
#include "block.h"
36
 
37
#include "dwarf2.h"
38
#include "dwarf2expr.h"
39
#include "dwarf2loc.h"
40
#include "dwarf2-frame.h"
41
 
42
#include "gdb_string.h"
43
#include "gdb_assert.h"
44
 
45
static void
46
dwarf_expr_frame_base_1 (struct symbol *framefunc, CORE_ADDR pc,
47
                         gdb_byte **start, size_t *length);
48
 
49
/* A helper function for dealing with location lists.  Given a
50
   symbol baton (BATON) and a pc value (PC), find the appropriate
51
   location expression, set *LOCEXPR_LENGTH, and return a pointer
52
   to the beginning of the expression.  Returns NULL on failure.
53
 
54
   For now, only return the first matching location expression; there
55
   can be more than one in the list.  */
56
 
57
static gdb_byte *
58
find_location_expression (struct dwarf2_loclist_baton *baton,
59
                          size_t *locexpr_length, CORE_ADDR pc)
60
{
61
  CORE_ADDR low, high;
62
  gdb_byte *loc_ptr, *buf_end;
63
  int length;
64
  struct objfile *objfile = dwarf2_per_cu_objfile (baton->per_cu);
65
  struct gdbarch *gdbarch = get_objfile_arch (objfile);
66
  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
67
  unsigned int addr_size = dwarf2_per_cu_addr_size (baton->per_cu);
68
  CORE_ADDR base_mask = ~(~(CORE_ADDR)1 << (addr_size * 8 - 1));
69
  /* Adjust base_address for relocatable objects.  */
70
  CORE_ADDR base_offset = ANOFFSET (objfile->section_offsets,
71
                                    SECT_OFF_TEXT (objfile));
72
  CORE_ADDR base_address = baton->base_address + base_offset;
73
 
74
  loc_ptr = baton->data;
75
  buf_end = baton->data + baton->size;
76
 
77
  while (1)
78
    {
79
      if (buf_end - loc_ptr < 2 * addr_size)
80
        error (_("find_location_expression: Corrupted DWARF expression."));
81
 
82
      low = extract_unsigned_integer (loc_ptr, addr_size, byte_order);
83
      loc_ptr += addr_size;
84
 
85
      /* A base-address-selection entry.  */
86
      if (low == base_mask)
87
        {
88
          base_address = dwarf2_read_address (gdbarch,
89
                                              loc_ptr, buf_end, addr_size);
90
          loc_ptr += addr_size;
91
          continue;
92
        }
93
 
94
      high = extract_unsigned_integer (loc_ptr, addr_size, byte_order);
95
      loc_ptr += addr_size;
96
 
97
      /* An end-of-list entry.  */
98
      if (low == 0 && high == 0)
99
        return NULL;
100
 
101
      /* Otherwise, a location expression entry.  */
102
      low += base_address;
103
      high += base_address;
104
 
105
      length = extract_unsigned_integer (loc_ptr, 2, byte_order);
106
      loc_ptr += 2;
107
 
108
      if (pc >= low && pc < high)
109
        {
110
          *locexpr_length = length;
111
          return loc_ptr;
112
        }
113
 
114
      loc_ptr += length;
115
    }
116
}
117
 
118
/* This is the baton used when performing dwarf2 expression
119
   evaluation.  */
120
struct dwarf_expr_baton
121
{
122
  struct frame_info *frame;
123
  struct objfile *objfile;
124
};
125
 
126
/* Helper functions for dwarf2_evaluate_loc_desc.  */
127
 
128
/* Using the frame specified in BATON, return the value of register
129
   REGNUM, treated as a pointer.  */
130
static CORE_ADDR
131
dwarf_expr_read_reg (void *baton, int dwarf_regnum)
132
{
133
  struct dwarf_expr_baton *debaton = (struct dwarf_expr_baton *) baton;
134
  struct gdbarch *gdbarch = get_frame_arch (debaton->frame);
135
  CORE_ADDR result;
136
  int regnum;
137
 
138
  regnum = gdbarch_dwarf2_reg_to_regnum (gdbarch, dwarf_regnum);
139
  result = address_from_register (builtin_type (gdbarch)->builtin_data_ptr,
140
                                  regnum, debaton->frame);
141
  return result;
142
}
143
 
144
/* Read memory at ADDR (length LEN) into BUF.  */
145
 
146
static void
147
dwarf_expr_read_mem (void *baton, gdb_byte *buf, CORE_ADDR addr, size_t len)
148
{
149
  read_memory (addr, buf, len);
150
}
151
 
152
/* Using the frame specified in BATON, find the location expression
153
   describing the frame base.  Return a pointer to it in START and
154
   its length in LENGTH.  */
155
static void
156
dwarf_expr_frame_base (void *baton, gdb_byte **start, size_t * length)
157
{
158
  /* FIXME: cagney/2003-03-26: This code should be using
159
     get_frame_base_address(), and then implement a dwarf2 specific
160
     this_base method.  */
161
  struct symbol *framefunc;
162
  struct dwarf_expr_baton *debaton = (struct dwarf_expr_baton *) baton;
163
 
164
  /* Use block_linkage_function, which returns a real (not inlined)
165
     function, instead of get_frame_function, which may return an
166
     inlined function.  */
167
  framefunc = block_linkage_function (get_frame_block (debaton->frame, NULL));
168
 
169
  /* If we found a frame-relative symbol then it was certainly within
170
     some function associated with a frame. If we can't find the frame,
171
     something has gone wrong.  */
172
  gdb_assert (framefunc != NULL);
173
 
174
  dwarf_expr_frame_base_1 (framefunc,
175
                           get_frame_address_in_block (debaton->frame),
176
                           start, length);
177
}
178
 
179
static void
180
dwarf_expr_frame_base_1 (struct symbol *framefunc, CORE_ADDR pc,
181
                         gdb_byte **start, size_t *length)
182
{
183
  if (SYMBOL_LOCATION_BATON (framefunc) == NULL)
184
    *start = NULL;
185
  else if (SYMBOL_COMPUTED_OPS (framefunc) == &dwarf2_loclist_funcs)
186
    {
187
      struct dwarf2_loclist_baton *symbaton;
188
 
189
      symbaton = SYMBOL_LOCATION_BATON (framefunc);
190
      *start = find_location_expression (symbaton, length, pc);
191
    }
192
  else
193
    {
194
      struct dwarf2_locexpr_baton *symbaton;
195
      symbaton = SYMBOL_LOCATION_BATON (framefunc);
196
      if (symbaton != NULL)
197
        {
198
          *length = symbaton->size;
199
          *start = symbaton->data;
200
        }
201
      else
202
        *start = NULL;
203
    }
204
 
205
  if (*start == NULL)
206
    error (_("Could not find the frame base for \"%s\"."),
207
           SYMBOL_NATURAL_NAME (framefunc));
208
}
209
 
210
/* Helper function for dwarf2_evaluate_loc_desc.  Computes the CFA for
211
   the frame in BATON.  */
212
 
213
static CORE_ADDR
214
dwarf_expr_frame_cfa (void *baton)
215
{
216
  struct dwarf_expr_baton *debaton = (struct dwarf_expr_baton *) baton;
217
  return dwarf2_frame_cfa (debaton->frame);
218
}
219
 
220
/* Using the objfile specified in BATON, find the address for the
221
   current thread's thread-local storage with offset OFFSET.  */
222
static CORE_ADDR
223
dwarf_expr_tls_address (void *baton, CORE_ADDR offset)
224
{
225
  struct dwarf_expr_baton *debaton = (struct dwarf_expr_baton *) baton;
226
 
227
  return target_translate_tls_address (debaton->objfile, offset);
228
}
229
 
230
struct piece_closure
231
{
232
  /* The number of pieces used to describe this variable.  */
233
  int n_pieces;
234
 
235
  /* The architecture, used only for DWARF_VALUE_STACK.  */
236
  struct gdbarch *arch;
237
 
238
  /* The pieces themselves.  */
239
  struct dwarf_expr_piece *pieces;
240
};
241
 
242
/* Allocate a closure for a value formed from separately-described
243
   PIECES.  */
244
 
245
static struct piece_closure *
246
allocate_piece_closure (int n_pieces, struct dwarf_expr_piece *pieces,
247
                        struct gdbarch *arch)
248
{
249
  struct piece_closure *c = XZALLOC (struct piece_closure);
250
 
251
  c->n_pieces = n_pieces;
252
  c->arch = arch;
253
  c->pieces = XCALLOC (n_pieces, struct dwarf_expr_piece);
254
 
255
  memcpy (c->pieces, pieces, n_pieces * sizeof (struct dwarf_expr_piece));
256
 
257
  return c;
258
}
259
 
260
static void
261
read_pieced_value (struct value *v)
262
{
263
  int i;
264
  long offset = 0;
265
  gdb_byte *contents;
266
  struct piece_closure *c = (struct piece_closure *) value_computed_closure (v);
267
  struct frame_info *frame = frame_find_by_id (VALUE_FRAME_ID (v));
268
 
269
  contents = value_contents_raw (v);
270
  for (i = 0; i < c->n_pieces; i++)
271
    {
272
      struct dwarf_expr_piece *p = &c->pieces[i];
273
      switch (p->location)
274
        {
275
        case DWARF_VALUE_REGISTER:
276
          {
277
            struct gdbarch *arch = get_frame_arch (frame);
278
            int gdb_regnum = gdbarch_dwarf2_reg_to_regnum (arch,
279
                                                           p->v.expr.value);
280
            int reg_offset = 0;
281
 
282
            if (gdbarch_byte_order (arch) == BFD_ENDIAN_BIG
283
                && p->size < register_size (arch, gdb_regnum))
284
              /* Big-endian, and we want less than full size.  */
285
              reg_offset = register_size (arch, gdb_regnum) - p->size;
286
 
287
            get_frame_register_bytes (frame, gdb_regnum, reg_offset, p->size,
288
                                      contents + offset);
289
          }
290
          break;
291
 
292
        case DWARF_VALUE_MEMORY:
293
          if (p->v.expr.in_stack_memory)
294
            read_stack (p->v.expr.value, contents + offset, p->size);
295
          else
296
            read_memory (p->v.expr.value, contents + offset, p->size);
297
          break;
298
 
299
        case DWARF_VALUE_STACK:
300
          {
301
            size_t n;
302
            int addr_size = gdbarch_addr_bit (c->arch) / 8;
303
            n = p->size;
304
            if (n > addr_size)
305
              n = addr_size;
306
            store_unsigned_integer (contents + offset, n,
307
                                    gdbarch_byte_order (c->arch),
308
                                    p->v.expr.value);
309
          }
310
          break;
311
 
312
        case DWARF_VALUE_LITERAL:
313
          {
314
            size_t n = p->size;
315
            if (n > p->v.literal.length)
316
              n = p->v.literal.length;
317
            memcpy (contents + offset, p->v.literal.data, n);
318
          }
319
          break;
320
 
321
        default:
322
          internal_error (__FILE__, __LINE__, _("invalid location type"));
323
        }
324
      offset += p->size;
325
    }
326
}
327
 
328
static void
329
write_pieced_value (struct value *to, struct value *from)
330
{
331
  int i;
332
  long offset = 0;
333
  gdb_byte *contents;
334
  struct piece_closure *c = (struct piece_closure *) value_computed_closure (to);
335
  struct frame_info *frame = frame_find_by_id (VALUE_FRAME_ID (to));
336
 
337
  if (frame == NULL)
338
    {
339
      set_value_optimized_out (to, 1);
340
      return;
341
    }
342
 
343
  contents = value_contents_raw (from);
344
  for (i = 0; i < c->n_pieces; i++)
345
    {
346
      struct dwarf_expr_piece *p = &c->pieces[i];
347
      switch (p->location)
348
        {
349
        case DWARF_VALUE_REGISTER:
350
          {
351
            struct gdbarch *arch = get_frame_arch (frame);
352
            int gdb_regnum = gdbarch_dwarf2_reg_to_regnum (arch, p->v.expr.value);
353
            int reg_offset = 0;
354
 
355
            if (gdbarch_byte_order (arch) == BFD_ENDIAN_BIG
356
                && p->size < register_size (arch, gdb_regnum))
357
              /* Big-endian, and we want less than full size.  */
358
              reg_offset = register_size (arch, gdb_regnum) - p->size;
359
 
360
            put_frame_register_bytes (frame, gdb_regnum, reg_offset, p->size,
361
                                      contents + offset);
362
          }
363
          break;
364
        case DWARF_VALUE_MEMORY:
365
          write_memory (p->v.expr.value, contents + offset, p->size);
366
          break;
367
        default:
368
          set_value_optimized_out (to, 1);
369
          return;
370
        }
371
      offset += p->size;
372
    }
373
}
374
 
375
static void *
376
copy_pieced_value_closure (struct value *v)
377
{
378
  struct piece_closure *c = (struct piece_closure *) value_computed_closure (v);
379
 
380
  return allocate_piece_closure (c->n_pieces, c->pieces, c->arch);
381
}
382
 
383
static void
384
free_pieced_value_closure (struct value *v)
385
{
386
  struct piece_closure *c = (struct piece_closure *) value_computed_closure (v);
387
 
388
  xfree (c->pieces);
389
  xfree (c);
390
}
391
 
392
/* Functions for accessing a variable described by DW_OP_piece.  */
393
static struct lval_funcs pieced_value_funcs = {
394
  read_pieced_value,
395
  write_pieced_value,
396
  copy_pieced_value_closure,
397
  free_pieced_value_closure
398
};
399
 
400
/* Evaluate a location description, starting at DATA and with length
401
   SIZE, to find the current location of variable VAR in the context
402
   of FRAME.  */
403
static struct value *
404
dwarf2_evaluate_loc_desc (struct symbol *var, struct frame_info *frame,
405
                          gdb_byte *data, unsigned short size,
406
                          struct dwarf2_per_cu_data *per_cu)
407
{
408
  struct value *retval;
409
  struct dwarf_expr_baton baton;
410
  struct dwarf_expr_context *ctx;
411
  struct cleanup *old_chain;
412
 
413
  if (size == 0)
414
    {
415
      retval = allocate_value (SYMBOL_TYPE (var));
416
      VALUE_LVAL (retval) = not_lval;
417
      set_value_optimized_out (retval, 1);
418
      return retval;
419
    }
420
 
421
  baton.frame = frame;
422
  baton.objfile = dwarf2_per_cu_objfile (per_cu);
423
 
424
  ctx = new_dwarf_expr_context ();
425
  old_chain = make_cleanup_free_dwarf_expr_context (ctx);
426
 
427
  ctx->gdbarch = get_objfile_arch (baton.objfile);
428
  ctx->addr_size = dwarf2_per_cu_addr_size (per_cu);
429
  ctx->baton = &baton;
430
  ctx->read_reg = dwarf_expr_read_reg;
431
  ctx->read_mem = dwarf_expr_read_mem;
432
  ctx->get_frame_base = dwarf_expr_frame_base;
433
  ctx->get_frame_cfa = dwarf_expr_frame_cfa;
434
  ctx->get_tls_address = dwarf_expr_tls_address;
435
 
436
  dwarf_expr_eval (ctx, data, size);
437
  if (ctx->num_pieces > 0)
438
    {
439
      struct piece_closure *c;
440
      struct frame_id frame_id = get_frame_id (frame);
441
 
442
      c = allocate_piece_closure (ctx->num_pieces, ctx->pieces, ctx->gdbarch);
443
      retval = allocate_computed_value (SYMBOL_TYPE (var),
444
                                        &pieced_value_funcs,
445
                                        c);
446
      VALUE_FRAME_ID (retval) = frame_id;
447
    }
448
  else
449
    {
450
      switch (ctx->location)
451
        {
452
        case DWARF_VALUE_REGISTER:
453
          {
454
            struct gdbarch *arch = get_frame_arch (frame);
455
            CORE_ADDR dwarf_regnum = dwarf_expr_fetch (ctx, 0);
456
            int gdb_regnum = gdbarch_dwarf2_reg_to_regnum (arch, dwarf_regnum);
457
            retval = value_from_register (SYMBOL_TYPE (var), gdb_regnum, frame);
458
          }
459
          break;
460
 
461
        case DWARF_VALUE_MEMORY:
462
          {
463
            CORE_ADDR address = dwarf_expr_fetch (ctx, 0);
464
            int in_stack_memory = dwarf_expr_fetch_in_stack_memory (ctx, 0);
465
 
466
            retval = allocate_value (SYMBOL_TYPE (var));
467
            VALUE_LVAL (retval) = lval_memory;
468
            set_value_lazy (retval, 1);
469
            if (in_stack_memory)
470
              set_value_stack (retval, 1);
471
            set_value_address (retval, address);
472
          }
473
          break;
474
 
475
        case DWARF_VALUE_STACK:
476
          {
477
            ULONGEST value = (ULONGEST) dwarf_expr_fetch (ctx, 0);
478
            bfd_byte *contents;
479
            size_t n = ctx->addr_size;
480
 
481
            retval = allocate_value (SYMBOL_TYPE (var));
482
            contents = value_contents_raw (retval);
483
            if (n > TYPE_LENGTH (SYMBOL_TYPE (var)))
484
              n = TYPE_LENGTH (SYMBOL_TYPE (var));
485
            store_unsigned_integer (contents, n,
486
                                    gdbarch_byte_order (ctx->gdbarch),
487
                                    value);
488
          }
489
          break;
490
 
491
        case DWARF_VALUE_LITERAL:
492
          {
493
            bfd_byte *contents;
494
            size_t n = ctx->len;
495
 
496
            retval = allocate_value (SYMBOL_TYPE (var));
497
            contents = value_contents_raw (retval);
498
            if (n > TYPE_LENGTH (SYMBOL_TYPE (var)))
499
              n = TYPE_LENGTH (SYMBOL_TYPE (var));
500
            memcpy (contents, ctx->data, n);
501
          }
502
          break;
503
 
504
        default:
505
          internal_error (__FILE__, __LINE__, _("invalid location type"));
506
        }
507
    }
508
 
509
  set_value_initialized (retval, ctx->initialized);
510
 
511
  do_cleanups (old_chain);
512
 
513
  return retval;
514
}
515
 
516
/* Helper functions and baton for dwarf2_loc_desc_needs_frame.  */
517
 
518
struct needs_frame_baton
519
{
520
  int needs_frame;
521
};
522
 
523
/* Reads from registers do require a frame.  */
524
static CORE_ADDR
525
needs_frame_read_reg (void *baton, int regnum)
526
{
527
  struct needs_frame_baton *nf_baton = baton;
528
  nf_baton->needs_frame = 1;
529
  return 1;
530
}
531
 
532
/* Reads from memory do not require a frame.  */
533
static void
534
needs_frame_read_mem (void *baton, gdb_byte *buf, CORE_ADDR addr, size_t len)
535
{
536
  memset (buf, 0, len);
537
}
538
 
539
/* Frame-relative accesses do require a frame.  */
540
static void
541
needs_frame_frame_base (void *baton, gdb_byte **start, size_t * length)
542
{
543
  static gdb_byte lit0 = DW_OP_lit0;
544
  struct needs_frame_baton *nf_baton = baton;
545
 
546
  *start = &lit0;
547
  *length = 1;
548
 
549
  nf_baton->needs_frame = 1;
550
}
551
 
552
/* CFA accesses require a frame.  */
553
 
554
static CORE_ADDR
555
needs_frame_frame_cfa (void *baton)
556
{
557
  struct needs_frame_baton *nf_baton = baton;
558
  nf_baton->needs_frame = 1;
559
  return 1;
560
}
561
 
562
/* Thread-local accesses do require a frame.  */
563
static CORE_ADDR
564
needs_frame_tls_address (void *baton, CORE_ADDR offset)
565
{
566
  struct needs_frame_baton *nf_baton = baton;
567
  nf_baton->needs_frame = 1;
568
  return 1;
569
}
570
 
571
/* Return non-zero iff the location expression at DATA (length SIZE)
572
   requires a frame to evaluate.  */
573
 
574
static int
575
dwarf2_loc_desc_needs_frame (gdb_byte *data, unsigned short size,
576
                             struct dwarf2_per_cu_data *per_cu)
577
{
578
  struct needs_frame_baton baton;
579
  struct dwarf_expr_context *ctx;
580
  int in_reg;
581
  struct cleanup *old_chain;
582
 
583
  baton.needs_frame = 0;
584
 
585
  ctx = new_dwarf_expr_context ();
586
  old_chain = make_cleanup_free_dwarf_expr_context (ctx);
587
 
588
  ctx->gdbarch = get_objfile_arch (dwarf2_per_cu_objfile (per_cu));
589
  ctx->addr_size = dwarf2_per_cu_addr_size (per_cu);
590
  ctx->baton = &baton;
591
  ctx->read_reg = needs_frame_read_reg;
592
  ctx->read_mem = needs_frame_read_mem;
593
  ctx->get_frame_base = needs_frame_frame_base;
594
  ctx->get_frame_cfa = needs_frame_frame_cfa;
595
  ctx->get_tls_address = needs_frame_tls_address;
596
 
597
  dwarf_expr_eval (ctx, data, size);
598
 
599
  in_reg = ctx->location == DWARF_VALUE_REGISTER;
600
 
601
  if (ctx->num_pieces > 0)
602
    {
603
      int i;
604
 
605
      /* If the location has several pieces, and any of them are in
606
         registers, then we will need a frame to fetch them from.  */
607
      for (i = 0; i < ctx->num_pieces; i++)
608
        if (ctx->pieces[i].location == DWARF_VALUE_REGISTER)
609
          in_reg = 1;
610
    }
611
 
612
  do_cleanups (old_chain);
613
 
614
  return baton.needs_frame || in_reg;
615
}
616
 
617
static void
618
dwarf2_tracepoint_var_ref (struct symbol *symbol, struct gdbarch *gdbarch,
619
                           struct agent_expr *ax, struct axs_value *value,
620
                           gdb_byte *data, int size)
621
{
622
  if (size == 0)
623
    error (_("Symbol \"%s\" has been optimized out."),
624
           SYMBOL_PRINT_NAME (symbol));
625
 
626
  if (size == 1
627
      && data[0] >= DW_OP_reg0
628
      && data[0] <= DW_OP_reg31)
629
    {
630
      value->kind = axs_lvalue_register;
631
      value->u.reg = data[0] - DW_OP_reg0;
632
    }
633
  else if (data[0] == DW_OP_regx)
634
    {
635
      ULONGEST reg;
636
      read_uleb128 (data + 1, data + size, &reg);
637
      value->kind = axs_lvalue_register;
638
      value->u.reg = reg;
639
    }
640
  else if (data[0] == DW_OP_fbreg)
641
    {
642
      struct block *b;
643
      struct symbol *framefunc;
644
      int frame_reg = 0;
645
      LONGEST frame_offset;
646
      gdb_byte *buf_end;
647
      gdb_byte *base_data;
648
      size_t base_size;
649
      LONGEST base_offset = 0;
650
 
651
      b = block_for_pc (ax->scope);
652
 
653
      if (!b)
654
        error (_("No block found for address"));
655
 
656
      framefunc = block_linkage_function (b);
657
 
658
      if (!framefunc)
659
        error (_("No function found for block"));
660
 
661
      dwarf_expr_frame_base_1 (framefunc, ax->scope,
662
                               &base_data, &base_size);
663
 
664
      if (base_data[0] >= DW_OP_breg0
665
           && base_data[0] <= DW_OP_breg31)
666
        {
667
          frame_reg = base_data[0] - DW_OP_breg0;
668
          buf_end = read_sleb128 (base_data + 1, base_data + base_size, &base_offset);
669
          if (buf_end != base_data + base_size)
670
            error (_("Unexpected opcode after DW_OP_breg%u for symbol \"%s\"."),
671
                   frame_reg, SYMBOL_PRINT_NAME (symbol));
672
        }
673
      else
674
        {
675
          /* We don't know what to do with the frame base expression,
676
             so we can't trace this variable; give up.  */
677
          error (_("Cannot generate expression to collect symbol \"%s\"; DWARF 2 encoding not handled"),
678
                 SYMBOL_PRINT_NAME (symbol));
679
        }
680
 
681
      buf_end = read_sleb128 (data + 1, data + size, &frame_offset);
682
      if (buf_end != data + size)
683
        error (_("Unexpected opcode after DW_OP_fbreg for symbol \"%s\"."),
684
               SYMBOL_PRINT_NAME (symbol));
685
 
686
      ax_reg (ax, frame_reg);
687
      ax_const_l (ax, base_offset + frame_offset);
688
      ax_simple (ax, aop_add);
689
 
690
      value->kind = axs_lvalue_memory;
691
    }
692
  else if (data[0] >= DW_OP_breg0
693
           && data[0] <= DW_OP_breg31)
694
    {
695
      unsigned int reg;
696
      LONGEST offset;
697
      gdb_byte *buf_end;
698
 
699
      reg = data[0] - DW_OP_breg0;
700
      buf_end = read_sleb128 (data + 1, data + size, &offset);
701
      if (buf_end != data + size)
702
        error (_("Unexpected opcode after DW_OP_breg%u for symbol \"%s\"."),
703
               reg, SYMBOL_PRINT_NAME (symbol));
704
 
705
      ax_reg (ax, reg);
706
      ax_const_l (ax, offset);
707
      ax_simple (ax, aop_add);
708
 
709
      value->kind = axs_lvalue_memory;
710
    }
711
  else
712
    error (_("Unsupported DWARF opcode 0x%x in the location of \"%s\"."),
713
           data[0], SYMBOL_PRINT_NAME (symbol));
714
}
715
 
716
/* Return the value of SYMBOL in FRAME using the DWARF-2 expression
717
   evaluator to calculate the location.  */
718
static struct value *
719
locexpr_read_variable (struct symbol *symbol, struct frame_info *frame)
720
{
721
  struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
722
  struct value *val;
723
  val = dwarf2_evaluate_loc_desc (symbol, frame, dlbaton->data, dlbaton->size,
724
                                  dlbaton->per_cu);
725
 
726
  return val;
727
}
728
 
729
/* Return non-zero iff we need a frame to evaluate SYMBOL.  */
730
static int
731
locexpr_read_needs_frame (struct symbol *symbol)
732
{
733
  struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
734
  return dwarf2_loc_desc_needs_frame (dlbaton->data, dlbaton->size,
735
                                      dlbaton->per_cu);
736
}
737
 
738
/* Print a natural-language description of SYMBOL to STREAM.  */
739
static int
740
locexpr_describe_location (struct symbol *symbol, struct ui_file *stream)
741
{
742
  /* FIXME: be more extensive.  */
743
  struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
744
  int addr_size = dwarf2_per_cu_addr_size (dlbaton->per_cu);
745
 
746
  if (dlbaton->size == 1
747
      && dlbaton->data[0] >= DW_OP_reg0
748
      && dlbaton->data[0] <= DW_OP_reg31)
749
    {
750
      struct objfile *objfile = dwarf2_per_cu_objfile (dlbaton->per_cu);
751
      struct gdbarch *gdbarch = get_objfile_arch (objfile);
752
      int regno = gdbarch_dwarf2_reg_to_regnum (gdbarch,
753
                                                dlbaton->data[0] - DW_OP_reg0);
754
      fprintf_filtered (stream,
755
                        "a variable in register %s",
756
                        gdbarch_register_name (gdbarch, regno));
757
      return 1;
758
    }
759
 
760
  /* The location expression for a TLS variable looks like this (on a
761
     64-bit LE machine):
762
 
763
     DW_AT_location    : 10 byte block: 3 4 0 0 0 0 0 0 0 e0
764
                        (DW_OP_addr: 4; DW_OP_GNU_push_tls_address)
765
 
766
     0x3 is the encoding for DW_OP_addr, which has an operand as long
767
     as the size of an address on the target machine (here is 8
768
     bytes).  0xe0 is the encoding for DW_OP_GNU_push_tls_address.
769
     The operand represents the offset at which the variable is within
770
     the thread local storage.  */
771
 
772
  if (dlbaton->size > 1
773
      && dlbaton->data[dlbaton->size - 1] == DW_OP_GNU_push_tls_address)
774
    if (dlbaton->data[0] == DW_OP_addr)
775
      {
776
        struct objfile *objfile = dwarf2_per_cu_objfile (dlbaton->per_cu);
777
        struct gdbarch *gdbarch = get_objfile_arch (objfile);
778
        CORE_ADDR offset = dwarf2_read_address (gdbarch,
779
                                                &dlbaton->data[1],
780
                                                &dlbaton->data[dlbaton->size - 1],
781
                                                addr_size);
782
        fprintf_filtered (stream,
783
                          "a thread-local variable at offset %s in the "
784
                          "thread-local storage for `%s'",
785
                          paddress (gdbarch, offset), objfile->name);
786
        return 1;
787
      }
788
 
789
 
790
  fprintf_filtered (stream,
791
                    "a variable with complex or multiple locations (DWARF2)");
792
  return 1;
793
}
794
 
795
 
796
/* Describe the location of SYMBOL as an agent value in VALUE, generating
797
   any necessary bytecode in AX.
798
 
799
   NOTE drow/2003-02-26: This function is extremely minimal, because
800
   doing it correctly is extremely complicated and there is no
801
   publicly available stub with tracepoint support for me to test
802
   against.  When there is one this function should be revisited.  */
803
 
804
static void
805
locexpr_tracepoint_var_ref (struct symbol *symbol, struct gdbarch *gdbarch,
806
                            struct agent_expr *ax, struct axs_value *value)
807
{
808
  struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
809
 
810
  dwarf2_tracepoint_var_ref (symbol, gdbarch, ax, value,
811
                             dlbaton->data, dlbaton->size);
812
}
813
 
814
/* The set of location functions used with the DWARF-2 expression
815
   evaluator.  */
816
const struct symbol_computed_ops dwarf2_locexpr_funcs = {
817
  locexpr_read_variable,
818
  locexpr_read_needs_frame,
819
  locexpr_describe_location,
820
  locexpr_tracepoint_var_ref
821
};
822
 
823
 
824
/* Wrapper functions for location lists.  These generally find
825
   the appropriate location expression and call something above.  */
826
 
827
/* Return the value of SYMBOL in FRAME using the DWARF-2 expression
828
   evaluator to calculate the location.  */
829
static struct value *
830
loclist_read_variable (struct symbol *symbol, struct frame_info *frame)
831
{
832
  struct dwarf2_loclist_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
833
  struct value *val;
834
  gdb_byte *data;
835
  size_t size;
836
 
837
  data = find_location_expression (dlbaton, &size,
838
                                   frame ? get_frame_address_in_block (frame)
839
                                   : 0);
840
  if (data == NULL)
841
    {
842
      val = allocate_value (SYMBOL_TYPE (symbol));
843
      VALUE_LVAL (val) = not_lval;
844
      set_value_optimized_out (val, 1);
845
    }
846
  else
847
    val = dwarf2_evaluate_loc_desc (symbol, frame, data, size,
848
                                    dlbaton->per_cu);
849
 
850
  return val;
851
}
852
 
853
/* Return non-zero iff we need a frame to evaluate SYMBOL.  */
854
static int
855
loclist_read_needs_frame (struct symbol *symbol)
856
{
857
  /* If there's a location list, then assume we need to have a frame
858
     to choose the appropriate location expression.  With tracking of
859
     global variables this is not necessarily true, but such tracking
860
     is disabled in GCC at the moment until we figure out how to
861
     represent it.  */
862
 
863
  return 1;
864
}
865
 
866
/* Print a natural-language description of SYMBOL to STREAM.  */
867
static int
868
loclist_describe_location (struct symbol *symbol, struct ui_file *stream)
869
{
870
  /* FIXME: Could print the entire list of locations.  */
871
  fprintf_filtered (stream, "a variable with multiple locations");
872
  return 1;
873
}
874
 
875
/* Describe the location of SYMBOL as an agent value in VALUE, generating
876
   any necessary bytecode in AX.  */
877
static void
878
loclist_tracepoint_var_ref (struct symbol *symbol, struct gdbarch *gdbarch,
879
                            struct agent_expr *ax, struct axs_value *value)
880
{
881
  struct dwarf2_loclist_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
882
  gdb_byte *data;
883
  size_t size;
884
 
885
  data = find_location_expression (dlbaton, &size, ax->scope);
886
  if (data == NULL)
887
    error (_("Variable \"%s\" is not available."), SYMBOL_NATURAL_NAME (symbol));
888
 
889
  dwarf2_tracepoint_var_ref (symbol, gdbarch, ax, value, data, size);
890
}
891
 
892
/* The set of location functions used with the DWARF-2 expression
893
   evaluator and location lists.  */
894
const struct symbol_computed_ops dwarf2_loclist_funcs = {
895
  loclist_read_variable,
896
  loclist_read_needs_frame,
897
  loclist_describe_location,
898
  loclist_tracepoint_var_ref
899
};

powered by: WebSVN 2.1.0

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