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

Subversion Repositories openrisc

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

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 227 jeremybenn
/* Find a variable's value in memory, for GDB, the GNU debugger.
2
 
3
   Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
4
   1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005, 2007, 2008, 2009,
5
   2010 Free Software Foundation, Inc.
6
 
7
   This file is part of GDB.
8
 
9
   This program is free software; you can redistribute it and/or modify
10
   it under the terms of the GNU General Public License as published by
11
   the Free Software Foundation; either version 3 of the License, or
12
   (at your option) any later version.
13
 
14
   This program is distributed in the hope that it will be useful,
15
   but WITHOUT ANY WARRANTY; without even the implied warranty of
16
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17
   GNU General Public License for more details.
18
 
19
   You should have received a copy of the GNU General Public License
20
   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
21
 
22
#include "defs.h"
23
#include "symtab.h"
24
#include "gdbtypes.h"
25
#include "frame.h"
26
#include "value.h"
27
#include "gdbcore.h"
28
#include "inferior.h"
29
#include "target.h"
30
#include "gdb_string.h"
31
#include "gdb_assert.h"
32
#include "floatformat.h"
33
#include "symfile.h"            /* for overlay functions */
34
#include "regcache.h"
35
#include "user-regs.h"
36
#include "block.h"
37
#include "objfiles.h"
38
 
39
/* Basic byte-swapping routines.  All 'extract' functions return a
40
   host-format integer from a target-format integer at ADDR which is
41
   LEN bytes long.  */
42
 
43
#if TARGET_CHAR_BIT != 8 || HOST_CHAR_BIT != 8
44
  /* 8 bit characters are a pretty safe assumption these days, so we
45
     assume it throughout all these swapping routines.  If we had to deal with
46
     9 bit characters, we would need to make len be in bits and would have
47
     to re-write these routines...  */
48
you lose
49
#endif
50
 
51
LONGEST
52
extract_signed_integer (const gdb_byte *addr, int len,
53
                        enum bfd_endian byte_order)
54
{
55
  LONGEST retval;
56
  const unsigned char *p;
57
  const unsigned char *startaddr = addr;
58
  const unsigned char *endaddr = startaddr + len;
59
 
60
  if (len > (int) sizeof (LONGEST))
61
    error (_("\
62
That operation is not available on integers of more than %d bytes."),
63
           (int) sizeof (LONGEST));
64
 
65
  /* Start at the most significant end of the integer, and work towards
66
     the least significant.  */
67
  if (byte_order == BFD_ENDIAN_BIG)
68
    {
69
      p = startaddr;
70
      /* Do the sign extension once at the start.  */
71
      retval = ((LONGEST) * p ^ 0x80) - 0x80;
72
      for (++p; p < endaddr; ++p)
73
        retval = (retval << 8) | *p;
74
    }
75
  else
76
    {
77
      p = endaddr - 1;
78
      /* Do the sign extension once at the start.  */
79
      retval = ((LONGEST) * p ^ 0x80) - 0x80;
80
      for (--p; p >= startaddr; --p)
81
        retval = (retval << 8) | *p;
82
    }
83
  return retval;
84
}
85
 
86
ULONGEST
87
extract_unsigned_integer (const gdb_byte *addr, int len,
88
                          enum bfd_endian byte_order)
89
{
90
  ULONGEST retval;
91
  const unsigned char *p;
92
  const unsigned char *startaddr = addr;
93
  const unsigned char *endaddr = startaddr + len;
94
 
95
  if (len > (int) sizeof (ULONGEST))
96
    error (_("\
97
That operation is not available on integers of more than %d bytes."),
98
           (int) sizeof (ULONGEST));
99
 
100
  /* Start at the most significant end of the integer, and work towards
101
     the least significant.  */
102
  retval = 0;
103
  if (byte_order == BFD_ENDIAN_BIG)
104
    {
105
      for (p = startaddr; p < endaddr; ++p)
106
        retval = (retval << 8) | *p;
107
    }
108
  else
109
    {
110
      for (p = endaddr - 1; p >= startaddr; --p)
111
        retval = (retval << 8) | *p;
112
    }
113
  return retval;
114
}
115
 
116
/* Sometimes a long long unsigned integer can be extracted as a
117
   LONGEST value.  This is done so that we can print these values
118
   better.  If this integer can be converted to a LONGEST, this
119
   function returns 1 and sets *PVAL.  Otherwise it returns 0.  */
120
 
121
int
122
extract_long_unsigned_integer (const gdb_byte *addr, int orig_len,
123
                               enum bfd_endian byte_order, LONGEST *pval)
124
{
125
  const gdb_byte *p;
126
  const gdb_byte *first_addr;
127
  int len;
128
 
129
  len = orig_len;
130
  if (byte_order == BFD_ENDIAN_BIG)
131
    {
132
      for (p = addr;
133
           len > (int) sizeof (LONGEST) && p < addr + orig_len;
134
           p++)
135
        {
136
          if (*p == 0)
137
            len--;
138
          else
139
            break;
140
        }
141
      first_addr = p;
142
    }
143
  else
144
    {
145
      first_addr = addr;
146
      for (p = addr + orig_len - 1;
147
           len > (int) sizeof (LONGEST) && p >= addr;
148
           p--)
149
        {
150
          if (*p == 0)
151
            len--;
152
          else
153
            break;
154
        }
155
    }
156
 
157
  if (len <= (int) sizeof (LONGEST))
158
    {
159
      *pval = (LONGEST) extract_unsigned_integer (first_addr,
160
                                                  sizeof (LONGEST),
161
                                                  byte_order);
162
      return 1;
163
    }
164
 
165
  return 0;
166
}
167
 
168
 
169
/* Treat the bytes at BUF as a pointer of type TYPE, and return the
170
   address it represents.  */
171
CORE_ADDR
172
extract_typed_address (const gdb_byte *buf, struct type *type)
173
{
174
  if (TYPE_CODE (type) != TYPE_CODE_PTR
175
      && TYPE_CODE (type) != TYPE_CODE_REF)
176
    internal_error (__FILE__, __LINE__,
177
                    _("extract_typed_address: "
178
                    "type is not a pointer or reference"));
179
 
180
  return gdbarch_pointer_to_address (get_type_arch (type), type, buf);
181
}
182
 
183
/* All 'store' functions accept a host-format integer and store a
184
   target-format integer at ADDR which is LEN bytes long.  */
185
 
186
void
187
store_signed_integer (gdb_byte *addr, int len,
188
                      enum bfd_endian byte_order, LONGEST val)
189
{
190
  gdb_byte *p;
191
  gdb_byte *startaddr = addr;
192
  gdb_byte *endaddr = startaddr + len;
193
 
194
  /* Start at the least significant end of the integer, and work towards
195
     the most significant.  */
196
  if (byte_order == BFD_ENDIAN_BIG)
197
    {
198
      for (p = endaddr - 1; p >= startaddr; --p)
199
        {
200
          *p = val & 0xff;
201
          val >>= 8;
202
        }
203
    }
204
  else
205
    {
206
      for (p = startaddr; p < endaddr; ++p)
207
        {
208
          *p = val & 0xff;
209
          val >>= 8;
210
        }
211
    }
212
}
213
 
214
void
215
store_unsigned_integer (gdb_byte *addr, int len,
216
                        enum bfd_endian byte_order, ULONGEST val)
217
{
218
  unsigned char *p;
219
  unsigned char *startaddr = (unsigned char *) addr;
220
  unsigned char *endaddr = startaddr + len;
221
 
222
  /* Start at the least significant end of the integer, and work towards
223
     the most significant.  */
224
  if (byte_order == BFD_ENDIAN_BIG)
225
    {
226
      for (p = endaddr - 1; p >= startaddr; --p)
227
        {
228
          *p = val & 0xff;
229
          val >>= 8;
230
        }
231
    }
232
  else
233
    {
234
      for (p = startaddr; p < endaddr; ++p)
235
        {
236
          *p = val & 0xff;
237
          val >>= 8;
238
        }
239
    }
240
}
241
 
242
/* Store the address ADDR as a pointer of type TYPE at BUF, in target
243
   form.  */
244
void
245
store_typed_address (gdb_byte *buf, struct type *type, CORE_ADDR addr)
246
{
247
  if (TYPE_CODE (type) != TYPE_CODE_PTR
248
      && TYPE_CODE (type) != TYPE_CODE_REF)
249
    internal_error (__FILE__, __LINE__,
250
                    _("store_typed_address: "
251
                    "type is not a pointer or reference"));
252
 
253
  gdbarch_address_to_pointer (get_type_arch (type), type, buf, addr);
254
}
255
 
256
 
257
 
258
/* Return a `value' with the contents of (virtual or cooked) register
259
   REGNUM as found in the specified FRAME.  The register's type is
260
   determined by register_type().  */
261
 
262
struct value *
263
value_of_register (int regnum, struct frame_info *frame)
264
{
265
  struct gdbarch *gdbarch = get_frame_arch (frame);
266
  CORE_ADDR addr;
267
  int optim;
268
  struct value *reg_val;
269
  int realnum;
270
  gdb_byte raw_buffer[MAX_REGISTER_SIZE];
271
  enum lval_type lval;
272
 
273
  /* User registers lie completely outside of the range of normal
274
     registers.  Catch them early so that the target never sees them.  */
275
  if (regnum >= gdbarch_num_regs (gdbarch)
276
                + gdbarch_num_pseudo_regs (gdbarch))
277
    return value_of_user_reg (regnum, frame);
278
 
279
  frame_register (frame, regnum, &optim, &lval, &addr, &realnum, raw_buffer);
280
 
281
  reg_val = allocate_value (register_type (gdbarch, regnum));
282
 
283
  memcpy (value_contents_raw (reg_val), raw_buffer,
284
          register_size (gdbarch, regnum));
285
  VALUE_LVAL (reg_val) = lval;
286
  set_value_address (reg_val, addr);
287
  VALUE_REGNUM (reg_val) = regnum;
288
  set_value_optimized_out (reg_val, optim);
289
  VALUE_FRAME_ID (reg_val) = get_frame_id (frame);
290
  return reg_val;
291
}
292
 
293
/* Return a `value' with the contents of (virtual or cooked) register
294
   REGNUM as found in the specified FRAME.  The register's type is
295
   determined by register_type().  The value is not fetched.  */
296
 
297
struct value *
298
value_of_register_lazy (struct frame_info *frame, int regnum)
299
{
300
  struct gdbarch *gdbarch = get_frame_arch (frame);
301
  struct value *reg_val;
302
 
303
  gdb_assert (regnum < (gdbarch_num_regs (gdbarch)
304
                        + gdbarch_num_pseudo_regs (gdbarch)));
305
 
306
  /* We should have a valid (i.e. non-sentinel) frame.  */
307
  gdb_assert (frame_id_p (get_frame_id (frame)));
308
 
309
  reg_val = allocate_value (register_type (gdbarch, regnum));
310
  VALUE_LVAL (reg_val) = lval_register;
311
  VALUE_REGNUM (reg_val) = regnum;
312
  VALUE_FRAME_ID (reg_val) = get_frame_id (frame);
313
  set_value_lazy (reg_val, 1);
314
  return reg_val;
315
}
316
 
317
/* Given a pointer of type TYPE in target form in BUF, return the
318
   address it represents.  */
319
CORE_ADDR
320
unsigned_pointer_to_address (struct gdbarch *gdbarch,
321
                             struct type *type, const gdb_byte *buf)
322
{
323
  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
324
  return extract_unsigned_integer (buf, TYPE_LENGTH (type), byte_order);
325
}
326
 
327
CORE_ADDR
328
signed_pointer_to_address (struct gdbarch *gdbarch,
329
                           struct type *type, const gdb_byte *buf)
330
{
331
  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
332
  return extract_signed_integer (buf, TYPE_LENGTH (type), byte_order);
333
}
334
 
335
/* Given an address, store it as a pointer of type TYPE in target
336
   format in BUF.  */
337
void
338
unsigned_address_to_pointer (struct gdbarch *gdbarch, struct type *type,
339
                             gdb_byte *buf, CORE_ADDR addr)
340
{
341
  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
342
  store_unsigned_integer (buf, TYPE_LENGTH (type), byte_order, addr);
343
}
344
 
345
void
346
address_to_signed_pointer (struct gdbarch *gdbarch, struct type *type,
347
                           gdb_byte *buf, CORE_ADDR addr)
348
{
349
  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
350
  store_signed_integer (buf, TYPE_LENGTH (type), byte_order, addr);
351
}
352
 
353
/* Will calling read_var_value or locate_var_value on SYM end
354
   up caring what frame it is being evaluated relative to?  SYM must
355
   be non-NULL.  */
356
int
357
symbol_read_needs_frame (struct symbol *sym)
358
{
359
  switch (SYMBOL_CLASS (sym))
360
    {
361
      /* All cases listed explicitly so that gcc -Wall will detect it if
362
         we failed to consider one.  */
363
    case LOC_COMPUTED:
364
      /* FIXME: cagney/2004-01-26: It should be possible to
365
         unconditionally call the SYMBOL_COMPUTED_OPS method when available.
366
         Unfortunately DWARF 2 stores the frame-base (instead of the
367
         function) location in a function's symbol.  Oops!  For the
368
         moment enable this when/where applicable.  */
369
      return SYMBOL_COMPUTED_OPS (sym)->read_needs_frame (sym);
370
 
371
    case LOC_REGISTER:
372
    case LOC_ARG:
373
    case LOC_REF_ARG:
374
    case LOC_REGPARM_ADDR:
375
    case LOC_LOCAL:
376
      return 1;
377
 
378
    case LOC_UNDEF:
379
    case LOC_CONST:
380
    case LOC_STATIC:
381
    case LOC_TYPEDEF:
382
 
383
    case LOC_LABEL:
384
      /* Getting the address of a label can be done independently of the block,
385
         even if some *uses* of that address wouldn't work so well without
386
         the right frame.  */
387
 
388
    case LOC_BLOCK:
389
    case LOC_CONST_BYTES:
390
    case LOC_UNRESOLVED:
391
    case LOC_OPTIMIZED_OUT:
392
      return 0;
393
    }
394
  return 1;
395
}
396
 
397
/* Given a struct symbol for a variable,
398
   and a stack frame id, read the value of the variable
399
   and return a (pointer to a) struct value containing the value.
400
   If the variable cannot be found, return a zero pointer.  */
401
 
402
struct value *
403
read_var_value (struct symbol *var, struct frame_info *frame)
404
{
405
  struct value *v;
406
  struct type *type = SYMBOL_TYPE (var);
407
  CORE_ADDR addr;
408
  int len;
409
 
410
  if (SYMBOL_CLASS (var) == LOC_COMPUTED
411
      || SYMBOL_CLASS (var) == LOC_REGISTER)
412
    /* These cases do not use V.  */
413
    v = NULL;
414
  else
415
    {
416
      v = allocate_value (type);
417
      VALUE_LVAL (v) = lval_memory;     /* The most likely possibility.  */
418
    }
419
 
420
  len = TYPE_LENGTH (type);
421
 
422
  if (symbol_read_needs_frame (var))
423
    gdb_assert (frame);
424
 
425
  switch (SYMBOL_CLASS (var))
426
    {
427
    case LOC_CONST:
428
      /* Put the constant back in target format.  */
429
      store_signed_integer (value_contents_raw (v), len,
430
                            gdbarch_byte_order (get_type_arch (type)),
431
                            (LONGEST) SYMBOL_VALUE (var));
432
      VALUE_LVAL (v) = not_lval;
433
      return v;
434
 
435
    case LOC_LABEL:
436
      /* Put the constant back in target format.  */
437
      if (overlay_debugging)
438
        {
439
          CORE_ADDR addr
440
            = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var),
441
                                        SYMBOL_OBJ_SECTION (var));
442
          store_typed_address (value_contents_raw (v), type, addr);
443
        }
444
      else
445
        store_typed_address (value_contents_raw (v), type,
446
                              SYMBOL_VALUE_ADDRESS (var));
447
      VALUE_LVAL (v) = not_lval;
448
      return v;
449
 
450
    case LOC_CONST_BYTES:
451
      {
452
        memcpy (value_contents_raw (v), SYMBOL_VALUE_BYTES (var), len);
453
        VALUE_LVAL (v) = not_lval;
454
        return v;
455
      }
456
 
457
    case LOC_STATIC:
458
      if (overlay_debugging)
459
        addr = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var),
460
                                         SYMBOL_OBJ_SECTION (var));
461
      else
462
        addr = SYMBOL_VALUE_ADDRESS (var);
463
      break;
464
 
465
    case LOC_ARG:
466
      addr = get_frame_args_address (frame);
467
      if (!addr)
468
        return 0;
469
      addr += SYMBOL_VALUE (var);
470
      break;
471
 
472
    case LOC_REF_ARG:
473
      {
474
        struct value *ref;
475
        CORE_ADDR argref;
476
        argref = get_frame_args_address (frame);
477
        if (!argref)
478
          return 0;
479
        argref += SYMBOL_VALUE (var);
480
        ref = value_at (lookup_pointer_type (type), argref);
481
        addr = value_as_address (ref);
482
        break;
483
      }
484
 
485
    case LOC_LOCAL:
486
      addr = get_frame_locals_address (frame);
487
      addr += SYMBOL_VALUE (var);
488
      break;
489
 
490
    case LOC_TYPEDEF:
491
      error (_("Cannot look up value of a typedef"));
492
      break;
493
 
494
    case LOC_BLOCK:
495
      if (overlay_debugging)
496
        set_value_address (v, symbol_overlayed_address
497
          (BLOCK_START (SYMBOL_BLOCK_VALUE (var)), SYMBOL_OBJ_SECTION (var)));
498
      else
499
        set_value_address (v, BLOCK_START (SYMBOL_BLOCK_VALUE (var)));
500
      return v;
501
 
502
    case LOC_REGISTER:
503
    case LOC_REGPARM_ADDR:
504
      {
505
        int regno = SYMBOL_REGISTER_OPS (var)
506
                      ->register_number (var, get_frame_arch (frame));
507
        struct value *regval;
508
 
509
        if (SYMBOL_CLASS (var) == LOC_REGPARM_ADDR)
510
          {
511
            regval = value_from_register (lookup_pointer_type (type),
512
                                          regno,
513
                                          frame);
514
 
515
            if (regval == NULL)
516
              error (_("Value of register variable not available."));
517
 
518
            addr = value_as_address (regval);
519
            VALUE_LVAL (v) = lval_memory;
520
          }
521
        else
522
          {
523
            regval = value_from_register (type, regno, frame);
524
 
525
            if (regval == NULL)
526
              error (_("Value of register variable not available."));
527
            return regval;
528
          }
529
      }
530
      break;
531
 
532
    case LOC_COMPUTED:
533
      /* FIXME: cagney/2004-01-26: It should be possible to
534
         unconditionally call the SYMBOL_COMPUTED_OPS method when available.
535
         Unfortunately DWARF 2 stores the frame-base (instead of the
536
         function) location in a function's symbol.  Oops!  For the
537
         moment enable this when/where applicable.  */
538
      return SYMBOL_COMPUTED_OPS (var)->read_variable (var, frame);
539
 
540
    case LOC_UNRESOLVED:
541
      {
542
        struct minimal_symbol *msym;
543
        struct obj_section *obj_section;
544
 
545
        msym = lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (var), NULL, NULL);
546
        if (msym == NULL)
547
          return 0;
548
        if (overlay_debugging)
549
          addr = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (msym),
550
                                           SYMBOL_OBJ_SECTION (msym));
551
        else
552
          addr = SYMBOL_VALUE_ADDRESS (msym);
553
 
554
        obj_section = SYMBOL_OBJ_SECTION (msym);
555
        if (obj_section
556
            && (obj_section->the_bfd_section->flags & SEC_THREAD_LOCAL) != 0)
557
          addr = target_translate_tls_address (obj_section->objfile, addr);
558
      }
559
      break;
560
 
561
    case LOC_OPTIMIZED_OUT:
562
      VALUE_LVAL (v) = not_lval;
563
      set_value_optimized_out (v, 1);
564
      return v;
565
 
566
    default:
567
      error (_("Cannot look up value of a botched symbol."));
568
      break;
569
    }
570
 
571
  set_value_address (v, addr);
572
  set_value_lazy (v, 1);
573
  return v;
574
}
575
 
576
/* Install default attributes for register values.  */
577
 
578
struct value *
579
default_value_from_register (struct type *type, int regnum,
580
                             struct frame_info *frame)
581
{
582
  struct gdbarch *gdbarch = get_frame_arch (frame);
583
  int len = TYPE_LENGTH (type);
584
  struct value *value = allocate_value (type);
585
 
586
  VALUE_LVAL (value) = lval_register;
587
  VALUE_FRAME_ID (value) = get_frame_id (frame);
588
  VALUE_REGNUM (value) = regnum;
589
 
590
  /* Any structure stored in more than one register will always be
591
     an integral number of registers.  Otherwise, you need to do
592
     some fiddling with the last register copied here for little
593
     endian machines.  */
594
  if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG
595
      && len < register_size (gdbarch, regnum))
596
    /* Big-endian, and we want less than full size.  */
597
    set_value_offset (value, register_size (gdbarch, regnum) - len);
598
  else
599
    set_value_offset (value, 0);
600
 
601
  return value;
602
}
603
 
604
/* Return a value of type TYPE, stored in register REGNUM, in frame FRAME.  */
605
 
606
struct value *
607
value_from_register (struct type *type, int regnum, struct frame_info *frame)
608
{
609
  struct gdbarch *gdbarch = get_frame_arch (frame);
610
  struct type *type1 = check_typedef (type);
611
  struct value *v;
612
 
613
  if (gdbarch_convert_register_p (gdbarch, regnum, type1))
614
    {
615
      /* The ISA/ABI need to something weird when obtaining the
616
         specified value from this register.  It might need to
617
         re-order non-adjacent, starting with REGNUM (see MIPS and
618
         i386).  It might need to convert the [float] register into
619
         the corresponding [integer] type (see Alpha).  The assumption
620
         is that gdbarch_register_to_value populates the entire value
621
         including the location.  */
622
      v = allocate_value (type);
623
      VALUE_LVAL (v) = lval_register;
624
      VALUE_FRAME_ID (v) = get_frame_id (frame);
625
      VALUE_REGNUM (v) = regnum;
626
      gdbarch_register_to_value (gdbarch,
627
                                 frame, regnum, type1, value_contents_raw (v));
628
    }
629
  else
630
    {
631
      int len = TYPE_LENGTH (type);
632
 
633
      /* Construct the value.  */
634
      v = gdbarch_value_from_register (gdbarch, type, regnum, frame);
635
 
636
      /* Get the data.  */
637
      if (!get_frame_register_bytes (frame, regnum, value_offset (v), len,
638
                                     value_contents_raw (v)))
639
        set_value_optimized_out (v, 1);
640
    }
641
  return v;
642
}
643
 
644
/* Return contents of register REGNUM in frame FRAME as address,
645
   interpreted as value of type TYPE.   Will abort if register
646
   value is not available.  */
647
 
648
CORE_ADDR
649
address_from_register (struct type *type, int regnum, struct frame_info *frame)
650
{
651
  struct value *value;
652
  CORE_ADDR result;
653
 
654
  value = value_from_register (type, regnum, frame);
655
  gdb_assert (value);
656
 
657
  result = value_as_address (value);
658
  release_value (value);
659
  value_free (value);
660
 
661
  return result;
662
}

powered by: WebSVN 2.1.0

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