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

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-6.8/] [gdb/] [findvar.c] - Blame information for rev 258

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

Line No. Rev Author Line
1 24 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
5
   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
 
38
/* Basic byte-swapping routines.  GDB has needed these for a long time...
39
   All extract a target-format integer at ADDR which is LEN bytes long.  */
40
 
41
#if TARGET_CHAR_BIT != 8 || HOST_CHAR_BIT != 8
42
  /* 8 bit characters are a pretty safe assumption these days, so we
43
     assume it throughout all these swapping routines.  If we had to deal with
44
     9 bit characters, we would need to make len be in bits and would have
45
     to re-write these routines...  */
46
you lose
47
#endif
48
 
49
LONGEST
50
extract_signed_integer (const gdb_byte *addr, int len)
51
{
52
  LONGEST retval;
53
  const unsigned char *p;
54
  const unsigned char *startaddr = addr;
55
  const unsigned char *endaddr = startaddr + len;
56
 
57
  if (len > (int) sizeof (LONGEST))
58
    error (_("\
59
That operation is not available on integers of more than %d bytes."),
60
           (int) sizeof (LONGEST));
61
 
62
  /* Start at the most significant end of the integer, and work towards
63
     the least significant.  */
64
  if (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG)
65
    {
66
      p = startaddr;
67
      /* Do the sign extension once at the start.  */
68
      retval = ((LONGEST) * p ^ 0x80) - 0x80;
69
      for (++p; p < endaddr; ++p)
70
        retval = (retval << 8) | *p;
71
    }
72
  else
73
    {
74
      p = endaddr - 1;
75
      /* Do the sign extension once at the start.  */
76
      retval = ((LONGEST) * p ^ 0x80) - 0x80;
77
      for (--p; p >= startaddr; --p)
78
        retval = (retval << 8) | *p;
79
    }
80
  return retval;
81
}
82
 
83
ULONGEST
84
extract_unsigned_integer (const gdb_byte *addr, int len)
85
{
86
  ULONGEST retval;
87
  const unsigned char *p;
88
  const unsigned char *startaddr = addr;
89
  const unsigned char *endaddr = startaddr + len;
90
 
91
  if (len > (int) sizeof (ULONGEST))
92
    error (_("\
93
That operation is not available on integers of more than %d bytes."),
94
           (int) sizeof (ULONGEST));
95
 
96
  /* Start at the most significant end of the integer, and work towards
97
     the least significant.  */
98
  retval = 0;
99
  if (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG)
100
    {
101
      for (p = startaddr; p < endaddr; ++p)
102
        retval = (retval << 8) | *p;
103
    }
104
  else
105
    {
106
      for (p = endaddr - 1; p >= startaddr; --p)
107
        retval = (retval << 8) | *p;
108
    }
109
  return retval;
110
}
111
 
112
/* Sometimes a long long unsigned integer can be extracted as a
113
   LONGEST value.  This is done so that we can print these values
114
   better.  If this integer can be converted to a LONGEST, this
115
   function returns 1 and sets *PVAL.  Otherwise it returns 0.  */
116
 
117
int
118
extract_long_unsigned_integer (const gdb_byte *addr, int orig_len,
119
                               LONGEST *pval)
120
{
121
  const gdb_byte *p;
122
  const gdb_byte *first_addr;
123
  int len;
124
 
125
  len = orig_len;
126
  if (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG)
127
    {
128
      for (p = addr;
129
           len > (int) sizeof (LONGEST) && p < addr + orig_len;
130
           p++)
131
        {
132
          if (*p == 0)
133
            len--;
134
          else
135
            break;
136
        }
137
      first_addr = p;
138
    }
139
  else
140
    {
141
      first_addr = addr;
142
      for (p = addr + orig_len - 1;
143
           len > (int) sizeof (LONGEST) && p >= addr;
144
           p--)
145
        {
146
          if (*p == 0)
147
            len--;
148
          else
149
            break;
150
        }
151
    }
152
 
153
  if (len <= (int) sizeof (LONGEST))
154
    {
155
      *pval = (LONGEST) extract_unsigned_integer (first_addr,
156
                                                  sizeof (LONGEST));
157
      return 1;
158
    }
159
 
160
  return 0;
161
}
162
 
163
 
164
/* Treat the bytes at BUF as a pointer of type TYPE, and return the
165
   address it represents.  */
166
CORE_ADDR
167
extract_typed_address (const gdb_byte *buf, struct type *type)
168
{
169
  if (TYPE_CODE (type) != TYPE_CODE_PTR
170
      && TYPE_CODE (type) != TYPE_CODE_REF)
171
    internal_error (__FILE__, __LINE__,
172
                    _("extract_typed_address: "
173
                    "type is not a pointer or reference"));
174
 
175
  return gdbarch_pointer_to_address (current_gdbarch, type, buf);
176
}
177
 
178
 
179
void
180
store_signed_integer (gdb_byte *addr, int len, LONGEST val)
181
{
182
  gdb_byte *p;
183
  gdb_byte *startaddr = addr;
184
  gdb_byte *endaddr = startaddr + len;
185
 
186
  /* Start at the least significant end of the integer, and work towards
187
     the most significant.  */
188
  if (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG)
189
    {
190
      for (p = endaddr - 1; p >= startaddr; --p)
191
        {
192
          *p = val & 0xff;
193
          val >>= 8;
194
        }
195
    }
196
  else
197
    {
198
      for (p = startaddr; p < endaddr; ++p)
199
        {
200
          *p = val & 0xff;
201
          val >>= 8;
202
        }
203
    }
204
}
205
 
206
void
207
store_unsigned_integer (gdb_byte *addr, int len, ULONGEST val)
208
{
209
  unsigned char *p;
210
  unsigned char *startaddr = (unsigned char *) addr;
211
  unsigned char *endaddr = startaddr + len;
212
 
213
  /* Start at the least significant end of the integer, and work towards
214
     the most significant.  */
215
  if (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG)
216
    {
217
      for (p = endaddr - 1; p >= startaddr; --p)
218
        {
219
          *p = val & 0xff;
220
          val >>= 8;
221
        }
222
    }
223
  else
224
    {
225
      for (p = startaddr; p < endaddr; ++p)
226
        {
227
          *p = val & 0xff;
228
          val >>= 8;
229
        }
230
    }
231
}
232
 
233
/* Store the address ADDR as a pointer of type TYPE at BUF, in target
234
   form.  */
235
void
236
store_typed_address (gdb_byte *buf, struct type *type, CORE_ADDR addr)
237
{
238
  if (TYPE_CODE (type) != TYPE_CODE_PTR
239
      && TYPE_CODE (type) != TYPE_CODE_REF)
240
    internal_error (__FILE__, __LINE__,
241
                    _("store_typed_address: "
242
                    "type is not a pointer or reference"));
243
 
244
  gdbarch_address_to_pointer (current_gdbarch, type, buf, addr);
245
}
246
 
247
 
248
 
249
/* Return a `value' with the contents of (virtual or cooked) register
250
   REGNUM as found in the specified FRAME.  The register's type is
251
   determined by register_type().  */
252
 
253
struct value *
254
value_of_register (int regnum, struct frame_info *frame)
255
{
256
  struct gdbarch *gdbarch = get_frame_arch (frame);
257
  CORE_ADDR addr;
258
  int optim;
259
  struct value *reg_val;
260
  int realnum;
261
  gdb_byte raw_buffer[MAX_REGISTER_SIZE];
262
  enum lval_type lval;
263
 
264
  /* User registers lie completely outside of the range of normal
265
     registers.  Catch them early so that the target never sees them.  */
266
  if (regnum >= gdbarch_num_regs (gdbarch)
267
                + gdbarch_num_pseudo_regs (gdbarch))
268
    return value_of_user_reg (regnum, frame);
269
 
270
  frame_register (frame, regnum, &optim, &lval, &addr, &realnum, raw_buffer);
271
 
272
  reg_val = allocate_value (register_type (gdbarch, regnum));
273
 
274
  memcpy (value_contents_raw (reg_val), raw_buffer,
275
          register_size (gdbarch, regnum));
276
  VALUE_LVAL (reg_val) = lval;
277
  VALUE_ADDRESS (reg_val) = addr;
278
  VALUE_REGNUM (reg_val) = regnum;
279
  set_value_optimized_out (reg_val, optim);
280
  VALUE_FRAME_ID (reg_val) = get_frame_id (frame);
281
  return reg_val;
282
}
283
 
284
/* Given a pointer of type TYPE in target form in BUF, return the
285
   address it represents.  */
286
CORE_ADDR
287
unsigned_pointer_to_address (struct type *type, const gdb_byte *buf)
288
{
289
  return extract_unsigned_integer (buf, TYPE_LENGTH (type));
290
}
291
 
292
CORE_ADDR
293
signed_pointer_to_address (struct type *type, const gdb_byte *buf)
294
{
295
  return extract_signed_integer (buf, TYPE_LENGTH (type));
296
}
297
 
298
/* Given an address, store it as a pointer of type TYPE in target
299
   format in BUF.  */
300
void
301
unsigned_address_to_pointer (struct type *type, gdb_byte *buf,
302
                             CORE_ADDR addr)
303
{
304
  store_unsigned_integer (buf, TYPE_LENGTH (type), addr);
305
}
306
 
307
void
308
address_to_signed_pointer (struct type *type, gdb_byte *buf, CORE_ADDR addr)
309
{
310
  store_signed_integer (buf, TYPE_LENGTH (type), addr);
311
}
312
 
313
/* Will calling read_var_value or locate_var_value on SYM end
314
   up caring what frame it is being evaluated relative to?  SYM must
315
   be non-NULL.  */
316
int
317
symbol_read_needs_frame (struct symbol *sym)
318
{
319
  switch (SYMBOL_CLASS (sym))
320
    {
321
      /* All cases listed explicitly so that gcc -Wall will detect it if
322
         we failed to consider one.  */
323
    case LOC_COMPUTED:
324
    case LOC_COMPUTED_ARG:
325
      /* FIXME: cagney/2004-01-26: It should be possible to
326
         unconditionally call the SYMBOL_OPS method when available.
327
         Unfortunately DWARF 2 stores the frame-base (instead of the
328
         function) location in a function's symbol.  Oops!  For the
329
         moment enable this when/where applicable.  */
330
      return SYMBOL_OPS (sym)->read_needs_frame (sym);
331
 
332
    case LOC_REGISTER:
333
    case LOC_ARG:
334
    case LOC_REF_ARG:
335
    case LOC_REGPARM:
336
    case LOC_REGPARM_ADDR:
337
    case LOC_LOCAL:
338
    case LOC_LOCAL_ARG:
339
    case LOC_BASEREG:
340
    case LOC_BASEREG_ARG:
341
    case LOC_HP_THREAD_LOCAL_STATIC:
342
      return 1;
343
 
344
    case LOC_UNDEF:
345
    case LOC_CONST:
346
    case LOC_STATIC:
347
    case LOC_INDIRECT:
348
    case LOC_TYPEDEF:
349
 
350
    case LOC_LABEL:
351
      /* Getting the address of a label can be done independently of the block,
352
         even if some *uses* of that address wouldn't work so well without
353
         the right frame.  */
354
 
355
    case LOC_BLOCK:
356
    case LOC_CONST_BYTES:
357
    case LOC_UNRESOLVED:
358
    case LOC_OPTIMIZED_OUT:
359
      return 0;
360
    }
361
  return 1;
362
}
363
 
364
/* Given a struct symbol for a variable,
365
   and a stack frame id, read the value of the variable
366
   and return a (pointer to a) struct value containing the value.
367
   If the variable cannot be found, return a zero pointer.
368
   If FRAME is NULL, use the selected frame.  */
369
 
370
struct value *
371
read_var_value (struct symbol *var, struct frame_info *frame)
372
{
373
  struct value *v;
374
  struct type *type = SYMBOL_TYPE (var);
375
  CORE_ADDR addr;
376
  int len;
377
 
378
  if (SYMBOL_CLASS (var) == LOC_COMPUTED
379
      || SYMBOL_CLASS (var) == LOC_COMPUTED_ARG
380
      || SYMBOL_CLASS (var) == LOC_REGISTER
381
      || SYMBOL_CLASS (var) == LOC_REGPARM)
382
    /* These cases do not use V.  */
383
    v = NULL;
384
  else
385
    {
386
      v = allocate_value (type);
387
      VALUE_LVAL (v) = lval_memory;     /* The most likely possibility.  */
388
    }
389
 
390
  len = TYPE_LENGTH (type);
391
 
392
  /* FIXME drow/2003-09-06: this call to the selected frame should be
393
     pushed upwards to the callers.  */
394
  if (frame == NULL)
395
    frame = deprecated_safe_get_selected_frame ();
396
 
397
  switch (SYMBOL_CLASS (var))
398
    {
399
    case LOC_CONST:
400
      /* Put the constant back in target format.  */
401
      store_signed_integer (value_contents_raw (v), len,
402
                            (LONGEST) SYMBOL_VALUE (var));
403
      VALUE_LVAL (v) = not_lval;
404
      return v;
405
 
406
    case LOC_LABEL:
407
      /* Put the constant back in target format.  */
408
      if (overlay_debugging)
409
        {
410
          CORE_ADDR addr
411
            = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var),
412
                                        SYMBOL_BFD_SECTION (var));
413
          store_typed_address (value_contents_raw (v), type, addr);
414
        }
415
      else
416
        store_typed_address (value_contents_raw (v), type,
417
                              SYMBOL_VALUE_ADDRESS (var));
418
      VALUE_LVAL (v) = not_lval;
419
      return v;
420
 
421
    case LOC_CONST_BYTES:
422
      {
423
        memcpy (value_contents_raw (v), SYMBOL_VALUE_BYTES (var), len);
424
        VALUE_LVAL (v) = not_lval;
425
        return v;
426
      }
427
 
428
    case LOC_STATIC:
429
      if (overlay_debugging)
430
        addr = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var),
431
                                         SYMBOL_BFD_SECTION (var));
432
      else
433
        addr = SYMBOL_VALUE_ADDRESS (var);
434
      break;
435
 
436
    case LOC_INDIRECT:
437
      {
438
        /* The import slot does not have a real address in it from the
439
           dynamic loader (dld.sl on HP-UX), if the target hasn't
440
           begun execution yet, so check for that. */
441
        CORE_ADDR locaddr;
442
        struct value *loc;
443
        if (!target_has_execution)
444
          error (_("\
445
Attempt to access variable defined in different shared object or load module when\n\
446
addresses have not been bound by the dynamic loader. Try again when executable is running."));
447
 
448
        locaddr = SYMBOL_VALUE_ADDRESS (var);
449
        loc = value_at (lookup_pointer_type (type), locaddr);
450
        addr = value_as_address (loc);
451
        break;
452
      }
453
 
454
    case LOC_ARG:
455
      if (frame == NULL)
456
        return 0;
457
      addr = get_frame_args_address (frame);
458
      if (!addr)
459
        return 0;
460
      addr += SYMBOL_VALUE (var);
461
      break;
462
 
463
    case LOC_REF_ARG:
464
      {
465
        struct value *ref;
466
        CORE_ADDR argref;
467
        if (frame == NULL)
468
          return 0;
469
        argref = get_frame_args_address (frame);
470
        if (!argref)
471
          return 0;
472
        argref += SYMBOL_VALUE (var);
473
        ref = value_at (lookup_pointer_type (type), argref);
474
        addr = value_as_address (ref);
475
        break;
476
      }
477
 
478
    case LOC_LOCAL:
479
    case LOC_LOCAL_ARG:
480
      if (frame == NULL)
481
        return 0;
482
      addr = get_frame_locals_address (frame);
483
      addr += SYMBOL_VALUE (var);
484
      break;
485
 
486
    case LOC_BASEREG:
487
    case LOC_BASEREG_ARG:
488
    case LOC_HP_THREAD_LOCAL_STATIC:
489
      {
490
        struct value *regval;
491
 
492
        regval = value_from_register (lookup_pointer_type (type),
493
                                      SYMBOL_BASEREG (var), frame);
494
        if (regval == NULL)
495
          error (_("Value of base register not available."));
496
        addr = value_as_address (regval);
497
        addr += SYMBOL_VALUE (var);
498
        break;
499
      }
500
 
501
    case LOC_TYPEDEF:
502
      error (_("Cannot look up value of a typedef"));
503
      break;
504
 
505
    case LOC_BLOCK:
506
      if (overlay_debugging)
507
        VALUE_ADDRESS (v) = symbol_overlayed_address
508
          (BLOCK_START (SYMBOL_BLOCK_VALUE (var)), SYMBOL_BFD_SECTION (var));
509
      else
510
        VALUE_ADDRESS (v) = BLOCK_START (SYMBOL_BLOCK_VALUE (var));
511
      return v;
512
 
513
    case LOC_REGISTER:
514
    case LOC_REGPARM:
515
    case LOC_REGPARM_ADDR:
516
      {
517
        struct block *b;
518
        int regno = SYMBOL_VALUE (var);
519
        struct value *regval;
520
 
521
        if (frame == NULL)
522
          return 0;
523
        b = get_frame_block (frame, 0);
524
 
525
        if (SYMBOL_CLASS (var) == LOC_REGPARM_ADDR)
526
          {
527
            regval = value_from_register (lookup_pointer_type (type),
528
                                          regno,
529
                                          frame);
530
 
531
            if (regval == NULL)
532
              error (_("Value of register variable not available."));
533
 
534
            addr = value_as_address (regval);
535
            VALUE_LVAL (v) = lval_memory;
536
          }
537
        else
538
          {
539
            regval = value_from_register (type, regno, frame);
540
 
541
            if (regval == NULL)
542
              error (_("Value of register variable not available."));
543
            return regval;
544
          }
545
      }
546
      break;
547
 
548
    case LOC_COMPUTED:
549
    case LOC_COMPUTED_ARG:
550
      /* FIXME: cagney/2004-01-26: It should be possible to
551
         unconditionally call the SYMBOL_OPS method when available.
552
         Unfortunately DWARF 2 stores the frame-base (instead of the
553
         function) location in a function's symbol.  Oops!  For the
554
         moment enable this when/where applicable.  */
555
      if (frame == 0 && SYMBOL_OPS (var)->read_needs_frame (var))
556
        return 0;
557
      return SYMBOL_OPS (var)->read_variable (var, frame);
558
 
559
    case LOC_UNRESOLVED:
560
      {
561
        struct minimal_symbol *msym;
562
 
563
        msym = lookup_minimal_symbol (DEPRECATED_SYMBOL_NAME (var), NULL, NULL);
564
        if (msym == NULL)
565
          return 0;
566
        if (overlay_debugging)
567
          addr = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (msym),
568
                                           SYMBOL_BFD_SECTION (msym));
569
        else
570
          addr = SYMBOL_VALUE_ADDRESS (msym);
571
      }
572
      break;
573
 
574
    case LOC_OPTIMIZED_OUT:
575
      VALUE_LVAL (v) = not_lval;
576
      set_value_optimized_out (v, 1);
577
      return v;
578
 
579
    default:
580
      error (_("Cannot look up value of a botched symbol."));
581
      break;
582
    }
583
 
584
  VALUE_ADDRESS (v) = addr;
585
  set_value_lazy (v, 1);
586
  return v;
587
}
588
 
589
/* Install default attributes for register values.  */
590
 
591
struct value *
592
default_value_from_register (struct type *type, int regnum,
593
                             struct frame_info *frame)
594
{
595
  struct gdbarch *gdbarch = get_frame_arch (frame);
596
  int len = TYPE_LENGTH (type);
597
  struct value *value = allocate_value (type);
598
 
599
  VALUE_LVAL (value) = lval_register;
600
  VALUE_FRAME_ID (value) = get_frame_id (frame);
601
  VALUE_REGNUM (value) = regnum;
602
 
603
  /* Any structure stored in more than one register will always be
604
     an integral number of registers.  Otherwise, you need to do
605
     some fiddling with the last register copied here for little
606
     endian machines.  */
607
  if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG
608
      && len < register_size (gdbarch, regnum))
609
    /* Big-endian, and we want less than full size.  */
610
    set_value_offset (value, register_size (gdbarch, regnum) - len);
611
  else
612
    set_value_offset (value, 0);
613
 
614
  return value;
615
}
616
 
617
/* Return a value of type TYPE, stored in register REGNUM, in frame FRAME.  */
618
 
619
struct value *
620
value_from_register (struct type *type, int regnum, struct frame_info *frame)
621
{
622
  struct gdbarch *gdbarch = get_frame_arch (frame);
623
  struct type *type1 = check_typedef (type);
624
  struct value *v;
625
 
626
  if (gdbarch_convert_register_p (gdbarch, regnum, type1))
627
    {
628
      /* The ISA/ABI need to something weird when obtaining the
629
         specified value from this register.  It might need to
630
         re-order non-adjacent, starting with REGNUM (see MIPS and
631
         i386).  It might need to convert the [float] register into
632
         the corresponding [integer] type (see Alpha).  The assumption
633
         is that gdbarch_register_to_value populates the entire value
634
         including the location.  */
635
      v = allocate_value (type);
636
      VALUE_LVAL (v) = lval_register;
637
      VALUE_FRAME_ID (v) = get_frame_id (frame);
638
      VALUE_REGNUM (v) = regnum;
639
      gdbarch_register_to_value (gdbarch,
640
                                 frame, regnum, type1, value_contents_raw (v));
641
    }
642
  else
643
    {
644
      int len = TYPE_LENGTH (type);
645
 
646
      /* Construct the value.  */
647
      v = gdbarch_value_from_register (gdbarch, type, regnum, frame);
648
 
649
      /* Get the data.  */
650
      if (!get_frame_register_bytes (frame, regnum, value_offset (v), len,
651
                                     value_contents_raw (v)))
652
        set_value_optimized_out (v, 1);
653
    }
654
  return v;
655
}
656
 
657
/* Return contents of register REGNUM in frame FRAME as address,
658
   interpreted as value of type TYPE.   Will abort if register
659
   value is not available.  */
660
 
661
CORE_ADDR
662
address_from_register (struct type *type, int regnum, struct frame_info *frame)
663
{
664
  struct value *value;
665
  CORE_ADDR result;
666
 
667
  value = value_from_register (type, regnum, frame);
668
  gdb_assert (value);
669
 
670
  result = value_as_address (value);
671
  release_value (value);
672
  value_free (value);
673
 
674
  return result;
675
}
676
 
677
 
678
/* Given a struct symbol for a variable or function,
679
   and a stack frame id,
680
   return a (pointer to a) struct value containing the properly typed
681
   address.  */
682
 
683
struct value *
684
locate_var_value (struct symbol *var, struct frame_info *frame)
685
{
686
  struct gdbarch *gdbarch = get_frame_arch (frame);
687
  CORE_ADDR addr = 0;
688
  struct type *type = SYMBOL_TYPE (var);
689
  struct value *lazy_value;
690
 
691
  /* Evaluate it first; if the result is a memory address, we're fine.
692
     Lazy evaluation pays off here. */
693
 
694
  lazy_value = read_var_value (var, frame);
695
  if (lazy_value == 0)
696
    error (_("Address of \"%s\" is unknown."), SYMBOL_PRINT_NAME (var));
697
 
698
  if (value_lazy (lazy_value)
699
      || TYPE_CODE (type) == TYPE_CODE_FUNC)
700
    {
701
      struct value *val;
702
 
703
      addr = VALUE_ADDRESS (lazy_value);
704
      val = value_from_pointer (lookup_pointer_type (type), addr);
705
      return val;
706
    }
707
 
708
  /* Not a memory address; check what the problem was.  */
709
  switch (VALUE_LVAL (lazy_value))
710
    {
711
    case lval_register:
712
      gdb_assert (gdbarch_register_name
713
                   (gdbarch, VALUE_REGNUM (lazy_value)) != NULL
714
                  && *gdbarch_register_name
715
                    (gdbarch, VALUE_REGNUM (lazy_value)) != '\0');
716
      error (_("Address requested for identifier "
717
               "\"%s\" which is in register $%s"),
718
            SYMBOL_PRINT_NAME (var),
719
            gdbarch_register_name (gdbarch, VALUE_REGNUM (lazy_value)));
720
      break;
721
 
722
    default:
723
      error (_("Can't take address of \"%s\" which isn't an lvalue."),
724
             SYMBOL_PRINT_NAME (var));
725
      break;
726
    }
727
  return 0;                      /* For lint -- never reached */
728
}

powered by: WebSVN 2.1.0

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