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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-stable/] [gdb-7.2/] [gdb/] [findvar.c] - Blame information for rev 853

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

Line No. Rev Author Line
1 330 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
 
325
  return extract_unsigned_integer (buf, TYPE_LENGTH (type), byte_order);
326
}
327
 
328
CORE_ADDR
329
signed_pointer_to_address (struct gdbarch *gdbarch,
330
                           struct type *type, const gdb_byte *buf)
331
{
332
  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
333
 
334
  return extract_signed_integer (buf, TYPE_LENGTH (type), byte_order);
335
}
336
 
337
/* Given an address, store it as a pointer of type TYPE in target
338
   format in BUF.  */
339
void
340
unsigned_address_to_pointer (struct gdbarch *gdbarch, struct type *type,
341
                             gdb_byte *buf, CORE_ADDR addr)
342
{
343
  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
344
 
345
  store_unsigned_integer (buf, TYPE_LENGTH (type), byte_order, addr);
346
}
347
 
348
void
349
address_to_signed_pointer (struct gdbarch *gdbarch, struct type *type,
350
                           gdb_byte *buf, CORE_ADDR addr)
351
{
352
  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
353
 
354
  store_signed_integer (buf, TYPE_LENGTH (type), byte_order, addr);
355
}
356
 
357
/* Will calling read_var_value or locate_var_value on SYM end
358
   up caring what frame it is being evaluated relative to?  SYM must
359
   be non-NULL.  */
360
int
361
symbol_read_needs_frame (struct symbol *sym)
362
{
363
  switch (SYMBOL_CLASS (sym))
364
    {
365
      /* All cases listed explicitly so that gcc -Wall will detect it if
366
         we failed to consider one.  */
367
    case LOC_COMPUTED:
368
      /* FIXME: cagney/2004-01-26: It should be possible to
369
         unconditionally call the SYMBOL_COMPUTED_OPS method when available.
370
         Unfortunately DWARF 2 stores the frame-base (instead of the
371
         function) location in a function's symbol.  Oops!  For the
372
         moment enable this when/where applicable.  */
373
      return SYMBOL_COMPUTED_OPS (sym)->read_needs_frame (sym);
374
 
375
    case LOC_REGISTER:
376
    case LOC_ARG:
377
    case LOC_REF_ARG:
378
    case LOC_REGPARM_ADDR:
379
    case LOC_LOCAL:
380
      return 1;
381
 
382
    case LOC_UNDEF:
383
    case LOC_CONST:
384
    case LOC_STATIC:
385
    case LOC_TYPEDEF:
386
 
387
    case LOC_LABEL:
388
      /* Getting the address of a label can be done independently of the block,
389
         even if some *uses* of that address wouldn't work so well without
390
         the right frame.  */
391
 
392
    case LOC_BLOCK:
393
    case LOC_CONST_BYTES:
394
    case LOC_UNRESOLVED:
395
    case LOC_OPTIMIZED_OUT:
396
      return 0;
397
    }
398
  return 1;
399
}
400
 
401
/* Given a struct symbol for a variable,
402
   and a stack frame id, read the value of the variable
403
   and return a (pointer to a) struct value containing the value.
404
   If the variable cannot be found, return a zero pointer.  */
405
 
406
struct value *
407
read_var_value (struct symbol *var, struct frame_info *frame)
408
{
409
  struct value *v;
410
  struct type *type = SYMBOL_TYPE (var);
411
  CORE_ADDR addr;
412
  int len;
413
 
414
  if (SYMBOL_CLASS (var) == LOC_COMPUTED
415
      || SYMBOL_CLASS (var) == LOC_REGISTER)
416
    /* These cases do not use V.  */
417
    v = NULL;
418
  else
419
    {
420
      v = allocate_value (type);
421
      VALUE_LVAL (v) = lval_memory;     /* The most likely possibility.  */
422
    }
423
 
424
  len = TYPE_LENGTH (type);
425
 
426
  if (symbol_read_needs_frame (var))
427
    gdb_assert (frame);
428
 
429
  switch (SYMBOL_CLASS (var))
430
    {
431
    case LOC_CONST:
432
      /* Put the constant back in target format.  */
433
      store_signed_integer (value_contents_raw (v), len,
434
                            gdbarch_byte_order (get_type_arch (type)),
435
                            (LONGEST) SYMBOL_VALUE (var));
436
      VALUE_LVAL (v) = not_lval;
437
      return v;
438
 
439
    case LOC_LABEL:
440
      /* Put the constant back in target format.  */
441
      if (overlay_debugging)
442
        {
443
          CORE_ADDR addr
444
            = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var),
445
                                        SYMBOL_OBJ_SECTION (var));
446
 
447
          store_typed_address (value_contents_raw (v), type, addr);
448
        }
449
      else
450
        store_typed_address (value_contents_raw (v), type,
451
                              SYMBOL_VALUE_ADDRESS (var));
452
      VALUE_LVAL (v) = not_lval;
453
      return v;
454
 
455
    case LOC_CONST_BYTES:
456
      memcpy (value_contents_raw (v), SYMBOL_VALUE_BYTES (var), len);
457
      VALUE_LVAL (v) = not_lval;
458
      return v;
459
 
460
    case LOC_STATIC:
461
      if (overlay_debugging)
462
        addr = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var),
463
                                         SYMBOL_OBJ_SECTION (var));
464
      else
465
        addr = SYMBOL_VALUE_ADDRESS (var);
466
      break;
467
 
468
    case LOC_ARG:
469
      addr = get_frame_args_address (frame);
470
      if (!addr)
471
        return 0;
472
      addr += SYMBOL_VALUE (var);
473
      break;
474
 
475
    case LOC_REF_ARG:
476
      {
477
        struct value *ref;
478
        CORE_ADDR argref;
479
 
480
        argref = get_frame_args_address (frame);
481
        if (!argref)
482
          return 0;
483
        argref += SYMBOL_VALUE (var);
484
        ref = value_at (lookup_pointer_type (type), argref);
485
        addr = value_as_address (ref);
486
        break;
487
      }
488
 
489
    case LOC_LOCAL:
490
      addr = get_frame_locals_address (frame);
491
      addr += SYMBOL_VALUE (var);
492
      break;
493
 
494
    case LOC_TYPEDEF:
495
      error (_("Cannot look up value of a typedef"));
496
      break;
497
 
498
    case LOC_BLOCK:
499
      if (overlay_debugging)
500
        set_value_address (v, symbol_overlayed_address
501
          (BLOCK_START (SYMBOL_BLOCK_VALUE (var)), SYMBOL_OBJ_SECTION (var)));
502
      else
503
        set_value_address (v, BLOCK_START (SYMBOL_BLOCK_VALUE (var)));
504
      return v;
505
 
506
    case LOC_REGISTER:
507
    case LOC_REGPARM_ADDR:
508
      {
509
        int regno = SYMBOL_REGISTER_OPS (var)
510
                      ->register_number (var, get_frame_arch (frame));
511
        struct value *regval;
512
 
513
        if (SYMBOL_CLASS (var) == LOC_REGPARM_ADDR)
514
          {
515
            regval = value_from_register (lookup_pointer_type (type),
516
                                          regno,
517
                                          frame);
518
 
519
            if (regval == NULL)
520
              error (_("Value of register variable not available."));
521
 
522
            addr = value_as_address (regval);
523
            VALUE_LVAL (v) = lval_memory;
524
          }
525
        else
526
          {
527
            regval = value_from_register (type, regno, frame);
528
 
529
            if (regval == NULL)
530
              error (_("Value of register variable not available."));
531
            return regval;
532
          }
533
      }
534
      break;
535
 
536
    case LOC_COMPUTED:
537
      /* FIXME: cagney/2004-01-26: It should be possible to
538
         unconditionally call the SYMBOL_COMPUTED_OPS method when available.
539
         Unfortunately DWARF 2 stores the frame-base (instead of the
540
         function) location in a function's symbol.  Oops!  For the
541
         moment enable this when/where applicable.  */
542
      return SYMBOL_COMPUTED_OPS (var)->read_variable (var, frame);
543
 
544
    case LOC_UNRESOLVED:
545
      {
546
        struct minimal_symbol *msym;
547
        struct obj_section *obj_section;
548
 
549
        msym = lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (var), NULL, NULL);
550
        if (msym == NULL)
551
          return 0;
552
        if (overlay_debugging)
553
          addr = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (msym),
554
                                           SYMBOL_OBJ_SECTION (msym));
555
        else
556
          addr = SYMBOL_VALUE_ADDRESS (msym);
557
 
558
        obj_section = SYMBOL_OBJ_SECTION (msym);
559
        if (obj_section
560
            && (obj_section->the_bfd_section->flags & SEC_THREAD_LOCAL) != 0)
561
          addr = target_translate_tls_address (obj_section->objfile, addr);
562
      }
563
      break;
564
 
565
    case LOC_OPTIMIZED_OUT:
566
      VALUE_LVAL (v) = not_lval;
567
      set_value_optimized_out (v, 1);
568
      return v;
569
 
570
    default:
571
      error (_("Cannot look up value of a botched symbol."));
572
      break;
573
    }
574
 
575
  set_value_address (v, addr);
576
  set_value_lazy (v, 1);
577
  return v;
578
}
579
 
580
/* Install default attributes for register values.  */
581
 
582
struct value *
583
default_value_from_register (struct type *type, int regnum,
584
                             struct frame_info *frame)
585
{
586
  struct gdbarch *gdbarch = get_frame_arch (frame);
587
  int len = TYPE_LENGTH (type);
588
  struct value *value = allocate_value (type);
589
 
590
  VALUE_LVAL (value) = lval_register;
591
  VALUE_FRAME_ID (value) = get_frame_id (frame);
592
  VALUE_REGNUM (value) = regnum;
593
 
594
  /* Any structure stored in more than one register will always be
595
     an integral number of registers.  Otherwise, you need to do
596
     some fiddling with the last register copied here for little
597
     endian machines.  */
598
  if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG
599
      && len < register_size (gdbarch, regnum))
600
    /* Big-endian, and we want less than full size.  */
601
    set_value_offset (value, register_size (gdbarch, regnum) - len);
602
  else
603
    set_value_offset (value, 0);
604
 
605
  return value;
606
}
607
 
608
/* Return a value of type TYPE, stored in register REGNUM, in frame FRAME.  */
609
 
610
struct value *
611
value_from_register (struct type *type, int regnum, struct frame_info *frame)
612
{
613
  struct gdbarch *gdbarch = get_frame_arch (frame);
614
  struct type *type1 = check_typedef (type);
615
  struct value *v;
616
 
617
  if (gdbarch_convert_register_p (gdbarch, regnum, type1))
618
    {
619
      /* The ISA/ABI need to something weird when obtaining the
620
         specified value from this register.  It might need to
621
         re-order non-adjacent, starting with REGNUM (see MIPS and
622
         i386).  It might need to convert the [float] register into
623
         the corresponding [integer] type (see Alpha).  The assumption
624
         is that gdbarch_register_to_value populates the entire value
625
         including the location.  */
626
      v = allocate_value (type);
627
      VALUE_LVAL (v) = lval_register;
628
      VALUE_FRAME_ID (v) = get_frame_id (frame);
629
      VALUE_REGNUM (v) = regnum;
630
      gdbarch_register_to_value (gdbarch,
631
                                 frame, regnum, type1, value_contents_raw (v));
632
    }
633
  else
634
    {
635
      int len = TYPE_LENGTH (type);
636
 
637
      /* Construct the value.  */
638
      v = gdbarch_value_from_register (gdbarch, type, regnum, frame);
639
 
640
      /* Get the data.  */
641
      if (!get_frame_register_bytes (frame, regnum, value_offset (v), len,
642
                                     value_contents_raw (v)))
643
        set_value_optimized_out (v, 1);
644
    }
645
  return v;
646
}
647
 
648
/* Return contents of register REGNUM in frame FRAME as address,
649
   interpreted as value of type TYPE.   Will abort if register
650
   value is not available.  */
651
 
652
CORE_ADDR
653
address_from_register (struct type *type, int regnum, struct frame_info *frame)
654
{
655
  struct value *value;
656
  CORE_ADDR result;
657
 
658
  value = value_from_register (type, regnum, frame);
659
  gdb_assert (value);
660
 
661
  result = value_as_address (value);
662
  release_value (value);
663
  value_free (value);
664
 
665
  return result;
666
}

powered by: WebSVN 2.1.0

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