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