]> git.ipfire.org Git - thirdparty/binutils-gdb.git/blame - gdb/value.c
Copyright updates for 2007.
[thirdparty/binutils-gdb.git] / gdb / value.c
CommitLineData
c906108c 1/* Low level packing and unpacking of values for GDB, the GNU Debugger.
1bac305b 2
6aba47ca
DJ
3 Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
4 1996, 1997, 1998, 1999, 2000, 2002, 2003, 2004, 2005, 2006, 2007
4f2aea11 5 Free Software 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
197e01b6
EZ
21 Foundation, Inc., 51 Franklin Street, Fifth Floor,
22 Boston, MA 02110-1301, 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 44
91294c83
AC
45struct value
46{
47 /* Type of value; either not an lval, or one of the various
48 different possible kinds of lval. */
49 enum lval_type lval;
50
51 /* Is it modifiable? Only relevant if lval != not_lval. */
52 int modifiable;
53
54 /* Location of value (if lval). */
55 union
56 {
57 /* If lval == lval_memory, this is the address in the inferior.
58 If lval == lval_register, this is the byte offset into the
59 registers structure. */
60 CORE_ADDR address;
61
62 /* Pointer to internal variable. */
63 struct internalvar *internalvar;
64 } location;
65
66 /* Describes offset of a value within lval of a structure in bytes.
67 If lval == lval_memory, this is an offset to the address. If
68 lval == lval_register, this is a further offset from
69 location.address within the registers structure. Note also the
70 member embedded_offset below. */
71 int offset;
72
73 /* Only used for bitfields; number of bits contained in them. */
74 int bitsize;
75
76 /* Only used for bitfields; position of start of field. For
77 BITS_BIG_ENDIAN=0 targets, it is the position of the LSB. For
78 BITS_BIG_ENDIAN=1 targets, it is the position of the MSB. */
79 int bitpos;
80
81 /* Frame register value is relative to. This will be described in
82 the lval enum above as "lval_register". */
83 struct frame_id frame_id;
84
85 /* Type of the value. */
86 struct type *type;
87
88 /* If a value represents a C++ object, then the `type' field gives
89 the object's compile-time type. If the object actually belongs
90 to some class derived from `type', perhaps with other base
91 classes and additional members, then `type' is just a subobject
92 of the real thing, and the full object is probably larger than
93 `type' would suggest.
94
95 If `type' is a dynamic class (i.e. one with a vtable), then GDB
96 can actually determine the object's run-time type by looking at
97 the run-time type information in the vtable. When this
98 information is available, we may elect to read in the entire
99 object, for several reasons:
100
101 - When printing the value, the user would probably rather see the
102 full object, not just the limited portion apparent from the
103 compile-time type.
104
105 - If `type' has virtual base classes, then even printing `type'
106 alone may require reaching outside the `type' portion of the
107 object to wherever the virtual base class has been stored.
108
109 When we store the entire object, `enclosing_type' is the run-time
110 type -- the complete object -- and `embedded_offset' is the
111 offset of `type' within that larger type, in bytes. The
112 value_contents() macro takes `embedded_offset' into account, so
113 most GDB code continues to see the `type' portion of the value,
114 just as the inferior would.
115
116 If `type' is a pointer to an object, then `enclosing_type' is a
117 pointer to the object's run-time type, and `pointed_to_offset' is
118 the offset in bytes from the full object to the pointed-to object
119 -- that is, the value `embedded_offset' would have if we followed
120 the pointer and fetched the complete object. (I don't really see
121 the point. Why not just determine the run-time type when you
122 indirect, and avoid the special case? The contents don't matter
123 until you indirect anyway.)
124
125 If we're not doing anything fancy, `enclosing_type' is equal to
126 `type', and `embedded_offset' is zero, so everything works
127 normally. */
128 struct type *enclosing_type;
129 int embedded_offset;
130 int pointed_to_offset;
131
132 /* Values are stored in a chain, so that they can be deleted easily
133 over calls to the inferior. Values assigned to internal
134 variables or put into the value history are taken off this
135 list. */
136 struct value *next;
137
138 /* Register number if the value is from a register. */
139 short regnum;
140
141 /* If zero, contents of this value are in the contents field. If
142 nonzero, contents are in inferior memory at address in the
143 location.address field plus the offset field (and the lval field
144 should be lval_memory).
145
146 WARNING: This field is used by the code which handles watchpoints
147 (see breakpoint.c) to decide whether a particular value can be
148 watched by hardware watchpoints. If the lazy flag is set for
149 some member of a value chain, it is assumed that this member of
150 the chain doesn't need to be watched as part of watching the
151 value itself. This is how GDB avoids watching the entire struct
152 or array when the user wants to watch a single struct member or
153 array element. If you ever change the way lazy flag is set and
154 reset, be sure to consider this use as well! */
155 char lazy;
156
157 /* If nonzero, this is the value of a variable which does not
158 actually exist in the program. */
159 char optimized_out;
160
161 /* Actual contents of the value. For use of this value; setting it
162 uses the stuff above. Not valid if lazy is nonzero. Target
163 byte-order. We force it to be aligned properly for any possible
164 value. Note that a value therefore extends beyond what is
165 declared here. */
166 union
167 {
fc1a4b47 168 gdb_byte contents[1];
91294c83
AC
169 DOUBLEST force_doublest_align;
170 LONGEST force_longest_align;
171 CORE_ADDR force_core_addr_align;
172 void *force_pointer_align;
173 } aligner;
174 /* Do not add any new members here -- contents above will trash
175 them. */
176};
177
c906108c
SS
178/* Prototypes for local functions. */
179
a14ed312 180static void show_values (char *, int);
c906108c 181
a14ed312 182static void show_convenience (char *, int);
c906108c 183
c906108c
SS
184
185/* The value-history records all the values printed
186 by print commands during this session. Each chunk
187 records 60 consecutive values. The first chunk on
188 the chain records the most recent values.
189 The total number of values is in value_history_count. */
190
191#define VALUE_HISTORY_CHUNK 60
192
193struct value_history_chunk
c5aa993b
JM
194 {
195 struct value_history_chunk *next;
f23631e4 196 struct value *values[VALUE_HISTORY_CHUNK];
c5aa993b 197 };
c906108c
SS
198
199/* Chain of chunks now in use. */
200
201static struct value_history_chunk *value_history_chain;
202
203static int value_history_count; /* Abs number of last entry stored */
204\f
205/* List of all value objects currently allocated
206 (except for those released by calls to release_value)
207 This is so they can be freed after each command. */
208
f23631e4 209static struct value *all_values;
c906108c
SS
210
211/* Allocate a value that has the correct length for type TYPE. */
212
f23631e4 213struct value *
fba45db2 214allocate_value (struct type *type)
c906108c 215{
f23631e4 216 struct value *val;
c906108c
SS
217 struct type *atype = check_typedef (type);
218
5b90c7b5 219 val = (struct value *) xzalloc (sizeof (struct value) + TYPE_LENGTH (atype));
df407dfe 220 val->next = all_values;
c906108c 221 all_values = val;
df407dfe 222 val->type = type;
4754a64e 223 val->enclosing_type = type;
c906108c
SS
224 VALUE_LVAL (val) = not_lval;
225 VALUE_ADDRESS (val) = 0;
1df6926e 226 VALUE_FRAME_ID (val) = null_frame_id;
df407dfe
AC
227 val->offset = 0;
228 val->bitpos = 0;
229 val->bitsize = 0;
9ee8fc9d 230 VALUE_REGNUM (val) = -1;
d69fe07e 231 val->lazy = 0;
feb13ab0 232 val->optimized_out = 0;
13c3b5f5 233 val->embedded_offset = 0;
b44d461b 234 val->pointed_to_offset = 0;
c906108c
SS
235 val->modifiable = 1;
236 return val;
237}
238
239/* Allocate a value that has the correct length
240 for COUNT repetitions type TYPE. */
241
f23631e4 242struct value *
fba45db2 243allocate_repeat_value (struct type *type, int count)
c906108c 244{
c5aa993b 245 int low_bound = current_language->string_lower_bound; /* ??? */
c906108c
SS
246 /* FIXME-type-allocation: need a way to free this type when we are
247 done with it. */
248 struct type *range_type
c5aa993b
JM
249 = create_range_type ((struct type *) NULL, builtin_type_int,
250 low_bound, count + low_bound - 1);
c906108c
SS
251 /* FIXME-type-allocation: need a way to free this type when we are
252 done with it. */
253 return allocate_value (create_array_type ((struct type *) NULL,
254 type, range_type));
255}
256
df407dfe
AC
257/* Accessor methods. */
258
17cf0ecd
AC
259struct value *
260value_next (struct value *value)
261{
262 return value->next;
263}
264
df407dfe
AC
265struct type *
266value_type (struct value *value)
267{
268 return value->type;
269}
04624583
AC
270void
271deprecated_set_value_type (struct value *value, struct type *type)
272{
273 value->type = type;
274}
df407dfe
AC
275
276int
277value_offset (struct value *value)
278{
279 return value->offset;
280}
f5cf64a7
AC
281void
282set_value_offset (struct value *value, int offset)
283{
284 value->offset = offset;
285}
df407dfe
AC
286
287int
288value_bitpos (struct value *value)
289{
290 return value->bitpos;
291}
9bbda503
AC
292void
293set_value_bitpos (struct value *value, int bit)
294{
295 value->bitpos = bit;
296}
df407dfe
AC
297
298int
299value_bitsize (struct value *value)
300{
301 return value->bitsize;
302}
9bbda503
AC
303void
304set_value_bitsize (struct value *value, int bit)
305{
306 value->bitsize = bit;
307}
df407dfe 308
fc1a4b47 309gdb_byte *
990a07ab
AC
310value_contents_raw (struct value *value)
311{
312 return value->aligner.contents + value->embedded_offset;
313}
314
fc1a4b47 315gdb_byte *
990a07ab
AC
316value_contents_all_raw (struct value *value)
317{
318 return value->aligner.contents;
319}
320
4754a64e
AC
321struct type *
322value_enclosing_type (struct value *value)
323{
324 return value->enclosing_type;
325}
326
fc1a4b47 327const gdb_byte *
46615f07
AC
328value_contents_all (struct value *value)
329{
330 if (value->lazy)
331 value_fetch_lazy (value);
332 return value->aligner.contents;
333}
334
d69fe07e
AC
335int
336value_lazy (struct value *value)
337{
338 return value->lazy;
339}
340
dfa52d88
AC
341void
342set_value_lazy (struct value *value, int val)
343{
344 value->lazy = val;
345}
346
fc1a4b47 347const gdb_byte *
0fd88904
AC
348value_contents (struct value *value)
349{
350 return value_contents_writeable (value);
351}
352
fc1a4b47 353gdb_byte *
0fd88904
AC
354value_contents_writeable (struct value *value)
355{
356 if (value->lazy)
357 value_fetch_lazy (value);
fc0c53a0 358 return value_contents_raw (value);
0fd88904
AC
359}
360
a6c442d8
MK
361/* Return non-zero if VAL1 and VAL2 have the same contents. Note that
362 this function is different from value_equal; in C the operator ==
363 can return 0 even if the two values being compared are equal. */
364
365int
366value_contents_equal (struct value *val1, struct value *val2)
367{
368 struct type *type1;
369 struct type *type2;
370 int len;
371
372 type1 = check_typedef (value_type (val1));
373 type2 = check_typedef (value_type (val2));
374 len = TYPE_LENGTH (type1);
375 if (len != TYPE_LENGTH (type2))
376 return 0;
377
378 return (memcmp (value_contents (val1), value_contents (val2), len) == 0);
379}
380
feb13ab0
AC
381int
382value_optimized_out (struct value *value)
383{
384 return value->optimized_out;
385}
386
387void
388set_value_optimized_out (struct value *value, int val)
389{
390 value->optimized_out = val;
391}
13c3b5f5
AC
392
393int
394value_embedded_offset (struct value *value)
395{
396 return value->embedded_offset;
397}
398
399void
400set_value_embedded_offset (struct value *value, int val)
401{
402 value->embedded_offset = val;
403}
b44d461b
AC
404
405int
406value_pointed_to_offset (struct value *value)
407{
408 return value->pointed_to_offset;
409}
410
411void
412set_value_pointed_to_offset (struct value *value, int val)
413{
414 value->pointed_to_offset = val;
415}
13bb5560
AC
416
417enum lval_type *
418deprecated_value_lval_hack (struct value *value)
419{
420 return &value->lval;
421}
422
423CORE_ADDR *
424deprecated_value_address_hack (struct value *value)
425{
426 return &value->location.address;
427}
428
429struct internalvar **
430deprecated_value_internalvar_hack (struct value *value)
431{
432 return &value->location.internalvar;
433}
434
435struct frame_id *
436deprecated_value_frame_id_hack (struct value *value)
437{
438 return &value->frame_id;
439}
440
441short *
442deprecated_value_regnum_hack (struct value *value)
443{
444 return &value->regnum;
445}
88e3b34b
AC
446
447int
448deprecated_value_modifiable (struct value *value)
449{
450 return value->modifiable;
451}
452void
453deprecated_set_value_modifiable (struct value *value, int modifiable)
454{
455 value->modifiable = modifiable;
456}
990a07ab 457\f
c906108c
SS
458/* Return a mark in the value chain. All values allocated after the
459 mark is obtained (except for those released) are subject to being freed
460 if a subsequent value_free_to_mark is passed the mark. */
f23631e4 461struct value *
fba45db2 462value_mark (void)
c906108c
SS
463{
464 return all_values;
465}
466
467/* Free all values allocated since MARK was obtained by value_mark
468 (except for those released). */
469void
f23631e4 470value_free_to_mark (struct value *mark)
c906108c 471{
f23631e4
AC
472 struct value *val;
473 struct value *next;
c906108c
SS
474
475 for (val = all_values; val && val != mark; val = next)
476 {
df407dfe 477 next = val->next;
c906108c
SS
478 value_free (val);
479 }
480 all_values = val;
481}
482
483/* Free all the values that have been allocated (except for those released).
484 Called after each command, successful or not. */
485
486void
fba45db2 487free_all_values (void)
c906108c 488{
f23631e4
AC
489 struct value *val;
490 struct value *next;
c906108c
SS
491
492 for (val = all_values; val; val = next)
493 {
df407dfe 494 next = val->next;
c906108c
SS
495 value_free (val);
496 }
497
498 all_values = 0;
499}
500
501/* Remove VAL from the chain all_values
502 so it will not be freed automatically. */
503
504void
f23631e4 505release_value (struct value *val)
c906108c 506{
f23631e4 507 struct value *v;
c906108c
SS
508
509 if (all_values == val)
510 {
511 all_values = val->next;
512 return;
513 }
514
515 for (v = all_values; v; v = v->next)
516 {
517 if (v->next == val)
518 {
519 v->next = val->next;
520 break;
521 }
522 }
523}
524
525/* Release all values up to mark */
f23631e4
AC
526struct value *
527value_release_to_mark (struct value *mark)
c906108c 528{
f23631e4
AC
529 struct value *val;
530 struct value *next;
c906108c 531
df407dfe
AC
532 for (val = next = all_values; next; next = next->next)
533 if (next->next == mark)
c906108c 534 {
df407dfe
AC
535 all_values = next->next;
536 next->next = NULL;
c906108c
SS
537 return val;
538 }
539 all_values = 0;
540 return val;
541}
542
543/* Return a copy of the value ARG.
544 It contains the same contents, for same memory address,
545 but it's a different block of storage. */
546
f23631e4
AC
547struct value *
548value_copy (struct value *arg)
c906108c 549{
4754a64e 550 struct type *encl_type = value_enclosing_type (arg);
f23631e4 551 struct value *val = allocate_value (encl_type);
df407dfe 552 val->type = arg->type;
c906108c 553 VALUE_LVAL (val) = VALUE_LVAL (arg);
6f7c8fc2 554 val->location = arg->location;
df407dfe
AC
555 val->offset = arg->offset;
556 val->bitpos = arg->bitpos;
557 val->bitsize = arg->bitsize;
1df6926e 558 VALUE_FRAME_ID (val) = VALUE_FRAME_ID (arg);
9ee8fc9d 559 VALUE_REGNUM (val) = VALUE_REGNUM (arg);
d69fe07e 560 val->lazy = arg->lazy;
feb13ab0 561 val->optimized_out = arg->optimized_out;
13c3b5f5 562 val->embedded_offset = value_embedded_offset (arg);
b44d461b 563 val->pointed_to_offset = arg->pointed_to_offset;
c906108c 564 val->modifiable = arg->modifiable;
d69fe07e 565 if (!value_lazy (val))
c906108c 566 {
990a07ab 567 memcpy (value_contents_all_raw (val), value_contents_all_raw (arg),
4754a64e 568 TYPE_LENGTH (value_enclosing_type (arg)));
c906108c
SS
569
570 }
571 return val;
572}
573\f
574/* Access to the value history. */
575
576/* Record a new value in the value history.
577 Returns the absolute history index of the entry.
578 Result of -1 indicates the value was not saved; otherwise it is the
579 value history index of this new item. */
580
581int
f23631e4 582record_latest_value (struct value *val)
c906108c
SS
583{
584 int i;
585
586 /* We don't want this value to have anything to do with the inferior anymore.
587 In particular, "set $1 = 50" should not affect the variable from which
588 the value was taken, and fast watchpoints should be able to assume that
589 a value on the value history never changes. */
d69fe07e 590 if (value_lazy (val))
c906108c
SS
591 value_fetch_lazy (val);
592 /* We preserve VALUE_LVAL so that the user can find out where it was fetched
593 from. This is a bit dubious, because then *&$1 does not just return $1
594 but the current contents of that location. c'est la vie... */
595 val->modifiable = 0;
596 release_value (val);
597
598 /* Here we treat value_history_count as origin-zero
599 and applying to the value being stored now. */
600
601 i = value_history_count % VALUE_HISTORY_CHUNK;
602 if (i == 0)
603 {
f23631e4 604 struct value_history_chunk *new
c5aa993b
JM
605 = (struct value_history_chunk *)
606 xmalloc (sizeof (struct value_history_chunk));
c906108c
SS
607 memset (new->values, 0, sizeof new->values);
608 new->next = value_history_chain;
609 value_history_chain = new;
610 }
611
612 value_history_chain->values[i] = val;
613
614 /* Now we regard value_history_count as origin-one
615 and applying to the value just stored. */
616
617 return ++value_history_count;
618}
619
620/* Return a copy of the value in the history with sequence number NUM. */
621
f23631e4 622struct value *
fba45db2 623access_value_history (int num)
c906108c 624{
f23631e4 625 struct value_history_chunk *chunk;
52f0bd74
AC
626 int i;
627 int absnum = num;
c906108c
SS
628
629 if (absnum <= 0)
630 absnum += value_history_count;
631
632 if (absnum <= 0)
633 {
634 if (num == 0)
8a3fe4f8 635 error (_("The history is empty."));
c906108c 636 else if (num == 1)
8a3fe4f8 637 error (_("There is only one value in the history."));
c906108c 638 else
8a3fe4f8 639 error (_("History does not go back to $$%d."), -num);
c906108c
SS
640 }
641 if (absnum > value_history_count)
8a3fe4f8 642 error (_("History has not yet reached $%d."), absnum);
c906108c
SS
643
644 absnum--;
645
646 /* Now absnum is always absolute and origin zero. */
647
648 chunk = value_history_chain;
649 for (i = (value_history_count - 1) / VALUE_HISTORY_CHUNK - absnum / VALUE_HISTORY_CHUNK;
650 i > 0; i--)
651 chunk = chunk->next;
652
653 return value_copy (chunk->values[absnum % VALUE_HISTORY_CHUNK]);
654}
655
c906108c 656static void
fba45db2 657show_values (char *num_exp, int from_tty)
c906108c 658{
52f0bd74 659 int i;
f23631e4 660 struct value *val;
c906108c
SS
661 static int num = 1;
662
663 if (num_exp)
664 {
c5aa993b
JM
665 /* "info history +" should print from the stored position.
666 "info history <exp>" should print around value number <exp>. */
c906108c 667 if (num_exp[0] != '+' || num_exp[1] != '\0')
bb518678 668 num = parse_and_eval_long (num_exp) - 5;
c906108c
SS
669 }
670 else
671 {
672 /* "info history" means print the last 10 values. */
673 num = value_history_count - 9;
674 }
675
676 if (num <= 0)
677 num = 1;
678
679 for (i = num; i < num + 10 && i <= value_history_count; i++)
680 {
681 val = access_value_history (i);
a3f17187 682 printf_filtered (("$%d = "), i);
c906108c 683 value_print (val, gdb_stdout, 0, Val_pretty_default);
a3f17187 684 printf_filtered (("\n"));
c906108c
SS
685 }
686
687 /* The next "info history +" should start after what we just printed. */
688 num += 10;
689
690 /* Hitting just return after this command should do the same thing as
691 "info history +". If num_exp is null, this is unnecessary, since
692 "info history +" is not useful after "info history". */
693 if (from_tty && num_exp)
694 {
695 num_exp[0] = '+';
696 num_exp[1] = '\0';
697 }
698}
699\f
700/* Internal variables. These are variables within the debugger
701 that hold values assigned by debugger commands.
702 The user refers to them with a '$' prefix
703 that does not appear in the variable names stored internally. */
704
705static struct internalvar *internalvars;
706
53e5f3cf
AS
707/* If the variable does not already exist create it and give it the value given.
708 If no value is given then the default is zero. */
709static void
710init_if_undefined_command (char* args, int from_tty)
711{
712 struct internalvar* intvar;
713
714 /* Parse the expression - this is taken from set_command(). */
715 struct expression *expr = parse_expression (args);
716 register struct cleanup *old_chain =
717 make_cleanup (free_current_contents, &expr);
718
719 /* Validate the expression.
720 Was the expression an assignment?
721 Or even an expression at all? */
722 if (expr->nelts == 0 || expr->elts[0].opcode != BINOP_ASSIGN)
723 error (_("Init-if-undefined requires an assignment expression."));
724
725 /* Extract the variable from the parsed expression.
726 In the case of an assign the lvalue will be in elts[1] and elts[2]. */
727 if (expr->elts[1].opcode != OP_INTERNALVAR)
728 error (_("The first parameter to init-if-undefined should be a GDB variable."));
729 intvar = expr->elts[2].internalvar;
730
731 /* Only evaluate the expression if the lvalue is void.
732 This may still fail if the expresssion is invalid. */
733 if (TYPE_CODE (value_type (intvar->value)) == TYPE_CODE_VOID)
734 evaluate_expression (expr);
735
736 do_cleanups (old_chain);
737}
738
739
c906108c
SS
740/* Look up an internal variable with name NAME. NAME should not
741 normally include a dollar sign.
742
743 If the specified internal variable does not exist,
744 one is created, with a void value. */
745
746struct internalvar *
fba45db2 747lookup_internalvar (char *name)
c906108c 748{
52f0bd74 749 struct internalvar *var;
c906108c
SS
750
751 for (var = internalvars; var; var = var->next)
5cb316ef 752 if (strcmp (var->name, name) == 0)
c906108c
SS
753 return var;
754
755 var = (struct internalvar *) xmalloc (sizeof (struct internalvar));
1754f103 756 var->name = concat (name, (char *)NULL);
c906108c 757 var->value = allocate_value (builtin_type_void);
d3c139e9 758 var->endian = TARGET_BYTE_ORDER;
c906108c
SS
759 release_value (var->value);
760 var->next = internalvars;
761 internalvars = var;
762 return var;
763}
764
f23631e4 765struct value *
fba45db2 766value_of_internalvar (struct internalvar *var)
c906108c 767{
f23631e4 768 struct value *val;
d3c139e9
AS
769 int i, j;
770 gdb_byte temp;
c906108c 771
c906108c 772 val = value_copy (var->value);
d69fe07e 773 if (value_lazy (val))
c906108c
SS
774 value_fetch_lazy (val);
775 VALUE_LVAL (val) = lval_internalvar;
776 VALUE_INTERNALVAR (val) = var;
d3c139e9
AS
777
778 /* Values are always stored in the target's byte order. When connected to a
779 target this will most likely always be correct, so there's normally no
780 need to worry about it.
781
782 However, internal variables can be set up before the target endian is
783 known and so may become out of date. Fix it up before anybody sees.
784
785 Internal variables usually hold simple scalar values, and we can
786 correct those. More complex values (e.g. structures and floating
787 point types) are left alone, because they would be too complicated
788 to correct. */
789
790 if (var->endian != TARGET_BYTE_ORDER)
791 {
792 gdb_byte *array = value_contents_raw (val);
793 struct type *type = check_typedef (value_enclosing_type (val));
794 switch (TYPE_CODE (type))
795 {
796 case TYPE_CODE_INT:
797 case TYPE_CODE_PTR:
798 /* Reverse the bytes. */
799 for (i = 0, j = TYPE_LENGTH (type) - 1; i < j; i++, j--)
800 {
801 temp = array[j];
802 array[j] = array[i];
803 array[i] = temp;
804 }
805 break;
806 }
807 }
808
c906108c
SS
809 return val;
810}
811
812void
fba45db2 813set_internalvar_component (struct internalvar *var, int offset, int bitpos,
f23631e4 814 int bitsize, struct value *newval)
c906108c 815{
fc1a4b47 816 gdb_byte *addr = value_contents_writeable (var->value) + offset;
c906108c 817
c906108c
SS
818 if (bitsize)
819 modify_field (addr, value_as_long (newval),
820 bitpos, bitsize);
821 else
0fd88904 822 memcpy (addr, value_contents (newval), TYPE_LENGTH (value_type (newval)));
c906108c
SS
823}
824
825void
f23631e4 826set_internalvar (struct internalvar *var, struct value *val)
c906108c 827{
f23631e4 828 struct value *newval;
c906108c 829
c906108c
SS
830 newval = value_copy (val);
831 newval->modifiable = 1;
832
833 /* Force the value to be fetched from the target now, to avoid problems
834 later when this internalvar is referenced and the target is gone or
835 has changed. */
d69fe07e 836 if (value_lazy (newval))
c906108c
SS
837 value_fetch_lazy (newval);
838
839 /* Begin code which must not call error(). If var->value points to
840 something free'd, an error() obviously leaves a dangling pointer.
841 But we also get a danling pointer if var->value points to
842 something in the value chain (i.e., before release_value is
843 called), because after the error free_all_values will get called before
844 long. */
b8c9b27d 845 xfree (var->value);
c906108c 846 var->value = newval;
d3c139e9 847 var->endian = TARGET_BYTE_ORDER;
c906108c
SS
848 release_value (newval);
849 /* End code which must not call error(). */
850}
851
852char *
fba45db2 853internalvar_name (struct internalvar *var)
c906108c
SS
854{
855 return var->name;
856}
857
ae5a43e0
DJ
858/* Update VALUE before discarding OBJFILE. COPIED_TYPES is used to
859 prevent cycles / duplicates. */
860
861static void
862preserve_one_value (struct value *value, struct objfile *objfile,
863 htab_t copied_types)
864{
865 if (TYPE_OBJFILE (value->type) == objfile)
866 value->type = copy_type_recursive (objfile, value->type, copied_types);
867
868 if (TYPE_OBJFILE (value->enclosing_type) == objfile)
869 value->enclosing_type = copy_type_recursive (objfile,
870 value->enclosing_type,
871 copied_types);
872}
873
874/* Update the internal variables and value history when OBJFILE is
875 discarded; we must copy the types out of the objfile. New global types
876 will be created for every convenience variable which currently points to
877 this objfile's types, and the convenience variables will be adjusted to
878 use the new global types. */
c906108c
SS
879
880void
ae5a43e0 881preserve_values (struct objfile *objfile)
c906108c 882{
ae5a43e0
DJ
883 htab_t copied_types;
884 struct value_history_chunk *cur;
52f0bd74 885 struct internalvar *var;
ae5a43e0 886 int i;
c906108c 887
ae5a43e0
DJ
888 /* Create the hash table. We allocate on the objfile's obstack, since
889 it is soon to be deleted. */
890 copied_types = create_copied_types_hash (objfile);
891
892 for (cur = value_history_chain; cur; cur = cur->next)
893 for (i = 0; i < VALUE_HISTORY_CHUNK; i++)
894 if (cur->values[i])
895 preserve_one_value (cur->values[i], objfile, copied_types);
896
897 for (var = internalvars; var; var = var->next)
898 preserve_one_value (var->value, objfile, copied_types);
899
900 htab_delete (copied_types);
c906108c
SS
901}
902
903static void
fba45db2 904show_convenience (char *ignore, int from_tty)
c906108c 905{
52f0bd74 906 struct internalvar *var;
c906108c
SS
907 int varseen = 0;
908
909 for (var = internalvars; var; var = var->next)
910 {
c906108c
SS
911 if (!varseen)
912 {
913 varseen = 1;
914 }
a3f17187 915 printf_filtered (("$%s = "), var->name);
d3c139e9
AS
916 value_print (value_of_internalvar (var), gdb_stdout,
917 0, Val_pretty_default);
a3f17187 918 printf_filtered (("\n"));
c906108c
SS
919 }
920 if (!varseen)
a3f17187
AC
921 printf_unfiltered (_("\
922No debugger convenience variables now defined.\n\
c906108c 923Convenience variables have names starting with \"$\";\n\
a3f17187 924use \"set\" as in \"set $foo = 5\" to define them.\n"));
c906108c
SS
925}
926\f
927/* Extract a value as a C number (either long or double).
928 Knows how to convert fixed values to double, or
929 floating values to long.
930 Does not deallocate the value. */
931
932LONGEST
f23631e4 933value_as_long (struct value *val)
c906108c
SS
934{
935 /* This coerces arrays and functions, which is necessary (e.g.
936 in disassemble_command). It also dereferences references, which
937 I suspect is the most logical thing to do. */
994b9211 938 val = coerce_array (val);
0fd88904 939 return unpack_long (value_type (val), value_contents (val));
c906108c
SS
940}
941
942DOUBLEST
f23631e4 943value_as_double (struct value *val)
c906108c
SS
944{
945 DOUBLEST foo;
946 int inv;
c5aa993b 947
0fd88904 948 foo = unpack_double (value_type (val), value_contents (val), &inv);
c906108c 949 if (inv)
8a3fe4f8 950 error (_("Invalid floating value found in program."));
c906108c
SS
951 return foo;
952}
4478b372
JB
953/* Extract a value as a C pointer. Does not deallocate the value.
954 Note that val's type may not actually be a pointer; value_as_long
955 handles all the cases. */
c906108c 956CORE_ADDR
f23631e4 957value_as_address (struct value *val)
c906108c
SS
958{
959 /* Assume a CORE_ADDR can fit in a LONGEST (for now). Not sure
960 whether we want this to be true eventually. */
961#if 0
962 /* ADDR_BITS_REMOVE is wrong if we are being called for a
963 non-address (e.g. argument to "signal", "info break", etc.), or
964 for pointers to char, in which the low bits *are* significant. */
c5aa993b 965 return ADDR_BITS_REMOVE (value_as_long (val));
c906108c 966#else
f312f057
JB
967
968 /* There are several targets (IA-64, PowerPC, and others) which
969 don't represent pointers to functions as simply the address of
970 the function's entry point. For example, on the IA-64, a
971 function pointer points to a two-word descriptor, generated by
972 the linker, which contains the function's entry point, and the
973 value the IA-64 "global pointer" register should have --- to
974 support position-independent code. The linker generates
975 descriptors only for those functions whose addresses are taken.
976
977 On such targets, it's difficult for GDB to convert an arbitrary
978 function address into a function pointer; it has to either find
979 an existing descriptor for that function, or call malloc and
980 build its own. On some targets, it is impossible for GDB to
981 build a descriptor at all: the descriptor must contain a jump
982 instruction; data memory cannot be executed; and code memory
983 cannot be modified.
984
985 Upon entry to this function, if VAL is a value of type `function'
986 (that is, TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_FUNC), then
987 VALUE_ADDRESS (val) is the address of the function. This is what
988 you'll get if you evaluate an expression like `main'. The call
989 to COERCE_ARRAY below actually does all the usual unary
990 conversions, which includes converting values of type `function'
991 to `pointer to function'. This is the challenging conversion
992 discussed above. Then, `unpack_long' will convert that pointer
993 back into an address.
994
995 So, suppose the user types `disassemble foo' on an architecture
996 with a strange function pointer representation, on which GDB
997 cannot build its own descriptors, and suppose further that `foo'
998 has no linker-built descriptor. The address->pointer conversion
999 will signal an error and prevent the command from running, even
1000 though the next step would have been to convert the pointer
1001 directly back into the same address.
1002
1003 The following shortcut avoids this whole mess. If VAL is a
1004 function, just return its address directly. */
df407dfe
AC
1005 if (TYPE_CODE (value_type (val)) == TYPE_CODE_FUNC
1006 || TYPE_CODE (value_type (val)) == TYPE_CODE_METHOD)
f312f057
JB
1007 return VALUE_ADDRESS (val);
1008
994b9211 1009 val = coerce_array (val);
fc0c74b1
AC
1010
1011 /* Some architectures (e.g. Harvard), map instruction and data
1012 addresses onto a single large unified address space. For
1013 instance: An architecture may consider a large integer in the
1014 range 0x10000000 .. 0x1000ffff to already represent a data
1015 addresses (hence not need a pointer to address conversion) while
1016 a small integer would still need to be converted integer to
1017 pointer to address. Just assume such architectures handle all
1018 integer conversions in a single function. */
1019
1020 /* JimB writes:
1021
1022 I think INTEGER_TO_ADDRESS is a good idea as proposed --- but we
1023 must admonish GDB hackers to make sure its behavior matches the
1024 compiler's, whenever possible.
1025
1026 In general, I think GDB should evaluate expressions the same way
1027 the compiler does. When the user copies an expression out of
1028 their source code and hands it to a `print' command, they should
1029 get the same value the compiler would have computed. Any
1030 deviation from this rule can cause major confusion and annoyance,
1031 and needs to be justified carefully. In other words, GDB doesn't
1032 really have the freedom to do these conversions in clever and
1033 useful ways.
1034
1035 AndrewC pointed out that users aren't complaining about how GDB
1036 casts integers to pointers; they are complaining that they can't
1037 take an address from a disassembly listing and give it to `x/i'.
1038 This is certainly important.
1039
79dd2d24 1040 Adding an architecture method like integer_to_address() certainly
fc0c74b1
AC
1041 makes it possible for GDB to "get it right" in all circumstances
1042 --- the target has complete control over how things get done, so
1043 people can Do The Right Thing for their target without breaking
1044 anyone else. The standard doesn't specify how integers get
1045 converted to pointers; usually, the ABI doesn't either, but
1046 ABI-specific code is a more reasonable place to handle it. */
1047
df407dfe
AC
1048 if (TYPE_CODE (value_type (val)) != TYPE_CODE_PTR
1049 && TYPE_CODE (value_type (val)) != TYPE_CODE_REF
79dd2d24
AC
1050 && gdbarch_integer_to_address_p (current_gdbarch))
1051 return gdbarch_integer_to_address (current_gdbarch, value_type (val),
0fd88904 1052 value_contents (val));
fc0c74b1 1053
0fd88904 1054 return unpack_long (value_type (val), value_contents (val));
c906108c
SS
1055#endif
1056}
1057\f
1058/* Unpack raw data (copied from debugee, target byte order) at VALADDR
1059 as a long, or as a double, assuming the raw data is described
1060 by type TYPE. Knows how to convert different sizes of values
1061 and can convert between fixed and floating point. We don't assume
1062 any alignment for the raw data. Return value is in host byte order.
1063
1064 If you want functions and arrays to be coerced to pointers, and
1065 references to be dereferenced, call value_as_long() instead.
1066
1067 C++: It is assumed that the front-end has taken care of
1068 all matters concerning pointers to members. A pointer
1069 to member which reaches here is considered to be equivalent
1070 to an INT (or some size). After all, it is only an offset. */
1071
1072LONGEST
fc1a4b47 1073unpack_long (struct type *type, const gdb_byte *valaddr)
c906108c 1074{
52f0bd74
AC
1075 enum type_code code = TYPE_CODE (type);
1076 int len = TYPE_LENGTH (type);
1077 int nosign = TYPE_UNSIGNED (type);
c906108c
SS
1078
1079 if (current_language->la_language == language_scm
1080 && is_scmvalue_type (type))
1081 return scm_unpack (type, valaddr, TYPE_CODE_INT);
1082
1083 switch (code)
1084 {
1085 case TYPE_CODE_TYPEDEF:
1086 return unpack_long (check_typedef (type), valaddr);
1087 case TYPE_CODE_ENUM:
4f2aea11 1088 case TYPE_CODE_FLAGS:
c906108c
SS
1089 case TYPE_CODE_BOOL:
1090 case TYPE_CODE_INT:
1091 case TYPE_CODE_CHAR:
1092 case TYPE_CODE_RANGE:
0d5de010 1093 case TYPE_CODE_MEMBERPTR:
c906108c
SS
1094 if (nosign)
1095 return extract_unsigned_integer (valaddr, len);
1096 else
1097 return extract_signed_integer (valaddr, len);
1098
1099 case TYPE_CODE_FLT:
96d2f608 1100 return extract_typed_floating (valaddr, type);
c906108c
SS
1101
1102 case TYPE_CODE_PTR:
1103 case TYPE_CODE_REF:
1104 /* Assume a CORE_ADDR can fit in a LONGEST (for now). Not sure
c5aa993b 1105 whether we want this to be true eventually. */
4478b372 1106 return extract_typed_address (valaddr, type);
c906108c 1107
c906108c 1108 default:
8a3fe4f8 1109 error (_("Value can't be converted to integer."));
c906108c 1110 }
c5aa993b 1111 return 0; /* Placate lint. */
c906108c
SS
1112}
1113
1114/* Return a double value from the specified type and address.
1115 INVP points to an int which is set to 0 for valid value,
1116 1 for invalid value (bad float format). In either case,
1117 the returned double is OK to use. Argument is in target
1118 format, result is in host format. */
1119
1120DOUBLEST
fc1a4b47 1121unpack_double (struct type *type, const gdb_byte *valaddr, int *invp)
c906108c
SS
1122{
1123 enum type_code code;
1124 int len;
1125 int nosign;
1126
1127 *invp = 0; /* Assume valid. */
1128 CHECK_TYPEDEF (type);
1129 code = TYPE_CODE (type);
1130 len = TYPE_LENGTH (type);
1131 nosign = TYPE_UNSIGNED (type);
1132 if (code == TYPE_CODE_FLT)
1133 {
75bc7ddf
AC
1134 /* NOTE: cagney/2002-02-19: There was a test here to see if the
1135 floating-point value was valid (using the macro
1136 INVALID_FLOAT). That test/macro have been removed.
1137
1138 It turns out that only the VAX defined this macro and then
1139 only in a non-portable way. Fixing the portability problem
1140 wouldn't help since the VAX floating-point code is also badly
1141 bit-rotten. The target needs to add definitions for the
1142 methods TARGET_FLOAT_FORMAT and TARGET_DOUBLE_FORMAT - these
1143 exactly describe the target floating-point format. The
1144 problem here is that the corresponding floatformat_vax_f and
1145 floatformat_vax_d values these methods should be set to are
1146 also not defined either. Oops!
1147
1148 Hopefully someone will add both the missing floatformat
ac79b88b
DJ
1149 definitions and the new cases for floatformat_is_valid (). */
1150
1151 if (!floatformat_is_valid (floatformat_from_type (type), valaddr))
1152 {
1153 *invp = 1;
1154 return 0.0;
1155 }
1156
96d2f608 1157 return extract_typed_floating (valaddr, type);
c906108c
SS
1158 }
1159 else if (nosign)
1160 {
1161 /* Unsigned -- be sure we compensate for signed LONGEST. */
c906108c 1162 return (ULONGEST) unpack_long (type, valaddr);
c906108c
SS
1163 }
1164 else
1165 {
1166 /* Signed -- we are OK with unpack_long. */
1167 return unpack_long (type, valaddr);
1168 }
1169}
1170
1171/* Unpack raw data (copied from debugee, target byte order) at VALADDR
1172 as a CORE_ADDR, assuming the raw data is described by type TYPE.
1173 We don't assume any alignment for the raw data. Return value is in
1174 host byte order.
1175
1176 If you want functions and arrays to be coerced to pointers, and
1aa20aa8 1177 references to be dereferenced, call value_as_address() instead.
c906108c
SS
1178
1179 C++: It is assumed that the front-end has taken care of
1180 all matters concerning pointers to members. A pointer
1181 to member which reaches here is considered to be equivalent
1182 to an INT (or some size). After all, it is only an offset. */
1183
1184CORE_ADDR
fc1a4b47 1185unpack_pointer (struct type *type, const gdb_byte *valaddr)
c906108c
SS
1186{
1187 /* Assume a CORE_ADDR can fit in a LONGEST (for now). Not sure
1188 whether we want this to be true eventually. */
1189 return unpack_long (type, valaddr);
1190}
4478b372 1191
c906108c 1192\f
2c2738a0
DC
1193/* Get the value of the FIELDN'th field (which must be static) of
1194 TYPE. Return NULL if the field doesn't exist or has been
1195 optimized out. */
c906108c 1196
f23631e4 1197struct value *
fba45db2 1198value_static_field (struct type *type, int fieldno)
c906108c 1199{
948e66d9
DJ
1200 struct value *retval;
1201
c906108c
SS
1202 if (TYPE_FIELD_STATIC_HAS_ADDR (type, fieldno))
1203 {
948e66d9 1204 retval = value_at (TYPE_FIELD_TYPE (type, fieldno),
00a4c844 1205 TYPE_FIELD_STATIC_PHYSADDR (type, fieldno));
c906108c
SS
1206 }
1207 else
1208 {
1209 char *phys_name = TYPE_FIELD_STATIC_PHYSNAME (type, fieldno);
176620f1 1210 struct symbol *sym = lookup_symbol (phys_name, 0, VAR_DOMAIN, 0, NULL);
948e66d9 1211 if (sym == NULL)
c906108c
SS
1212 {
1213 /* With some compilers, e.g. HP aCC, static data members are reported
c5aa993b
JM
1214 as non-debuggable symbols */
1215 struct minimal_symbol *msym = lookup_minimal_symbol (phys_name, NULL, NULL);
c906108c
SS
1216 if (!msym)
1217 return NULL;
1218 else
c5aa993b 1219 {
948e66d9 1220 retval = value_at (TYPE_FIELD_TYPE (type, fieldno),
00a4c844 1221 SYMBOL_VALUE_ADDRESS (msym));
c906108c
SS
1222 }
1223 }
1224 else
1225 {
948e66d9
DJ
1226 /* SYM should never have a SYMBOL_CLASS which will require
1227 read_var_value to use the FRAME parameter. */
1228 if (symbol_read_needs_frame (sym))
8a3fe4f8
AC
1229 warning (_("static field's value depends on the current "
1230 "frame - bad debug info?"));
948e66d9 1231 retval = read_var_value (sym, NULL);
2b127877 1232 }
948e66d9
DJ
1233 if (retval && VALUE_LVAL (retval) == lval_memory)
1234 SET_FIELD_PHYSADDR (TYPE_FIELD (type, fieldno),
1235 VALUE_ADDRESS (retval));
c906108c 1236 }
948e66d9 1237 return retval;
c906108c
SS
1238}
1239
2b127877
DB
1240/* Change the enclosing type of a value object VAL to NEW_ENCL_TYPE.
1241 You have to be careful here, since the size of the data area for the value
1242 is set by the length of the enclosing type. So if NEW_ENCL_TYPE is bigger
1243 than the old enclosing type, you have to allocate more space for the data.
1244 The return value is a pointer to the new version of this value structure. */
1245
f23631e4
AC
1246struct value *
1247value_change_enclosing_type (struct value *val, struct type *new_encl_type)
2b127877 1248{
4754a64e 1249 if (TYPE_LENGTH (new_encl_type) <= TYPE_LENGTH (value_enclosing_type (val)))
2b127877 1250 {
4754a64e 1251 val->enclosing_type = new_encl_type;
2b127877
DB
1252 return val;
1253 }
1254 else
1255 {
f23631e4
AC
1256 struct value *new_val;
1257 struct value *prev;
2b127877 1258
f23631e4 1259 new_val = (struct value *) xrealloc (val, sizeof (struct value) + TYPE_LENGTH (new_encl_type));
cc303028 1260
4754a64e 1261 new_val->enclosing_type = new_encl_type;
cc303028 1262
2b127877
DB
1263 /* We have to make sure this ends up in the same place in the value
1264 chain as the original copy, so it's clean-up behavior is the same.
1265 If the value has been released, this is a waste of time, but there
1266 is no way to tell that in advance, so... */
1267
1268 if (val != all_values)
1269 {
1270 for (prev = all_values; prev != NULL; prev = prev->next)
1271 {
1272 if (prev->next == val)
1273 {
1274 prev->next = new_val;
1275 break;
1276 }
1277 }
1278 }
1279
1280 return new_val;
1281 }
1282}
1283
c906108c
SS
1284/* Given a value ARG1 (offset by OFFSET bytes)
1285 of a struct or union type ARG_TYPE,
1286 extract and return the value of one of its (non-static) fields.
1287 FIELDNO says which field. */
1288
f23631e4
AC
1289struct value *
1290value_primitive_field (struct value *arg1, int offset,
aa1ee363 1291 int fieldno, struct type *arg_type)
c906108c 1292{
f23631e4 1293 struct value *v;
52f0bd74 1294 struct type *type;
c906108c
SS
1295
1296 CHECK_TYPEDEF (arg_type);
1297 type = TYPE_FIELD_TYPE (arg_type, fieldno);
1298
1299 /* Handle packed fields */
1300
1301 if (TYPE_FIELD_BITSIZE (arg_type, fieldno))
1302 {
1303 v = value_from_longest (type,
1304 unpack_field_as_long (arg_type,
0fd88904 1305 value_contents (arg1)
c5aa993b 1306 + offset,
c906108c 1307 fieldno));
df407dfe
AC
1308 v->bitpos = TYPE_FIELD_BITPOS (arg_type, fieldno) % 8;
1309 v->bitsize = TYPE_FIELD_BITSIZE (arg_type, fieldno);
1310 v->offset = value_offset (arg1) + offset
2e70b7b9 1311 + TYPE_FIELD_BITPOS (arg_type, fieldno) / 8;
c906108c
SS
1312 }
1313 else if (fieldno < TYPE_N_BASECLASSES (arg_type))
1314 {
1315 /* This field is actually a base subobject, so preserve the
1316 entire object's contents for later references to virtual
1317 bases, etc. */
4754a64e 1318 v = allocate_value (value_enclosing_type (arg1));
df407dfe 1319 v->type = type;
d69fe07e 1320 if (value_lazy (arg1))
dfa52d88 1321 set_value_lazy (v, 1);
c906108c 1322 else
990a07ab 1323 memcpy (value_contents_all_raw (v), value_contents_all_raw (arg1),
4754a64e 1324 TYPE_LENGTH (value_enclosing_type (arg1)));
df407dfe 1325 v->offset = value_offset (arg1);
13c3b5f5
AC
1326 v->embedded_offset = (offset + value_embedded_offset (arg1)
1327 + TYPE_FIELD_BITPOS (arg_type, fieldno) / 8);
c906108c
SS
1328 }
1329 else
1330 {
1331 /* Plain old data member */
1332 offset += TYPE_FIELD_BITPOS (arg_type, fieldno) / 8;
1333 v = allocate_value (type);
d69fe07e 1334 if (value_lazy (arg1))
dfa52d88 1335 set_value_lazy (v, 1);
c906108c 1336 else
990a07ab
AC
1337 memcpy (value_contents_raw (v),
1338 value_contents_raw (arg1) + offset,
c906108c 1339 TYPE_LENGTH (type));
df407dfe 1340 v->offset = (value_offset (arg1) + offset
13c3b5f5 1341 + value_embedded_offset (arg1));
c906108c
SS
1342 }
1343 VALUE_LVAL (v) = VALUE_LVAL (arg1);
1344 if (VALUE_LVAL (arg1) == lval_internalvar)
1345 VALUE_LVAL (v) = lval_internalvar_component;
1346 VALUE_ADDRESS (v) = VALUE_ADDRESS (arg1);
9ee8fc9d 1347 VALUE_REGNUM (v) = VALUE_REGNUM (arg1);
0c16dd26 1348 VALUE_FRAME_ID (v) = VALUE_FRAME_ID (arg1);
c906108c 1349/* VALUE_OFFSET (v) = VALUE_OFFSET (arg1) + offset
c5aa993b 1350 + TYPE_FIELD_BITPOS (arg_type, fieldno) / 8; */
c906108c
SS
1351 return v;
1352}
1353
1354/* Given a value ARG1 of a struct or union type,
1355 extract and return the value of one of its (non-static) fields.
1356 FIELDNO says which field. */
1357
f23631e4 1358struct value *
aa1ee363 1359value_field (struct value *arg1, int fieldno)
c906108c 1360{
df407dfe 1361 return value_primitive_field (arg1, 0, fieldno, value_type (arg1));
c906108c
SS
1362}
1363
1364/* Return a non-virtual function as a value.
1365 F is the list of member functions which contains the desired method.
0478d61c
FF
1366 J is an index into F which provides the desired method.
1367
1368 We only use the symbol for its address, so be happy with either a
1369 full symbol or a minimal symbol.
1370 */
c906108c 1371
f23631e4
AC
1372struct value *
1373value_fn_field (struct value **arg1p, struct fn_field *f, int j, struct type *type,
fba45db2 1374 int offset)
c906108c 1375{
f23631e4 1376 struct value *v;
52f0bd74 1377 struct type *ftype = TYPE_FN_FIELD_TYPE (f, j);
0478d61c 1378 char *physname = TYPE_FN_FIELD_PHYSNAME (f, j);
c906108c 1379 struct symbol *sym;
0478d61c 1380 struct minimal_symbol *msym;
c906108c 1381
176620f1 1382 sym = lookup_symbol (physname, 0, VAR_DOMAIN, 0, NULL);
5ae326fa 1383 if (sym != NULL)
0478d61c 1384 {
5ae326fa
AC
1385 msym = NULL;
1386 }
1387 else
1388 {
1389 gdb_assert (sym == NULL);
0478d61c 1390 msym = lookup_minimal_symbol (physname, NULL, NULL);
5ae326fa
AC
1391 if (msym == NULL)
1392 return NULL;
0478d61c
FF
1393 }
1394
c906108c 1395 v = allocate_value (ftype);
0478d61c
FF
1396 if (sym)
1397 {
1398 VALUE_ADDRESS (v) = BLOCK_START (SYMBOL_BLOCK_VALUE (sym));
1399 }
1400 else
1401 {
1402 VALUE_ADDRESS (v) = SYMBOL_VALUE_ADDRESS (msym);
1403 }
c906108c
SS
1404
1405 if (arg1p)
c5aa993b 1406 {
df407dfe 1407 if (type != value_type (*arg1p))
c5aa993b
JM
1408 *arg1p = value_ind (value_cast (lookup_pointer_type (type),
1409 value_addr (*arg1p)));
1410
070ad9f0 1411 /* Move the `this' pointer according to the offset.
c5aa993b
JM
1412 VALUE_OFFSET (*arg1p) += offset;
1413 */
c906108c
SS
1414 }
1415
1416 return v;
1417}
1418
c906108c
SS
1419\f
1420/* Unpack a field FIELDNO of the specified TYPE, from the anonymous object at
1421 VALADDR.
1422
1423 Extracting bits depends on endianness of the machine. Compute the
1424 number of least significant bits to discard. For big endian machines,
1425 we compute the total number of bits in the anonymous object, subtract
1426 off the bit count from the MSB of the object to the MSB of the
1427 bitfield, then the size of the bitfield, which leaves the LSB discard
1428 count. For little endian machines, the discard count is simply the
1429 number of bits from the LSB of the anonymous object to the LSB of the
1430 bitfield.
1431
1432 If the field is signed, we also do sign extension. */
1433
1434LONGEST
fc1a4b47 1435unpack_field_as_long (struct type *type, const gdb_byte *valaddr, int fieldno)
c906108c
SS
1436{
1437 ULONGEST val;
1438 ULONGEST valmask;
1439 int bitpos = TYPE_FIELD_BITPOS (type, fieldno);
1440 int bitsize = TYPE_FIELD_BITSIZE (type, fieldno);
1441 int lsbcount;
1442 struct type *field_type;
1443
1444 val = extract_unsigned_integer (valaddr + bitpos / 8, sizeof (val));
1445 field_type = TYPE_FIELD_TYPE (type, fieldno);
1446 CHECK_TYPEDEF (field_type);
1447
1448 /* Extract bits. See comment above. */
1449
1450 if (BITS_BIG_ENDIAN)
1451 lsbcount = (sizeof val * 8 - bitpos % 8 - bitsize);
1452 else
1453 lsbcount = (bitpos % 8);
1454 val >>= lsbcount;
1455
1456 /* If the field does not entirely fill a LONGEST, then zero the sign bits.
1457 If the field is signed, and is negative, then sign extend. */
1458
1459 if ((bitsize > 0) && (bitsize < 8 * (int) sizeof (val)))
1460 {
1461 valmask = (((ULONGEST) 1) << bitsize) - 1;
1462 val &= valmask;
1463 if (!TYPE_UNSIGNED (field_type))
1464 {
1465 if (val & (valmask ^ (valmask >> 1)))
1466 {
1467 val |= ~valmask;
1468 }
1469 }
1470 }
1471 return (val);
1472}
1473
1474/* Modify the value of a bitfield. ADDR points to a block of memory in
1475 target byte order; the bitfield starts in the byte pointed to. FIELDVAL
1476 is the desired value of the field, in host byte order. BITPOS and BITSIZE
f4e88c8e
PH
1477 indicate which bits (in target bit order) comprise the bitfield.
1478 Requires 0 < BITSIZE <= lbits, 0 <= BITPOS+BITSIZE <= lbits, and
1479 0 <= BITPOS, where lbits is the size of a LONGEST in bits. */
c906108c
SS
1480
1481void
fc1a4b47 1482modify_field (gdb_byte *addr, LONGEST fieldval, int bitpos, int bitsize)
c906108c 1483{
f4e88c8e
PH
1484 ULONGEST oword;
1485 ULONGEST mask = (ULONGEST) -1 >> (8 * sizeof (ULONGEST) - bitsize);
c906108c
SS
1486
1487 /* If a negative fieldval fits in the field in question, chop
1488 off the sign extension bits. */
f4e88c8e
PH
1489 if ((~fieldval & ~(mask >> 1)) == 0)
1490 fieldval &= mask;
c906108c
SS
1491
1492 /* Warn if value is too big to fit in the field in question. */
f4e88c8e 1493 if (0 != (fieldval & ~mask))
c906108c
SS
1494 {
1495 /* FIXME: would like to include fieldval in the message, but
c5aa993b 1496 we don't have a sprintf_longest. */
8a3fe4f8 1497 warning (_("Value does not fit in %d bits."), bitsize);
c906108c
SS
1498
1499 /* Truncate it, otherwise adjoining fields may be corrupted. */
f4e88c8e 1500 fieldval &= mask;
c906108c
SS
1501 }
1502
f4e88c8e 1503 oword = extract_unsigned_integer (addr, sizeof oword);
c906108c
SS
1504
1505 /* Shifting for bit field depends on endianness of the target machine. */
1506 if (BITS_BIG_ENDIAN)
1507 bitpos = sizeof (oword) * 8 - bitpos - bitsize;
1508
f4e88c8e 1509 oword &= ~(mask << bitpos);
c906108c
SS
1510 oword |= fieldval << bitpos;
1511
f4e88c8e 1512 store_unsigned_integer (addr, sizeof oword, oword);
c906108c
SS
1513}
1514\f
1515/* Convert C numbers into newly allocated values */
1516
f23631e4 1517struct value *
aa1ee363 1518value_from_longest (struct type *type, LONGEST num)
c906108c 1519{
f23631e4 1520 struct value *val = allocate_value (type);
52f0bd74
AC
1521 enum type_code code;
1522 int len;
c5aa993b 1523retry:
c906108c
SS
1524 code = TYPE_CODE (type);
1525 len = TYPE_LENGTH (type);
1526
1527 switch (code)
1528 {
1529 case TYPE_CODE_TYPEDEF:
1530 type = check_typedef (type);
1531 goto retry;
1532 case TYPE_CODE_INT:
1533 case TYPE_CODE_CHAR:
1534 case TYPE_CODE_ENUM:
4f2aea11 1535 case TYPE_CODE_FLAGS:
c906108c
SS
1536 case TYPE_CODE_BOOL:
1537 case TYPE_CODE_RANGE:
0d5de010 1538 case TYPE_CODE_MEMBERPTR:
990a07ab 1539 store_signed_integer (value_contents_raw (val), len, num);
c906108c 1540 break;
c5aa993b 1541
c906108c
SS
1542 case TYPE_CODE_REF:
1543 case TYPE_CODE_PTR:
990a07ab 1544 store_typed_address (value_contents_raw (val), type, (CORE_ADDR) num);
c906108c 1545 break;
c5aa993b 1546
c906108c 1547 default:
8a3fe4f8 1548 error (_("Unexpected type (%d) encountered for integer constant."), code);
c906108c
SS
1549 }
1550 return val;
1551}
1552
4478b372
JB
1553
1554/* Create a value representing a pointer of type TYPE to the address
1555 ADDR. */
f23631e4 1556struct value *
4478b372
JB
1557value_from_pointer (struct type *type, CORE_ADDR addr)
1558{
f23631e4 1559 struct value *val = allocate_value (type);
990a07ab 1560 store_typed_address (value_contents_raw (val), type, addr);
4478b372
JB
1561 return val;
1562}
1563
1564
0f71a2f6 1565/* Create a value for a string constant to be stored locally
070ad9f0 1566 (not in the inferior's memory space, but in GDB memory).
0f71a2f6
JM
1567 This is analogous to value_from_longest, which also does not
1568 use inferior memory. String shall NOT contain embedded nulls. */
1569
f23631e4 1570struct value *
fba45db2 1571value_from_string (char *ptr)
0f71a2f6 1572{
f23631e4 1573 struct value *val;
c5aa993b 1574 int len = strlen (ptr);
0f71a2f6 1575 int lowbound = current_language->string_lower_bound;
f290d38e
AC
1576 struct type *string_char_type;
1577 struct type *rangetype;
1578 struct type *stringtype;
1579
1580 rangetype = create_range_type ((struct type *) NULL,
1581 builtin_type_int,
1582 lowbound, len + lowbound - 1);
1583 string_char_type = language_string_char_type (current_language,
1584 current_gdbarch);
1585 stringtype = create_array_type ((struct type *) NULL,
1586 string_char_type,
1587 rangetype);
0f71a2f6 1588 val = allocate_value (stringtype);
990a07ab 1589 memcpy (value_contents_raw (val), ptr, len);
0f71a2f6
JM
1590 return val;
1591}
1592
f23631e4 1593struct value *
fba45db2 1594value_from_double (struct type *type, DOUBLEST num)
c906108c 1595{
f23631e4 1596 struct value *val = allocate_value (type);
c906108c 1597 struct type *base_type = check_typedef (type);
52f0bd74
AC
1598 enum type_code code = TYPE_CODE (base_type);
1599 int len = TYPE_LENGTH (base_type);
c906108c
SS
1600
1601 if (code == TYPE_CODE_FLT)
1602 {
990a07ab 1603 store_typed_floating (value_contents_raw (val), base_type, num);
c906108c
SS
1604 }
1605 else
8a3fe4f8 1606 error (_("Unexpected type encountered for floating constant."));
c906108c
SS
1607
1608 return val;
1609}
994b9211
AC
1610
1611struct value *
1612coerce_ref (struct value *arg)
1613{
df407dfe 1614 struct type *value_type_arg_tmp = check_typedef (value_type (arg));
994b9211
AC
1615 if (TYPE_CODE (value_type_arg_tmp) == TYPE_CODE_REF)
1616 arg = value_at_lazy (TYPE_TARGET_TYPE (value_type_arg_tmp),
df407dfe 1617 unpack_pointer (value_type (arg),
0fd88904 1618 value_contents (arg)));
994b9211
AC
1619 return arg;
1620}
1621
1622struct value *
1623coerce_array (struct value *arg)
1624{
1625 arg = coerce_ref (arg);
1626 if (current_language->c_style_arrays
df407dfe 1627 && TYPE_CODE (value_type (arg)) == TYPE_CODE_ARRAY)
994b9211 1628 arg = value_coerce_array (arg);
df407dfe 1629 if (TYPE_CODE (value_type (arg)) == TYPE_CODE_FUNC)
994b9211
AC
1630 arg = value_coerce_function (arg);
1631 return arg;
1632}
1633
1634struct value *
1635coerce_number (struct value *arg)
1636{
1637 arg = coerce_array (arg);
1638 arg = coerce_enum (arg);
1639 return arg;
1640}
1641
1642struct value *
1643coerce_enum (struct value *arg)
1644{
df407dfe 1645 if (TYPE_CODE (check_typedef (value_type (arg))) == TYPE_CODE_ENUM)
994b9211
AC
1646 arg = value_cast (builtin_type_unsigned_int, arg);
1647 return arg;
1648}
c906108c 1649\f
c906108c 1650
74055713
AC
1651/* Should we use DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS instead of
1652 EXTRACT_RETURN_VALUE? GCC_P is true if compiled with gcc and TYPE
1653 is the type (which is known to be struct, union or array).
c906108c
SS
1654
1655 On most machines, the struct convention is used unless we are
1656 using gcc and the type is of a special size. */
1657/* As of about 31 Mar 93, GCC was changed to be compatible with the
1658 native compiler. GCC 2.3.3 was the last release that did it the
1659 old way. Since gcc2_compiled was not changed, we have no
1660 way to correctly win in all cases, so we just do the right thing
1661 for gcc1 and for gcc2 after this change. Thus it loses for gcc
1662 2.0-2.3.3. This is somewhat unfortunate, but changing gcc2_compiled
1663 would cause more chaos than dealing with some struct returns being
1664 handled wrong. */
bc87dfa0
AC
1665/* NOTE: cagney/2004-06-13: Deleted check for "gcc_p". GCC 1.x is
1666 dead. */
c906108c
SS
1667
1668int
fba45db2 1669generic_use_struct_convention (int gcc_p, struct type *value_type)
c5aa993b 1670{
bc87dfa0
AC
1671 return !(TYPE_LENGTH (value_type) == 1
1672 || TYPE_LENGTH (value_type) == 2
1673 || TYPE_LENGTH (value_type) == 4
1674 || TYPE_LENGTH (value_type) == 8);
c906108c
SS
1675}
1676
48436ce6
AC
1677/* Return true if the function returning the specified type is using
1678 the convention of returning structures in memory (passing in the
1679 address as a hidden first parameter). GCC_P is nonzero if compiled
c906108c
SS
1680 with GCC. */
1681
1682int
48436ce6 1683using_struct_return (struct type *value_type, int gcc_p)
c906108c 1684{
52f0bd74 1685 enum type_code code = TYPE_CODE (value_type);
c906108c
SS
1686
1687 if (code == TYPE_CODE_ERROR)
8a3fe4f8 1688 error (_("Function return type unknown."));
c906108c 1689
667e784f
AC
1690 if (code == TYPE_CODE_VOID)
1691 /* A void return value is never in memory. See also corresponding
44e5158b 1692 code in "print_return_value". */
667e784f
AC
1693 return 0;
1694
92ad9cd9
AC
1695 /* Probe the architecture for the return-value convention. */
1696 return (gdbarch_return_value (current_gdbarch, value_type,
1697 NULL, NULL, NULL)
31db7b6c 1698 != RETURN_VALUE_REGISTER_CONVENTION);
c906108c
SS
1699}
1700
c906108c 1701void
fba45db2 1702_initialize_values (void)
c906108c 1703{
1a966eab
AC
1704 add_cmd ("convenience", no_class, show_convenience, _("\
1705Debugger convenience (\"$foo\") variables.\n\
c906108c 1706These variables are created when you assign them values;\n\
1a966eab
AC
1707thus, \"print $foo=1\" gives \"$foo\" the value 1. Values may be any type.\n\
1708\n\
c906108c
SS
1709A few convenience variables are given values automatically:\n\
1710\"$_\"holds the last address examined with \"x\" or \"info lines\",\n\
1a966eab 1711\"$__\" holds the contents of the last address examined with \"x\"."),
c906108c
SS
1712 &showlist);
1713
1714 add_cmd ("values", no_class, show_values,
1a966eab 1715 _("Elements of value history around item number IDX (or last ten)."),
c906108c 1716 &showlist);
53e5f3cf
AS
1717
1718 add_com ("init-if-undefined", class_vars, init_if_undefined_command, _("\
1719Initialize a convenience variable if necessary.\n\
1720init-if-undefined VARIABLE = EXPRESSION\n\
1721Set an internal VARIABLE to the result of the EXPRESSION if it does not\n\
1722exist or does not contain a value. The EXPRESSION is not evaluated if the\n\
1723VARIABLE is already initialized."));
c906108c 1724}