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

Subversion Repositories or1k

[/] [or1k/] [trunk/] [gdb-5.3/] [gdb/] [values.c] - Blame information for rev 1765

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 1181 sfurman
/* Low level packing and unpacking of values for GDB, the GNU Debugger.
2
   Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994,
3
   1995, 1996, 1997, 1998, 1999, 2000, 2002.
4
   Free Software Foundation, Inc.
5
 
6
   This file is part of GDB.
7
 
8
   This program is free software; you can redistribute it and/or modify
9
   it under the terms of the GNU General Public License as published by
10
   the Free Software Foundation; either version 2 of the License, or
11
   (at your option) any later version.
12
 
13
   This program is distributed in the hope that it will be useful,
14
   but WITHOUT ANY WARRANTY; without even the implied warranty of
15
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16
   GNU General Public License for more details.
17
 
18
   You should have received a copy of the GNU General Public License
19
   along with this program; if not, write to the Free Software
20
   Foundation, Inc., 59 Temple Place - Suite 330,
21
   Boston, MA 02111-1307, USA.  */
22
 
23
#include "defs.h"
24
#include "gdb_string.h"
25
#include "symtab.h"
26
#include "gdbtypes.h"
27
#include "value.h"
28
#include "gdbcore.h"
29
#include "command.h"
30
#include "gdbcmd.h"
31
#include "target.h"
32
#include "language.h"
33
#include "scm-lang.h"
34
#include "demangle.h"
35
#include "doublest.h"
36
#include "gdb_assert.h"
37
#include "regcache.h"
38
 
39
/* Prototypes for exported functions. */
40
 
41
void _initialize_values (void);
42
 
43
/* Prototypes for local functions. */
44
 
45
static void show_values (char *, int);
46
 
47
static void show_convenience (char *, int);
48
 
49
 
50
/* The value-history records all the values printed
51
   by print commands during this session.  Each chunk
52
   records 60 consecutive values.  The first chunk on
53
   the chain records the most recent values.
54
   The total number of values is in value_history_count.  */
55
 
56
#define VALUE_HISTORY_CHUNK 60
57
 
58
struct value_history_chunk
59
  {
60
    struct value_history_chunk *next;
61
    struct value *values[VALUE_HISTORY_CHUNK];
62
  };
63
 
64
/* Chain of chunks now in use.  */
65
 
66
static struct value_history_chunk *value_history_chain;
67
 
68
static int value_history_count; /* Abs number of last entry stored */
69
 
70
/* List of all value objects currently allocated
71
   (except for those released by calls to release_value)
72
   This is so they can be freed after each command.  */
73
 
74
static struct value *all_values;
75
 
76
/* Allocate a  value  that has the correct length for type TYPE.  */
77
 
78
struct value *
79
allocate_value (struct type *type)
80
{
81
  struct value *val;
82
  struct type *atype = check_typedef (type);
83
 
84
  val = (struct value *) xmalloc (sizeof (struct value) + TYPE_LENGTH (atype));
85
  VALUE_NEXT (val) = all_values;
86
  all_values = val;
87
  VALUE_TYPE (val) = type;
88
  VALUE_ENCLOSING_TYPE (val) = type;
89
  VALUE_LVAL (val) = not_lval;
90
  VALUE_ADDRESS (val) = 0;
91
  VALUE_FRAME (val) = 0;
92
  VALUE_OFFSET (val) = 0;
93
  VALUE_BITPOS (val) = 0;
94
  VALUE_BITSIZE (val) = 0;
95
  VALUE_REGNO (val) = -1;
96
  VALUE_LAZY (val) = 0;
97
  VALUE_OPTIMIZED_OUT (val) = 0;
98
  VALUE_BFD_SECTION (val) = NULL;
99
  VALUE_EMBEDDED_OFFSET (val) = 0;
100
  VALUE_POINTED_TO_OFFSET (val) = 0;
101
  val->modifiable = 1;
102
  return val;
103
}
104
 
105
/* Allocate a  value  that has the correct length
106
   for COUNT repetitions type TYPE.  */
107
 
108
struct value *
109
allocate_repeat_value (struct type *type, int count)
110
{
111
  int low_bound = current_language->string_lower_bound;         /* ??? */
112
  /* FIXME-type-allocation: need a way to free this type when we are
113
     done with it.  */
114
  struct type *range_type
115
  = create_range_type ((struct type *) NULL, builtin_type_int,
116
                       low_bound, count + low_bound - 1);
117
  /* FIXME-type-allocation: need a way to free this type when we are
118
     done with it.  */
119
  return allocate_value (create_array_type ((struct type *) NULL,
120
                                            type, range_type));
121
}
122
 
123
/* Return a mark in the value chain.  All values allocated after the
124
   mark is obtained (except for those released) are subject to being freed
125
   if a subsequent value_free_to_mark is passed the mark.  */
126
struct value *
127
value_mark (void)
128
{
129
  return all_values;
130
}
131
 
132
/* Free all values allocated since MARK was obtained by value_mark
133
   (except for those released).  */
134
void
135
value_free_to_mark (struct value *mark)
136
{
137
  struct value *val;
138
  struct value *next;
139
 
140
  for (val = all_values; val && val != mark; val = next)
141
    {
142
      next = VALUE_NEXT (val);
143
      value_free (val);
144
    }
145
  all_values = val;
146
}
147
 
148
/* Free all the values that have been allocated (except for those released).
149
   Called after each command, successful or not.  */
150
 
151
void
152
free_all_values (void)
153
{
154
  struct value *val;
155
  struct value *next;
156
 
157
  for (val = all_values; val; val = next)
158
    {
159
      next = VALUE_NEXT (val);
160
      value_free (val);
161
    }
162
 
163
  all_values = 0;
164
}
165
 
166
/* Remove VAL from the chain all_values
167
   so it will not be freed automatically.  */
168
 
169
void
170
release_value (struct value *val)
171
{
172
  struct value *v;
173
 
174
  if (all_values == val)
175
    {
176
      all_values = val->next;
177
      return;
178
    }
179
 
180
  for (v = all_values; v; v = v->next)
181
    {
182
      if (v->next == val)
183
        {
184
          v->next = val->next;
185
          break;
186
        }
187
    }
188
}
189
 
190
/* Release all values up to mark  */
191
struct value *
192
value_release_to_mark (struct value *mark)
193
{
194
  struct value *val;
195
  struct value *next;
196
 
197
  for (val = next = all_values; next; next = VALUE_NEXT (next))
198
    if (VALUE_NEXT (next) == mark)
199
      {
200
        all_values = VALUE_NEXT (next);
201
        VALUE_NEXT (next) = 0;
202
        return val;
203
      }
204
  all_values = 0;
205
  return val;
206
}
207
 
208
/* Return a copy of the value ARG.
209
   It contains the same contents, for same memory address,
210
   but it's a different block of storage.  */
211
 
212
struct value *
213
value_copy (struct value *arg)
214
{
215
  register struct type *encl_type = VALUE_ENCLOSING_TYPE (arg);
216
  struct value *val = allocate_value (encl_type);
217
  VALUE_TYPE (val) = VALUE_TYPE (arg);
218
  VALUE_LVAL (val) = VALUE_LVAL (arg);
219
  VALUE_ADDRESS (val) = VALUE_ADDRESS (arg);
220
  VALUE_OFFSET (val) = VALUE_OFFSET (arg);
221
  VALUE_BITPOS (val) = VALUE_BITPOS (arg);
222
  VALUE_BITSIZE (val) = VALUE_BITSIZE (arg);
223
  VALUE_FRAME (val) = VALUE_FRAME (arg);
224
  VALUE_REGNO (val) = VALUE_REGNO (arg);
225
  VALUE_LAZY (val) = VALUE_LAZY (arg);
226
  VALUE_OPTIMIZED_OUT (val) = VALUE_OPTIMIZED_OUT (arg);
227
  VALUE_EMBEDDED_OFFSET (val) = VALUE_EMBEDDED_OFFSET (arg);
228
  VALUE_POINTED_TO_OFFSET (val) = VALUE_POINTED_TO_OFFSET (arg);
229
  VALUE_BFD_SECTION (val) = VALUE_BFD_SECTION (arg);
230
  val->modifiable = arg->modifiable;
231
  if (!VALUE_LAZY (val))
232
    {
233
      memcpy (VALUE_CONTENTS_ALL_RAW (val), VALUE_CONTENTS_ALL_RAW (arg),
234
              TYPE_LENGTH (VALUE_ENCLOSING_TYPE (arg)));
235
 
236
    }
237
  return val;
238
}
239
 
240
/* Access to the value history.  */
241
 
242
/* Record a new value in the value history.
243
   Returns the absolute history index of the entry.
244
   Result of -1 indicates the value was not saved; otherwise it is the
245
   value history index of this new item.  */
246
 
247
int
248
record_latest_value (struct value *val)
249
{
250
  int i;
251
 
252
  /* We don't want this value to have anything to do with the inferior anymore.
253
     In particular, "set $1 = 50" should not affect the variable from which
254
     the value was taken, and fast watchpoints should be able to assume that
255
     a value on the value history never changes.  */
256
  if (VALUE_LAZY (val))
257
    value_fetch_lazy (val);
258
  /* We preserve VALUE_LVAL so that the user can find out where it was fetched
259
     from.  This is a bit dubious, because then *&$1 does not just return $1
260
     but the current contents of that location.  c'est la vie...  */
261
  val->modifiable = 0;
262
  release_value (val);
263
 
264
  /* Here we treat value_history_count as origin-zero
265
     and applying to the value being stored now.  */
266
 
267
  i = value_history_count % VALUE_HISTORY_CHUNK;
268
  if (i == 0)
269
    {
270
      struct value_history_chunk *new
271
      = (struct value_history_chunk *)
272
      xmalloc (sizeof (struct value_history_chunk));
273
      memset (new->values, 0, sizeof new->values);
274
      new->next = value_history_chain;
275
      value_history_chain = new;
276
    }
277
 
278
  value_history_chain->values[i] = val;
279
 
280
  /* Now we regard value_history_count as origin-one
281
     and applying to the value just stored.  */
282
 
283
  return ++value_history_count;
284
}
285
 
286
/* Return a copy of the value in the history with sequence number NUM.  */
287
 
288
struct value *
289
access_value_history (int num)
290
{
291
  struct value_history_chunk *chunk;
292
  register int i;
293
  register int absnum = num;
294
 
295
  if (absnum <= 0)
296
    absnum += value_history_count;
297
 
298
  if (absnum <= 0)
299
    {
300
      if (num == 0)
301
        error ("The history is empty.");
302
      else if (num == 1)
303
        error ("There is only one value in the history.");
304
      else
305
        error ("History does not go back to $$%d.", -num);
306
    }
307
  if (absnum > value_history_count)
308
    error ("History has not yet reached $%d.", absnum);
309
 
310
  absnum--;
311
 
312
  /* Now absnum is always absolute and origin zero.  */
313
 
314
  chunk = value_history_chain;
315
  for (i = (value_history_count - 1) / VALUE_HISTORY_CHUNK - absnum / VALUE_HISTORY_CHUNK;
316
       i > 0; i--)
317
    chunk = chunk->next;
318
 
319
  return value_copy (chunk->values[absnum % VALUE_HISTORY_CHUNK]);
320
}
321
 
322
/* Clear the value history entirely.
323
   Must be done when new symbol tables are loaded,
324
   because the type pointers become invalid.  */
325
 
326
void
327
clear_value_history (void)
328
{
329
  struct value_history_chunk *next;
330
  register int i;
331
  struct value *val;
332
 
333
  while (value_history_chain)
334
    {
335
      for (i = 0; i < VALUE_HISTORY_CHUNK; i++)
336
        if ((val = value_history_chain->values[i]) != NULL)
337
          xfree (val);
338
      next = value_history_chain->next;
339
      xfree (value_history_chain);
340
      value_history_chain = next;
341
    }
342
  value_history_count = 0;
343
}
344
 
345
static void
346
show_values (char *num_exp, int from_tty)
347
{
348
  register int i;
349
  struct value *val;
350
  static int num = 1;
351
 
352
  if (num_exp)
353
    {
354
      /* "info history +" should print from the stored position.
355
         "info history <exp>" should print around value number <exp>.  */
356
      if (num_exp[0] != '+' || num_exp[1] != '\0')
357
        num = parse_and_eval_long (num_exp) - 5;
358
    }
359
  else
360
    {
361
      /* "info history" means print the last 10 values.  */
362
      num = value_history_count - 9;
363
    }
364
 
365
  if (num <= 0)
366
    num = 1;
367
 
368
  for (i = num; i < num + 10 && i <= value_history_count; i++)
369
    {
370
      val = access_value_history (i);
371
      printf_filtered ("$%d = ", i);
372
      value_print (val, gdb_stdout, 0, Val_pretty_default);
373
      printf_filtered ("\n");
374
    }
375
 
376
  /* The next "info history +" should start after what we just printed.  */
377
  num += 10;
378
 
379
  /* Hitting just return after this command should do the same thing as
380
     "info history +".  If num_exp is null, this is unnecessary, since
381
     "info history +" is not useful after "info history".  */
382
  if (from_tty && num_exp)
383
    {
384
      num_exp[0] = '+';
385
      num_exp[1] = '\0';
386
    }
387
}
388
 
389
/* Internal variables.  These are variables within the debugger
390
   that hold values assigned by debugger commands.
391
   The user refers to them with a '$' prefix
392
   that does not appear in the variable names stored internally.  */
393
 
394
static struct internalvar *internalvars;
395
 
396
/* Look up an internal variable with name NAME.  NAME should not
397
   normally include a dollar sign.
398
 
399
   If the specified internal variable does not exist,
400
   one is created, with a void value.  */
401
 
402
struct internalvar *
403
lookup_internalvar (char *name)
404
{
405
  register struct internalvar *var;
406
 
407
  for (var = internalvars; var; var = var->next)
408
    if (STREQ (var->name, name))
409
      return var;
410
 
411
  var = (struct internalvar *) xmalloc (sizeof (struct internalvar));
412
  var->name = concat (name, NULL);
413
  var->value = allocate_value (builtin_type_void);
414
  release_value (var->value);
415
  var->next = internalvars;
416
  internalvars = var;
417
  return var;
418
}
419
 
420
struct value *
421
value_of_internalvar (struct internalvar *var)
422
{
423
  struct value *val;
424
 
425
#ifdef IS_TRAPPED_INTERNALVAR
426
  if (IS_TRAPPED_INTERNALVAR (var->name))
427
    return VALUE_OF_TRAPPED_INTERNALVAR (var);
428
#endif
429
 
430
  val = value_copy (var->value);
431
  if (VALUE_LAZY (val))
432
    value_fetch_lazy (val);
433
  VALUE_LVAL (val) = lval_internalvar;
434
  VALUE_INTERNALVAR (val) = var;
435
  return val;
436
}
437
 
438
void
439
set_internalvar_component (struct internalvar *var, int offset, int bitpos,
440
                           int bitsize, struct value *newval)
441
{
442
  register char *addr = VALUE_CONTENTS (var->value) + offset;
443
 
444
#ifdef IS_TRAPPED_INTERNALVAR
445
  if (IS_TRAPPED_INTERNALVAR (var->name))
446
    SET_TRAPPED_INTERNALVAR (var, newval, bitpos, bitsize, offset);
447
#endif
448
 
449
  if (bitsize)
450
    modify_field (addr, value_as_long (newval),
451
                  bitpos, bitsize);
452
  else
453
    memcpy (addr, VALUE_CONTENTS (newval), TYPE_LENGTH (VALUE_TYPE (newval)));
454
}
455
 
456
void
457
set_internalvar (struct internalvar *var, struct value *val)
458
{
459
  struct value *newval;
460
 
461
#ifdef IS_TRAPPED_INTERNALVAR
462
  if (IS_TRAPPED_INTERNALVAR (var->name))
463
    SET_TRAPPED_INTERNALVAR (var, val, 0, 0, 0);
464
#endif
465
 
466
  newval = value_copy (val);
467
  newval->modifiable = 1;
468
 
469
  /* Force the value to be fetched from the target now, to avoid problems
470
     later when this internalvar is referenced and the target is gone or
471
     has changed.  */
472
  if (VALUE_LAZY (newval))
473
    value_fetch_lazy (newval);
474
 
475
  /* Begin code which must not call error().  If var->value points to
476
     something free'd, an error() obviously leaves a dangling pointer.
477
     But we also get a danling pointer if var->value points to
478
     something in the value chain (i.e., before release_value is
479
     called), because after the error free_all_values will get called before
480
     long.  */
481
  xfree (var->value);
482
  var->value = newval;
483
  release_value (newval);
484
  /* End code which must not call error().  */
485
}
486
 
487
char *
488
internalvar_name (struct internalvar *var)
489
{
490
  return var->name;
491
}
492
 
493
/* Free all internalvars.  Done when new symtabs are loaded,
494
   because that makes the values invalid.  */
495
 
496
void
497
clear_internalvars (void)
498
{
499
  register struct internalvar *var;
500
 
501
  while (internalvars)
502
    {
503
      var = internalvars;
504
      internalvars = var->next;
505
      xfree (var->name);
506
      xfree (var->value);
507
      xfree (var);
508
    }
509
}
510
 
511
static void
512
show_convenience (char *ignore, int from_tty)
513
{
514
  register struct internalvar *var;
515
  int varseen = 0;
516
 
517
  for (var = internalvars; var; var = var->next)
518
    {
519
#ifdef IS_TRAPPED_INTERNALVAR
520
      if (IS_TRAPPED_INTERNALVAR (var->name))
521
        continue;
522
#endif
523
      if (!varseen)
524
        {
525
          varseen = 1;
526
        }
527
      printf_filtered ("$%s = ", var->name);
528
      value_print (var->value, gdb_stdout, 0, Val_pretty_default);
529
      printf_filtered ("\n");
530
    }
531
  if (!varseen)
532
    printf_unfiltered ("No debugger convenience variables now defined.\n\
533
Convenience variables have names starting with \"$\";\n\
534
use \"set\" as in \"set $foo = 5\" to define them.\n");
535
}
536
 
537
/* Extract a value as a C number (either long or double).
538
   Knows how to convert fixed values to double, or
539
   floating values to long.
540
   Does not deallocate the value.  */
541
 
542
LONGEST
543
value_as_long (struct value *val)
544
{
545
  /* This coerces arrays and functions, which is necessary (e.g.
546
     in disassemble_command).  It also dereferences references, which
547
     I suspect is the most logical thing to do.  */
548
  COERCE_ARRAY (val);
549
  return unpack_long (VALUE_TYPE (val), VALUE_CONTENTS (val));
550
}
551
 
552
DOUBLEST
553
value_as_double (struct value *val)
554
{
555
  DOUBLEST foo;
556
  int inv;
557
 
558
  foo = unpack_double (VALUE_TYPE (val), VALUE_CONTENTS (val), &inv);
559
  if (inv)
560
    error ("Invalid floating value found in program.");
561
  return foo;
562
}
563
/* Extract a value as a C pointer. Does not deallocate the value.
564
   Note that val's type may not actually be a pointer; value_as_long
565
   handles all the cases.  */
566
CORE_ADDR
567
value_as_address (struct value *val)
568
{
569
  /* Assume a CORE_ADDR can fit in a LONGEST (for now).  Not sure
570
     whether we want this to be true eventually.  */
571
#if 0
572
  /* ADDR_BITS_REMOVE is wrong if we are being called for a
573
     non-address (e.g. argument to "signal", "info break", etc.), or
574
     for pointers to char, in which the low bits *are* significant.  */
575
  return ADDR_BITS_REMOVE (value_as_long (val));
576
#else
577
 
578
  /* There are several targets (IA-64, PowerPC, and others) which
579
     don't represent pointers to functions as simply the address of
580
     the function's entry point.  For example, on the IA-64, a
581
     function pointer points to a two-word descriptor, generated by
582
     the linker, which contains the function's entry point, and the
583
     value the IA-64 "global pointer" register should have --- to
584
     support position-independent code.  The linker generates
585
     descriptors only for those functions whose addresses are taken.
586
 
587
     On such targets, it's difficult for GDB to convert an arbitrary
588
     function address into a function pointer; it has to either find
589
     an existing descriptor for that function, or call malloc and
590
     build its own.  On some targets, it is impossible for GDB to
591
     build a descriptor at all: the descriptor must contain a jump
592
     instruction; data memory cannot be executed; and code memory
593
     cannot be modified.
594
 
595
     Upon entry to this function, if VAL is a value of type `function'
596
     (that is, TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_FUNC), then
597
     VALUE_ADDRESS (val) is the address of the function.  This is what
598
     you'll get if you evaluate an expression like `main'.  The call
599
     to COERCE_ARRAY below actually does all the usual unary
600
     conversions, which includes converting values of type `function'
601
     to `pointer to function'.  This is the challenging conversion
602
     discussed above.  Then, `unpack_long' will convert that pointer
603
     back into an address.
604
 
605
     So, suppose the user types `disassemble foo' on an architecture
606
     with a strange function pointer representation, on which GDB
607
     cannot build its own descriptors, and suppose further that `foo'
608
     has no linker-built descriptor.  The address->pointer conversion
609
     will signal an error and prevent the command from running, even
610
     though the next step would have been to convert the pointer
611
     directly back into the same address.
612
 
613
     The following shortcut avoids this whole mess.  If VAL is a
614
     function, just return its address directly.  */
615
  if (TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_FUNC
616
      || TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_METHOD)
617
    return VALUE_ADDRESS (val);
618
 
619
  COERCE_ARRAY (val);
620
 
621
  /* Some architectures (e.g. Harvard), map instruction and data
622
     addresses onto a single large unified address space.  For
623
     instance: An architecture may consider a large integer in the
624
     range 0x10000000 .. 0x1000ffff to already represent a data
625
     addresses (hence not need a pointer to address conversion) while
626
     a small integer would still need to be converted integer to
627
     pointer to address.  Just assume such architectures handle all
628
     integer conversions in a single function.  */
629
 
630
  /* JimB writes:
631
 
632
     I think INTEGER_TO_ADDRESS is a good idea as proposed --- but we
633
     must admonish GDB hackers to make sure its behavior matches the
634
     compiler's, whenever possible.
635
 
636
     In general, I think GDB should evaluate expressions the same way
637
     the compiler does.  When the user copies an expression out of
638
     their source code and hands it to a `print' command, they should
639
     get the same value the compiler would have computed.  Any
640
     deviation from this rule can cause major confusion and annoyance,
641
     and needs to be justified carefully.  In other words, GDB doesn't
642
     really have the freedom to do these conversions in clever and
643
     useful ways.
644
 
645
     AndrewC pointed out that users aren't complaining about how GDB
646
     casts integers to pointers; they are complaining that they can't
647
     take an address from a disassembly listing and give it to `x/i'.
648
     This is certainly important.
649
 
650
     Adding an architecture method like INTEGER_TO_ADDRESS certainly
651
     makes it possible for GDB to "get it right" in all circumstances
652
     --- the target has complete control over how things get done, so
653
     people can Do The Right Thing for their target without breaking
654
     anyone else.  The standard doesn't specify how integers get
655
     converted to pointers; usually, the ABI doesn't either, but
656
     ABI-specific code is a more reasonable place to handle it.  */
657
 
658
  if (TYPE_CODE (VALUE_TYPE (val)) != TYPE_CODE_PTR
659
      && TYPE_CODE (VALUE_TYPE (val)) != TYPE_CODE_REF
660
      && INTEGER_TO_ADDRESS_P ())
661
    return INTEGER_TO_ADDRESS (VALUE_TYPE (val), VALUE_CONTENTS (val));
662
 
663
  return unpack_long (VALUE_TYPE (val), VALUE_CONTENTS (val));
664
#endif
665
}
666
 
667
/* Unpack raw data (copied from debugee, target byte order) at VALADDR
668
   as a long, or as a double, assuming the raw data is described
669
   by type TYPE.  Knows how to convert different sizes of values
670
   and can convert between fixed and floating point.  We don't assume
671
   any alignment for the raw data.  Return value is in host byte order.
672
 
673
   If you want functions and arrays to be coerced to pointers, and
674
   references to be dereferenced, call value_as_long() instead.
675
 
676
   C++: It is assumed that the front-end has taken care of
677
   all matters concerning pointers to members.  A pointer
678
   to member which reaches here is considered to be equivalent
679
   to an INT (or some size).  After all, it is only an offset.  */
680
 
681
LONGEST
682
unpack_long (struct type *type, char *valaddr)
683
{
684
  register enum type_code code = TYPE_CODE (type);
685
  register int len = TYPE_LENGTH (type);
686
  register int nosign = TYPE_UNSIGNED (type);
687
 
688
  if (current_language->la_language == language_scm
689
      && is_scmvalue_type (type))
690
    return scm_unpack (type, valaddr, TYPE_CODE_INT);
691
 
692
  switch (code)
693
    {
694
    case TYPE_CODE_TYPEDEF:
695
      return unpack_long (check_typedef (type), valaddr);
696
    case TYPE_CODE_ENUM:
697
    case TYPE_CODE_BOOL:
698
    case TYPE_CODE_INT:
699
    case TYPE_CODE_CHAR:
700
    case TYPE_CODE_RANGE:
701
      if (nosign)
702
        return extract_unsigned_integer (valaddr, len);
703
      else
704
        return extract_signed_integer (valaddr, len);
705
 
706
    case TYPE_CODE_FLT:
707
      return extract_typed_floating (valaddr, type);
708
 
709
    case TYPE_CODE_PTR:
710
    case TYPE_CODE_REF:
711
      /* Assume a CORE_ADDR can fit in a LONGEST (for now).  Not sure
712
         whether we want this to be true eventually.  */
713
      return extract_typed_address (valaddr, type);
714
 
715
    case TYPE_CODE_MEMBER:
716
      error ("not implemented: member types in unpack_long");
717
 
718
    default:
719
      error ("Value can't be converted to integer.");
720
    }
721
  return 0;                      /* Placate lint.  */
722
}
723
 
724
/* Return a double value from the specified type and address.
725
   INVP points to an int which is set to 0 for valid value,
726
   1 for invalid value (bad float format).  In either case,
727
   the returned double is OK to use.  Argument is in target
728
   format, result is in host format.  */
729
 
730
DOUBLEST
731
unpack_double (struct type *type, char *valaddr, int *invp)
732
{
733
  enum type_code code;
734
  int len;
735
  int nosign;
736
 
737
  *invp = 0;                     /* Assume valid.   */
738
  CHECK_TYPEDEF (type);
739
  code = TYPE_CODE (type);
740
  len = TYPE_LENGTH (type);
741
  nosign = TYPE_UNSIGNED (type);
742
  if (code == TYPE_CODE_FLT)
743
    {
744
      /* NOTE: cagney/2002-02-19: There was a test here to see if the
745
         floating-point value was valid (using the macro
746
         INVALID_FLOAT).  That test/macro have been removed.
747
 
748
         It turns out that only the VAX defined this macro and then
749
         only in a non-portable way.  Fixing the portability problem
750
         wouldn't help since the VAX floating-point code is also badly
751
         bit-rotten.  The target needs to add definitions for the
752
         methods TARGET_FLOAT_FORMAT and TARGET_DOUBLE_FORMAT - these
753
         exactly describe the target floating-point format.  The
754
         problem here is that the corresponding floatformat_vax_f and
755
         floatformat_vax_d values these methods should be set to are
756
         also not defined either.  Oops!
757
 
758
         Hopefully someone will add both the missing floatformat
759
         definitions and floatformat_is_invalid() function.  */
760
      return extract_typed_floating (valaddr, type);
761
    }
762
  else if (nosign)
763
    {
764
      /* Unsigned -- be sure we compensate for signed LONGEST.  */
765
      return (ULONGEST) unpack_long (type, valaddr);
766
    }
767
  else
768
    {
769
      /* Signed -- we are OK with unpack_long.  */
770
      return unpack_long (type, valaddr);
771
    }
772
}
773
 
774
/* Unpack raw data (copied from debugee, target byte order) at VALADDR
775
   as a CORE_ADDR, assuming the raw data is described by type TYPE.
776
   We don't assume any alignment for the raw data.  Return value is in
777
   host byte order.
778
 
779
   If you want functions and arrays to be coerced to pointers, and
780
   references to be dereferenced, call value_as_address() instead.
781
 
782
   C++: It is assumed that the front-end has taken care of
783
   all matters concerning pointers to members.  A pointer
784
   to member which reaches here is considered to be equivalent
785
   to an INT (or some size).  After all, it is only an offset.  */
786
 
787
CORE_ADDR
788
unpack_pointer (struct type *type, char *valaddr)
789
{
790
  /* Assume a CORE_ADDR can fit in a LONGEST (for now).  Not sure
791
     whether we want this to be true eventually.  */
792
  return unpack_long (type, valaddr);
793
}
794
 
795
 
796
/* Get the value of the FIELDN'th field (which must be static) of
797
   TYPE.  Return NULL if the field doesn't exist or has been
798
   optimized out. */
799
 
800
struct value *
801
value_static_field (struct type *type, int fieldno)
802
{
803
  struct value *retval;
804
 
805
  if (TYPE_FIELD_STATIC_HAS_ADDR (type, fieldno))
806
    {
807
      retval = value_at (TYPE_FIELD_TYPE (type, fieldno),
808
                         TYPE_FIELD_STATIC_PHYSADDR (type, fieldno),
809
                         NULL);
810
    }
811
  else
812
    {
813
      char *phys_name = TYPE_FIELD_STATIC_PHYSNAME (type, fieldno);
814
      struct symbol *sym = lookup_symbol (phys_name, 0, VAR_NAMESPACE, 0, NULL);
815
      if (sym == NULL)
816
        {
817
          /* With some compilers, e.g. HP aCC, static data members are reported
818
             as non-debuggable symbols */
819
          struct minimal_symbol *msym = lookup_minimal_symbol (phys_name, NULL, NULL);
820
          if (!msym)
821
            return NULL;
822
          else
823
            {
824
              retval = value_at (TYPE_FIELD_TYPE (type, fieldno),
825
                                 SYMBOL_VALUE_ADDRESS (msym),
826
                                 SYMBOL_BFD_SECTION (msym));
827
            }
828
        }
829
      else
830
        {
831
          /* SYM should never have a SYMBOL_CLASS which will require
832
             read_var_value to use the FRAME parameter.  */
833
          if (symbol_read_needs_frame (sym))
834
            warning ("static field's value depends on the current "
835
                     "frame - bad debug info?");
836
          retval = read_var_value (sym, NULL);
837
        }
838
      if (retval && VALUE_LVAL (retval) == lval_memory)
839
        SET_FIELD_PHYSADDR (TYPE_FIELD (type, fieldno),
840
                            VALUE_ADDRESS (retval));
841
    }
842
  return retval;
843
}
844
 
845
/* Change the enclosing type of a value object VAL to NEW_ENCL_TYPE.
846
   You have to be careful here, since the size of the data area for the value
847
   is set by the length of the enclosing type.  So if NEW_ENCL_TYPE is bigger
848
   than the old enclosing type, you have to allocate more space for the data.
849
   The return value is a pointer to the new version of this value structure. */
850
 
851
struct value *
852
value_change_enclosing_type (struct value *val, struct type *new_encl_type)
853
{
854
  if (TYPE_LENGTH (new_encl_type) <= TYPE_LENGTH (VALUE_ENCLOSING_TYPE (val)))
855
    {
856
      VALUE_ENCLOSING_TYPE (val) = new_encl_type;
857
      return val;
858
    }
859
  else
860
    {
861
      struct value *new_val;
862
      struct value *prev;
863
 
864
      new_val = (struct value *) xrealloc (val, sizeof (struct value) + TYPE_LENGTH (new_encl_type));
865
 
866
      /* We have to make sure this ends up in the same place in the value
867
         chain as the original copy, so it's clean-up behavior is the same.
868
         If the value has been released, this is a waste of time, but there
869
         is no way to tell that in advance, so... */
870
 
871
      if (val != all_values)
872
        {
873
          for (prev = all_values; prev != NULL; prev = prev->next)
874
            {
875
              if (prev->next == val)
876
                {
877
                  prev->next = new_val;
878
                  break;
879
                }
880
            }
881
        }
882
 
883
      return new_val;
884
    }
885
}
886
 
887
/* Given a value ARG1 (offset by OFFSET bytes)
888
   of a struct or union type ARG_TYPE,
889
   extract and return the value of one of its (non-static) fields.
890
   FIELDNO says which field. */
891
 
892
struct value *
893
value_primitive_field (struct value *arg1, int offset,
894
                       register int fieldno, register struct type *arg_type)
895
{
896
  struct value *v;
897
  register struct type *type;
898
 
899
  CHECK_TYPEDEF (arg_type);
900
  type = TYPE_FIELD_TYPE (arg_type, fieldno);
901
 
902
  /* Handle packed fields */
903
 
904
  if (TYPE_FIELD_BITSIZE (arg_type, fieldno))
905
    {
906
      v = value_from_longest (type,
907
                              unpack_field_as_long (arg_type,
908
                                                    VALUE_CONTENTS (arg1)
909
                                                    + offset,
910
                                                    fieldno));
911
      VALUE_BITPOS (v) = TYPE_FIELD_BITPOS (arg_type, fieldno) % 8;
912
      VALUE_BITSIZE (v) = TYPE_FIELD_BITSIZE (arg_type, fieldno);
913
      VALUE_OFFSET (v) = VALUE_OFFSET (arg1) + offset
914
        + TYPE_FIELD_BITPOS (arg_type, fieldno) / 8;
915
    }
916
  else if (fieldno < TYPE_N_BASECLASSES (arg_type))
917
    {
918
      /* This field is actually a base subobject, so preserve the
919
         entire object's contents for later references to virtual
920
         bases, etc.  */
921
      v = allocate_value (VALUE_ENCLOSING_TYPE (arg1));
922
      VALUE_TYPE (v) = type;
923
      if (VALUE_LAZY (arg1))
924
        VALUE_LAZY (v) = 1;
925
      else
926
        memcpy (VALUE_CONTENTS_ALL_RAW (v), VALUE_CONTENTS_ALL_RAW (arg1),
927
                TYPE_LENGTH (VALUE_ENCLOSING_TYPE (arg1)));
928
      VALUE_OFFSET (v) = VALUE_OFFSET (arg1);
929
      VALUE_EMBEDDED_OFFSET (v)
930
        = offset +
931
        VALUE_EMBEDDED_OFFSET (arg1) +
932
        TYPE_FIELD_BITPOS (arg_type, fieldno) / 8;
933
    }
934
  else
935
    {
936
      /* Plain old data member */
937
      offset += TYPE_FIELD_BITPOS (arg_type, fieldno) / 8;
938
      v = allocate_value (type);
939
      if (VALUE_LAZY (arg1))
940
        VALUE_LAZY (v) = 1;
941
      else
942
        memcpy (VALUE_CONTENTS_RAW (v),
943
                VALUE_CONTENTS_RAW (arg1) + offset,
944
                TYPE_LENGTH (type));
945
      VALUE_OFFSET (v) = VALUE_OFFSET (arg1) + offset
946
                         + VALUE_EMBEDDED_OFFSET (arg1);
947
    }
948
  VALUE_LVAL (v) = VALUE_LVAL (arg1);
949
  if (VALUE_LVAL (arg1) == lval_internalvar)
950
    VALUE_LVAL (v) = lval_internalvar_component;
951
  VALUE_ADDRESS (v) = VALUE_ADDRESS (arg1);
952
  VALUE_REGNO (v) = VALUE_REGNO (arg1);
953
/*  VALUE_OFFSET (v) = VALUE_OFFSET (arg1) + offset
954
   + TYPE_FIELD_BITPOS (arg_type, fieldno) / 8; */
955
  return v;
956
}
957
 
958
/* Given a value ARG1 of a struct or union type,
959
   extract and return the value of one of its (non-static) fields.
960
   FIELDNO says which field. */
961
 
962
struct value *
963
value_field (struct value *arg1, register int fieldno)
964
{
965
  return value_primitive_field (arg1, 0, fieldno, VALUE_TYPE (arg1));
966
}
967
 
968
/* Return a non-virtual function as a value.
969
   F is the list of member functions which contains the desired method.
970
   J is an index into F which provides the desired method.
971
 
972
   We only use the symbol for its address, so be happy with either a
973
   full symbol or a minimal symbol.
974
 */
975
 
976
struct value *
977
value_fn_field (struct value **arg1p, struct fn_field *f, int j, struct type *type,
978
                int offset)
979
{
980
  struct value *v;
981
  register struct type *ftype = TYPE_FN_FIELD_TYPE (f, j);
982
  char *physname = TYPE_FN_FIELD_PHYSNAME (f, j);
983
  struct symbol *sym;
984
  struct minimal_symbol *msym;
985
 
986
  sym = lookup_symbol (physname, 0, VAR_NAMESPACE, 0, NULL);
987
  if (sym != NULL)
988
    {
989
      msym = NULL;
990
    }
991
  else
992
    {
993
      gdb_assert (sym == NULL);
994
      msym = lookup_minimal_symbol (physname, NULL, NULL);
995
      if (msym == NULL)
996
        return NULL;
997
    }
998
 
999
  v = allocate_value (ftype);
1000
  if (sym)
1001
    {
1002
      VALUE_ADDRESS (v) = BLOCK_START (SYMBOL_BLOCK_VALUE (sym));
1003
    }
1004
  else
1005
    {
1006
      VALUE_ADDRESS (v) = SYMBOL_VALUE_ADDRESS (msym);
1007
    }
1008
 
1009
  if (arg1p)
1010
    {
1011
      if (type != VALUE_TYPE (*arg1p))
1012
        *arg1p = value_ind (value_cast (lookup_pointer_type (type),
1013
                                        value_addr (*arg1p)));
1014
 
1015
      /* Move the `this' pointer according to the offset.
1016
         VALUE_OFFSET (*arg1p) += offset;
1017
       */
1018
    }
1019
 
1020
  return v;
1021
}
1022
 
1023
 
1024
/* Unpack a field FIELDNO of the specified TYPE, from the anonymous object at
1025
   VALADDR.
1026
 
1027
   Extracting bits depends on endianness of the machine.  Compute the
1028
   number of least significant bits to discard.  For big endian machines,
1029
   we compute the total number of bits in the anonymous object, subtract
1030
   off the bit count from the MSB of the object to the MSB of the
1031
   bitfield, then the size of the bitfield, which leaves the LSB discard
1032
   count.  For little endian machines, the discard count is simply the
1033
   number of bits from the LSB of the anonymous object to the LSB of the
1034
   bitfield.
1035
 
1036
   If the field is signed, we also do sign extension. */
1037
 
1038
LONGEST
1039
unpack_field_as_long (struct type *type, char *valaddr, int fieldno)
1040
{
1041
  ULONGEST val;
1042
  ULONGEST valmask;
1043
  int bitpos = TYPE_FIELD_BITPOS (type, fieldno);
1044
  int bitsize = TYPE_FIELD_BITSIZE (type, fieldno);
1045
  int lsbcount;
1046
  struct type *field_type;
1047
 
1048
  val = extract_unsigned_integer (valaddr + bitpos / 8, sizeof (val));
1049
  field_type = TYPE_FIELD_TYPE (type, fieldno);
1050
  CHECK_TYPEDEF (field_type);
1051
 
1052
  /* Extract bits.  See comment above. */
1053
 
1054
  if (BITS_BIG_ENDIAN)
1055
    lsbcount = (sizeof val * 8 - bitpos % 8 - bitsize);
1056
  else
1057
    lsbcount = (bitpos % 8);
1058
  val >>= lsbcount;
1059
 
1060
  /* If the field does not entirely fill a LONGEST, then zero the sign bits.
1061
     If the field is signed, and is negative, then sign extend. */
1062
 
1063
  if ((bitsize > 0) && (bitsize < 8 * (int) sizeof (val)))
1064
    {
1065
      valmask = (((ULONGEST) 1) << bitsize) - 1;
1066
      val &= valmask;
1067
      if (!TYPE_UNSIGNED (field_type))
1068
        {
1069
          if (val & (valmask ^ (valmask >> 1)))
1070
            {
1071
              val |= ~valmask;
1072
            }
1073
        }
1074
    }
1075
  return (val);
1076
}
1077
 
1078
/* Modify the value of a bitfield.  ADDR points to a block of memory in
1079
   target byte order; the bitfield starts in the byte pointed to.  FIELDVAL
1080
   is the desired value of the field, in host byte order.  BITPOS and BITSIZE
1081
   indicate which bits (in target bit order) comprise the bitfield.  */
1082
 
1083
void
1084
modify_field (char *addr, LONGEST fieldval, int bitpos, int bitsize)
1085
{
1086
  LONGEST oword;
1087
 
1088
  /* If a negative fieldval fits in the field in question, chop
1089
     off the sign extension bits.  */
1090
  if (bitsize < (8 * (int) sizeof (fieldval))
1091
      && (~fieldval & ~((1 << (bitsize - 1)) - 1)) == 0)
1092
    fieldval = fieldval & ((1 << bitsize) - 1);
1093
 
1094
  /* Warn if value is too big to fit in the field in question.  */
1095
  if (bitsize < (8 * (int) sizeof (fieldval))
1096
      && 0 != (fieldval & ~((1 << bitsize) - 1)))
1097
    {
1098
      /* FIXME: would like to include fieldval in the message, but
1099
         we don't have a sprintf_longest.  */
1100
      warning ("Value does not fit in %d bits.", bitsize);
1101
 
1102
      /* Truncate it, otherwise adjoining fields may be corrupted.  */
1103
      fieldval = fieldval & ((1 << bitsize) - 1);
1104
    }
1105
 
1106
  oword = extract_signed_integer (addr, sizeof oword);
1107
 
1108
  /* Shifting for bit field depends on endianness of the target machine.  */
1109
  if (BITS_BIG_ENDIAN)
1110
    bitpos = sizeof (oword) * 8 - bitpos - bitsize;
1111
 
1112
  /* Mask out old value, while avoiding shifts >= size of oword */
1113
  if (bitsize < 8 * (int) sizeof (oword))
1114
    oword &= ~(((((ULONGEST) 1) << bitsize) - 1) << bitpos);
1115
  else
1116
    oword &= ~((~(ULONGEST) 0) << bitpos);
1117
  oword |= fieldval << bitpos;
1118
 
1119
  store_signed_integer (addr, sizeof oword, oword);
1120
}
1121
 
1122
/* Convert C numbers into newly allocated values */
1123
 
1124
struct value *
1125
value_from_longest (struct type *type, register LONGEST num)
1126
{
1127
  struct value *val = allocate_value (type);
1128
  register enum type_code code;
1129
  register int len;
1130
retry:
1131
  code = TYPE_CODE (type);
1132
  len = TYPE_LENGTH (type);
1133
 
1134
  switch (code)
1135
    {
1136
    case TYPE_CODE_TYPEDEF:
1137
      type = check_typedef (type);
1138
      goto retry;
1139
    case TYPE_CODE_INT:
1140
    case TYPE_CODE_CHAR:
1141
    case TYPE_CODE_ENUM:
1142
    case TYPE_CODE_BOOL:
1143
    case TYPE_CODE_RANGE:
1144
      store_signed_integer (VALUE_CONTENTS_RAW (val), len, num);
1145
      break;
1146
 
1147
    case TYPE_CODE_REF:
1148
    case TYPE_CODE_PTR:
1149
      store_typed_address (VALUE_CONTENTS_RAW (val), type, (CORE_ADDR) num);
1150
      break;
1151
 
1152
    default:
1153
      error ("Unexpected type (%d) encountered for integer constant.", code);
1154
    }
1155
  return val;
1156
}
1157
 
1158
 
1159
/* Create a value representing a pointer of type TYPE to the address
1160
   ADDR.  */
1161
struct value *
1162
value_from_pointer (struct type *type, CORE_ADDR addr)
1163
{
1164
  struct value *val = allocate_value (type);
1165
  store_typed_address (VALUE_CONTENTS_RAW (val), type, addr);
1166
  return val;
1167
}
1168
 
1169
 
1170
/* Create a value for a string constant to be stored locally
1171
   (not in the inferior's memory space, but in GDB memory).
1172
   This is analogous to value_from_longest, which also does not
1173
   use inferior memory.  String shall NOT contain embedded nulls.  */
1174
 
1175
struct value *
1176
value_from_string (char *ptr)
1177
{
1178
  struct value *val;
1179
  int len = strlen (ptr);
1180
  int lowbound = current_language->string_lower_bound;
1181
  struct type *rangetype =
1182
  create_range_type ((struct type *) NULL,
1183
                     builtin_type_int,
1184
                     lowbound, len + lowbound - 1);
1185
  struct type *stringtype =
1186
  create_array_type ((struct type *) NULL,
1187
                     *current_language->string_char_type,
1188
                     rangetype);
1189
 
1190
  val = allocate_value (stringtype);
1191
  memcpy (VALUE_CONTENTS_RAW (val), ptr, len);
1192
  return val;
1193
}
1194
 
1195
struct value *
1196
value_from_double (struct type *type, DOUBLEST num)
1197
{
1198
  struct value *val = allocate_value (type);
1199
  struct type *base_type = check_typedef (type);
1200
  register enum type_code code = TYPE_CODE (base_type);
1201
  register int len = TYPE_LENGTH (base_type);
1202
 
1203
  if (code == TYPE_CODE_FLT)
1204
    {
1205
      store_typed_floating (VALUE_CONTENTS_RAW (val), base_type, num);
1206
    }
1207
  else
1208
    error ("Unexpected type encountered for floating constant.");
1209
 
1210
  return val;
1211
}
1212
 
1213
/* Deal with the value that is "about to be returned".  */
1214
 
1215
/* Return the value that a function returning now
1216
   would be returning to its caller, assuming its type is VALTYPE.
1217
   RETBUF is where we look for what ought to be the contents
1218
   of the registers (in raw form).  This is because it is often
1219
   desirable to restore old values to those registers
1220
   after saving the contents of interest, and then call
1221
   this function using the saved values.
1222
   struct_return is non-zero when the function in question is
1223
   using the structure return conventions on the machine in question;
1224
 
1225
   means returning pointer to where structure is vs. returning value). */
1226
 
1227
/* ARGSUSED */
1228
struct value *
1229
value_being_returned (struct type *valtype, struct regcache *retbuf,
1230
                      int struct_return)
1231
{
1232
  struct value *val;
1233
  CORE_ADDR addr;
1234
 
1235
  /* If this is not defined, just use EXTRACT_RETURN_VALUE instead.  */
1236
  if (EXTRACT_STRUCT_VALUE_ADDRESS_P ())
1237
    if (struct_return)
1238
      {
1239
        addr = EXTRACT_STRUCT_VALUE_ADDRESS (retbuf);
1240
        if (!addr)
1241
          error ("Function return value unknown.");
1242
        return value_at (valtype, addr, NULL);
1243
      }
1244
 
1245
  /* If this is not defined, just use EXTRACT_RETURN_VALUE instead.  */
1246
  if (DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS_P ())
1247
    if (struct_return)
1248
      {
1249
        char *buf = deprecated_grub_regcache_for_registers (retbuf);
1250
        addr = DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS (buf);
1251
        if (!addr)
1252
          error ("Function return value unknown.");
1253
        return value_at (valtype, addr, NULL);
1254
      }
1255
 
1256
  val = allocate_value (valtype);
1257
  CHECK_TYPEDEF (valtype);
1258
  EXTRACT_RETURN_VALUE (valtype, retbuf, VALUE_CONTENTS_RAW (val));
1259
 
1260
  return val;
1261
}
1262
 
1263
/* Should we use EXTRACT_STRUCT_VALUE_ADDRESS instead of
1264
   EXTRACT_RETURN_VALUE?  GCC_P is true if compiled with gcc
1265
   and TYPE is the type (which is known to be struct, union or array).
1266
 
1267
   On most machines, the struct convention is used unless we are
1268
   using gcc and the type is of a special size.  */
1269
/* As of about 31 Mar 93, GCC was changed to be compatible with the
1270
   native compiler.  GCC 2.3.3 was the last release that did it the
1271
   old way.  Since gcc2_compiled was not changed, we have no
1272
   way to correctly win in all cases, so we just do the right thing
1273
   for gcc1 and for gcc2 after this change.  Thus it loses for gcc
1274
   2.0-2.3.3.  This is somewhat unfortunate, but changing gcc2_compiled
1275
   would cause more chaos than dealing with some struct returns being
1276
   handled wrong.  */
1277
 
1278
int
1279
generic_use_struct_convention (int gcc_p, struct type *value_type)
1280
{
1281
  return !((gcc_p == 1)
1282
           && (TYPE_LENGTH (value_type) == 1
1283
               || TYPE_LENGTH (value_type) == 2
1284
               || TYPE_LENGTH (value_type) == 4
1285
               || TYPE_LENGTH (value_type) == 8));
1286
}
1287
 
1288
/* Return true if the function specified is using the structure returning
1289
   convention on this machine to return arguments, or 0 if it is using
1290
   the value returning convention.  FUNCTION is the value representing
1291
   the function, FUNCADDR is the address of the function, and VALUE_TYPE
1292
   is the type returned by the function.  GCC_P is nonzero if compiled
1293
   with GCC.  */
1294
 
1295
/* ARGSUSED */
1296
int
1297
using_struct_return (struct value *function, CORE_ADDR funcaddr,
1298
                     struct type *value_type, int gcc_p)
1299
{
1300
  register enum type_code code = TYPE_CODE (value_type);
1301
 
1302
  if (code == TYPE_CODE_ERROR)
1303
    error ("Function return type unknown.");
1304
 
1305
  if (code == TYPE_CODE_STRUCT
1306
      || code == TYPE_CODE_UNION
1307
      || code == TYPE_CODE_ARRAY
1308
      || RETURN_VALUE_ON_STACK (value_type))
1309
    return USE_STRUCT_CONVENTION (gcc_p, value_type);
1310
 
1311
  return 0;
1312
}
1313
 
1314
/* Store VAL so it will be returned if a function returns now.
1315
   Does not verify that VAL's type matches what the current
1316
   function wants to return.  */
1317
 
1318
void
1319
set_return_value (struct value *val)
1320
{
1321
  struct type *type = check_typedef (VALUE_TYPE (val));
1322
  register enum type_code code = TYPE_CODE (type);
1323
 
1324
  if (code == TYPE_CODE_ERROR)
1325
    error ("Function return type unknown.");
1326
 
1327
  if (code == TYPE_CODE_STRUCT
1328
      || code == TYPE_CODE_UNION)       /* FIXME, implement struct return.  */
1329
    error ("GDB does not support specifying a struct or union return value.");
1330
 
1331
  STORE_RETURN_VALUE (type, current_regcache, VALUE_CONTENTS (val));
1332
}
1333
 
1334
void
1335
_initialize_values (void)
1336
{
1337
  add_cmd ("convenience", no_class, show_convenience,
1338
           "Debugger convenience (\"$foo\") variables.\n\
1339
These variables are created when you assign them values;\n\
1340
thus, \"print $foo=1\" gives \"$foo\" the value 1.  Values may be any type.\n\n\
1341
A few convenience variables are given values automatically:\n\
1342
\"$_\"holds the last address examined with \"x\" or \"info lines\",\n\
1343
\"$__\" holds the contents of the last address examined with \"x\".",
1344
           &showlist);
1345
 
1346
  add_cmd ("values", no_class, show_values,
1347
           "Elements of value history around item number IDX (or last ten).",
1348
           &showlist);
1349
}

powered by: WebSVN 2.1.0

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