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