![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to valops.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / contrib / emacs-18.55 / gdb|
Return to valops.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / contrib / emacs-18.55 / gdb |
1.1 root 1: /* Perform non-arithmetic operations on values, for GDB.
2: Copyright (C) 1986, 1987 Free Software Foundation, Inc.
3:
4: GDB is distributed in the hope that it will be useful, but WITHOUT ANY
5: WARRANTY. No author or distributor accepts responsibility to anyone
6: for the consequences of using it or for whether it serves any
7: particular purpose or works at all, unless he says so in writing.
8: Refer to the GDB General Public License for full details.
9:
10: Everyone is granted permission to copy, modify and redistribute GDB,
11: but only under the conditions described in the GDB General Public
12: License. A copy of this license is supposed to have been given to you
13: along with GDB so you can know your rights and responsibilities. It
14: should be in a file named COPYING. Among other things, the copyright
15: notice and this notice must be preserved on all copies.
16:
17: In other words, go ahead and share GDB, but don't try to stop
18: anyone else from sharing it farther. Help stamp out software hoarding!
19: */
20:
21: #include "defs.h"
22: #include "initialize.h"
23: #include "param.h"
24: #include "symtab.h"
25: #include "value.h"
26:
27: START_FILE
28:
29: /* Cast value ARG2 to type TYPE and return as a value.
30: More general than a C cast: accepts any two types of the same length,
31: and if ARG2 is an lvalue it can be cast into anything at all. */
32:
33: value
34: value_cast (type, arg2)
35: struct type *type;
36: register value arg2;
37: {
38: register enum type_code code1;
39: register enum type_code code2;
40: register int scalar;
41:
42: /* Coerce arrays but not enums. Enums will work as-is
43: and coercing them would cause an infinite recursion. */
44: if (TYPE_CODE (VALUE_TYPE (arg2)) != TYPE_CODE_ENUM)
45: COERCE_ARRAY (arg2);
46:
47: code1 = TYPE_CODE (type);
48: code2 = TYPE_CODE (VALUE_TYPE (arg2));
49: scalar = (code2 == TYPE_CODE_INT || code2 == TYPE_CODE_FLT
50: || code2 == TYPE_CODE_ENUM);
51:
52: if (code1 == TYPE_CODE_FLT && scalar)
53: return value_from_double (type, value_as_double (arg2));
54: else if ((code1 == TYPE_CODE_INT || code1 == TYPE_CODE_ENUM)
55: && (scalar || code2 == TYPE_CODE_PTR))
56: return value_from_long (type, value_as_long (arg2));
57: else if (TYPE_LENGTH (type) == TYPE_LENGTH (VALUE_TYPE (arg2)))
58: {
59: VALUE_TYPE (arg2) = type;
60: return arg2;
61: }
62: else if (VALUE_LVAL (arg2) == lval_memory)
63: return value_at (type, VALUE_ADDRESS (arg2) + VALUE_OFFSET (arg2));
64: else
65: error ("Invalid cast.");
66: }
67:
68: /* Return the value with a specified type located at specified address. */
69:
70: value
71: value_at (type, addr)
72: struct type *type;
73: CORE_ADDR addr;
74: {
75: register value val = allocate_value (type);
76:
77: read_memory (addr, VALUE_CONTENTS (val), TYPE_LENGTH (type));
78: VALUE_LVAL (val) = lval_memory;
79: VALUE_ADDRESS (val) = addr;
80:
81: return val;
82: }
83:
84: /* Store the contents of FROMVAL into the location of TOVAL.
85: Return a new value with the location of TOVAL and contents of FROMVAL. */
86:
87: value
88: value_assign (toval, fromval)
89: register value toval, fromval;
90: {
91: register struct type *type = VALUE_TYPE (toval);
92: register value val;
93: char raw_buffer[MAX_REGISTER_RAW_SIZE];
94: char virtual_buffer[MAX_REGISTER_VIRTUAL_SIZE];
95: int use_buffer = 0;
96:
97: COERCE_ARRAY (fromval);
98:
99: if (VALUE_LVAL (toval) != lval_internalvar)
100: fromval = value_cast (type, fromval);
101:
102: /* If TOVAL is a special machine register requiring conversion
103: of program values to a special raw format,
104: convert FROMVAL's contents now, with result in `raw_buffer',
105: and set USE_BUFFER to the number of bytes to write. */
106:
107: if (VALUE_REGNO (toval) >= 0
108: && REGISTER_CONVERTIBLE (VALUE_REGNO (toval)))
109: {
110: int regno = VALUE_REGNO (toval);
111: if (VALUE_TYPE (fromval) != REGISTER_VIRTUAL_TYPE (regno))
112: fromval = value_cast (REGISTER_VIRTUAL_TYPE (regno), fromval);
113: bcopy (VALUE_CONTENTS (fromval), virtual_buffer,
114: REGISTER_VIRTUAL_SIZE (regno));
115: REGISTER_CONVERT_TO_RAW (regno, virtual_buffer, raw_buffer);
116: use_buffer = REGISTER_RAW_SIZE (regno);
117: }
118:
119: switch (VALUE_LVAL (toval))
120: {
121: case lval_internalvar:
122: set_internalvar (VALUE_INTERNALVAR (toval), fromval);
123: break;
124:
125: case lval_internalvar_component:
126: set_internalvar_component (VALUE_INTERNALVAR (toval),
127: VALUE_OFFSET (toval),
128: VALUE_BITPOS (toval),
129: VALUE_BITSIZE (toval),
130: fromval);
131: break;
132:
133: case lval_memory:
134: if (VALUE_BITSIZE (toval))
135: {
136: int val;
137: read_memory (VALUE_ADDRESS (toval) + VALUE_OFFSET (toval),
138: &val, sizeof val);
139: modify_field (&val, value_as_long (fromval),
140: VALUE_BITPOS (toval), VALUE_BITSIZE (toval));
141: write_memory (VALUE_ADDRESS (toval) + VALUE_OFFSET (toval),
142: &val, sizeof val);
143: }
144: else if (use_buffer)
145: write_memory (VALUE_ADDRESS (toval) + VALUE_OFFSET (toval),
146: raw_buffer, use_buffer);
147: else
148: write_memory (VALUE_ADDRESS (toval) + VALUE_OFFSET (toval),
149: VALUE_CONTENTS (fromval), TYPE_LENGTH (type));
150: break;
151:
152: case lval_register:
153: if (VALUE_BITSIZE (toval))
154: {
155: int val;
156:
157: read_register_bytes (VALUE_ADDRESS (toval) + VALUE_OFFSET (toval),
158: &val, sizeof val);
159: modify_field (&val, value_as_long (fromval),
160: VALUE_BITPOS (toval), VALUE_BITSIZE (toval));
161: write_register_bytes (VALUE_ADDRESS (toval) + VALUE_OFFSET (toval),
162: &val, sizeof val);
163: }
164: else if (use_buffer)
165: write_register_bytes (VALUE_ADDRESS (toval) + VALUE_OFFSET (toval),
166: raw_buffer, use_buffer);
167: else
168: write_register_bytes (VALUE_ADDRESS (toval) + VALUE_OFFSET (toval),
169: VALUE_CONTENTS (fromval), TYPE_LENGTH (type));
170: break;
171:
172: default:
173: error ("Left side of = operation is not an lvalue.");
174: }
175:
176: /* Return a value just like TOVAL except with the contents of FROMVAL. */
177:
178: val = allocate_value (type);
179: bcopy (toval, val, VALUE_CONTENTS (val) - (char *) val);
180: bcopy (VALUE_CONTENTS (fromval), VALUE_CONTENTS (val), TYPE_LENGTH (type));
181:
182: return val;
183: }
184:
185: /* Extend a value VAL to COUNT repetitions of its type. */
186:
187: value
188: value_repeat (arg1, count)
189: value arg1;
190: int count;
191: {
192: register value val;
193:
194: if (VALUE_LVAL (arg1) != lval_memory)
195: error ("Only values in memory can be extended with '@'.");
196: if (count < 1)
197: error ("Invalid number %d of repetitions.", count);
198:
199: val = allocate_repeat_value (VALUE_TYPE (arg1), count);
200:
201: read_memory (VALUE_ADDRESS (arg1) + VALUE_OFFSET (arg1),
202: VALUE_CONTENTS (val),
203: TYPE_LENGTH (VALUE_TYPE (val)) * count);
204: VALUE_LVAL (val) = lval_memory;
205: VALUE_ADDRESS (val) = VALUE_ADDRESS (arg1) + VALUE_OFFSET (arg1);
206:
207: return val;
208: }
209:
210: value
211: value_of_variable (var)
212: struct symbol *var;
213: {
214: return read_var_value (var, (CORE_ADDR) 0);
215: }
216:
217: /* Given a value which is an array, return a value which is
218: a pointer to its first element. */
219:
220: value
221: value_coerce_array (arg1)
222: value arg1;
223: {
224: register struct type *type;
225: register value val;
226:
227: if (VALUE_LVAL (arg1) != lval_memory)
228: error ("Attempt to take address of value not located in memory.");
229:
230: /* Get type of elements. */
231: if (TYPE_CODE (VALUE_TYPE (arg1)) == TYPE_CODE_ARRAY)
232: type = TYPE_TARGET_TYPE (VALUE_TYPE (arg1));
233: else
234: /* A phony array made by value_repeat.
235: Its type is the type of the elements, not an array type. */
236: type = VALUE_TYPE (arg1);
237:
238: /* Get the type of the result. */
239: type = lookup_pointer_type (type);
240: val = value_from_long (builtin_type_long,
241: VALUE_ADDRESS (arg1) + VALUE_OFFSET (arg1));
242: VALUE_TYPE (val) = type;
243: return val;
244: }
245:
246: /* Return a pointer value for the object for which ARG1 is the contents. */
247:
248: value
249: value_addr (arg1)
250: value arg1;
251: {
252: register struct type *type;
253: register value val, arg1_coerced;
254:
255: /* Taking the address of an array is really a no-op
256: once the array is coerced to a pointer to its first element. */
257: arg1_coerced = arg1;
258: COERCE_ARRAY (arg1_coerced);
259: if (arg1 != arg1_coerced)
260: return arg1_coerced;
261:
262: if (VALUE_LVAL (arg1) != lval_memory)
263: error ("Attempt to take address of value not located in memory.");
264:
265: /* Get the type of the result. */
266: type = lookup_pointer_type (VALUE_TYPE (arg1));
267: val = value_from_long (builtin_type_long,
268: VALUE_ADDRESS (arg1) + VALUE_OFFSET (arg1));
269: VALUE_TYPE (val) = type;
270: return val;
271: }
272:
273: /* Given a value of a pointer type, apply the C unary * operator to it. */
274:
275: value
276: value_ind (arg1)
277: value arg1;
278: {
279: COERCE_ARRAY (arg1);
280:
281: /* Allow * on an integer so we can cast it to whatever we want. */
282: if (TYPE_CODE (VALUE_TYPE (arg1)) == TYPE_CODE_INT)
283: return value_at (builtin_type_long,
284: (CORE_ADDR) value_as_long (arg1));
285: else if (TYPE_CODE (VALUE_TYPE (arg1)) == TYPE_CODE_PTR)
286: return value_at (TYPE_TARGET_TYPE (VALUE_TYPE (arg1)),
287: (CORE_ADDR) value_as_long (arg1));
288: error ("Attempt to take contents of a non-pointer value.");
289: }
290:
291: /* Pushing small parts of stack frames. */
292:
293: /* Push one word (the size of object that a register holds). */
294:
295: CORE_ADDR
296: push_word (sp, buffer)
297: CORE_ADDR sp;
298: REGISTER_TYPE buffer;
299: {
300: register int len = sizeof (REGISTER_TYPE);
301:
302: #if 1 INNER_THAN 2
303: sp -= len;
304: write_memory (sp, &buffer, len);
305: #else /* stack grows upward */
306: write_memory (sp, &buffer, len);
307: sp += len;
308: #endif /* stack grows upward */
309:
310: return sp;
311: }
312:
313: /* Push LEN bytes with data at BUFFER. */
314:
315: CORE_ADDR
316: push_bytes (sp, buffer, len)
317: CORE_ADDR sp;
318: char *buffer;
319: int len;
320: {
321: #if 1 INNER_THAN 2
322: sp -= len;
323: write_memory (sp, buffer, len);
324: #else /* stack grows upward */
325: write_memory (sp, buffer, len);
326: sp += len;
327: #endif /* stack grows upward */
328:
329: return sp;
330: }
331:
332: /* Push onto the stack the specified value VALUE. */
333:
334: CORE_ADDR
335: value_push (sp, arg)
336: register CORE_ADDR sp;
337: value arg;
338: {
339: register int len = TYPE_LENGTH (VALUE_TYPE (arg));
340:
341: #if 1 INNER_THAN 2
342: sp -= len;
343: write_memory (sp, VALUE_CONTENTS (arg), len);
344: #else /* stack grows upward */
345: write_memory (sp, VALUE_CONTENTS (arg), len);
346: sp += len;
347: #endif /* stack grows upward */
348:
349: return sp;
350: }
351:
352: /* Perform the standard coercions that are specified
353: for arguments to be passed to C functions. */
354:
355: value
356: value_arg_coerce (arg)
357: value arg;
358: {
359: register struct type *type;
360:
361: COERCE_ENUM (arg);
362:
363: type = VALUE_TYPE (arg);
364:
365: if (TYPE_CODE (type) == TYPE_CODE_INT
366: && TYPE_LENGTH (type) < sizeof (int))
367: return value_cast (builtin_type_int, arg);
368:
369: if (type == builtin_type_float)
370: return value_cast (builtin_type_double, arg);
371:
372: return arg;
373: }
374:
375: /* Push the value ARG, first coercing it as an argument
376: to a C function. */
377:
378: CORE_ADDR
379: value_arg_push (sp, arg)
380: register CORE_ADDR sp;
381: value arg;
382: {
383: return value_push (sp, value_arg_coerce (arg));
384: }
385:
386: /* Perform a function call in the inferior.
387: ARGS is a vector of values of arguments (NARGS of them).
388: FUNCTION is a value, the function to be called.
389: Returns a value representing what the function returned.
390: May fail to return, if a breakpoint or signal is hit
391: during the execution of the function. */
392:
393: value
394: call_function (function, nargs, args)
395: value function;
396: int nargs;
397: value *args;
398: {
399: register CORE_ADDR sp;
400: register int i;
401: CORE_ADDR start_sp;
402: static REGISTER_TYPE dummy[] = CALL_DUMMY;
403: REGISTER_TYPE dummy1[sizeof dummy / sizeof (REGISTER_TYPE)];
404: CORE_ADDR old_sp;
405: struct type *value_type;
406:
407: PUSH_DUMMY_FRAME;
408:
409: {
410: register CORE_ADDR funaddr;
411: register struct type *ftype = VALUE_TYPE (function);
412: register enum type_code code = TYPE_CODE (ftype);
413:
414: /* Determine address to call. */
415: if (code == TYPE_CODE_FUNC)
416: {
417: funaddr = VALUE_ADDRESS (function);
418: value_type = TYPE_TARGET_TYPE (ftype);
419: }
420: else if (code == TYPE_CODE_PTR)
421: {
422: funaddr = value_as_long (function);
423: if (TYPE_CODE (TYPE_TARGET_TYPE (ftype))
424: == TYPE_CODE_FUNC)
425: value_type = TYPE_TARGET_TYPE (TYPE_TARGET_TYPE (ftype));
426: else
427: value_type = builtin_type_int;
428: }
429: else if (code == TYPE_CODE_INT)
430: {
431: /* Handle the case of functions lacking debugging info.
432: Their values are characters since their addresses are char */
433: if (TYPE_LENGTH (ftype) == 1)
434: funaddr = value_as_long (value_addr (function));
435: else
436: /* Handle integer used as address of a function. */
437: funaddr = value_as_long (function);
438:
439: value_type = builtin_type_int;
440: }
441: else
442: error ("Invalid data type for function to be called.");
443:
444: /* Create a call sequence customized for this function
445: and the number of arguments for it. */
446: bcopy (dummy, dummy1, sizeof dummy);
447: FIX_CALL_DUMMY (dummy1, funaddr, nargs);
448: }
449:
450: old_sp = sp = read_register (SP_REGNUM);
451:
452: #if 1 INNER_THAN 2 /* Stack grows down */
453: sp -= sizeof dummy;
454: write_memory (sp, dummy1, sizeof dummy);
455: start_sp = sp;
456: for (i = nargs - 1; i >= 0; i--)
457: sp = value_arg_push (sp, args[i]);
458: #else /* Stack grows up */
459: start_sp = sp;
460: write_memory (sp, dummy1, sizeof dummy);
461: sp += sizeof dummy;
462: for (i = 0; i < nargs; i++)
463: sp = value_arg_push (sp, args[i]);
464: #endif /* Stack grows up */
465:
466: write_register (SP_REGNUM, sp);
467:
468: /* Figure out the value returned by the function. */
469: {
470: char retbuf[REGISTER_BYTES];
471:
472: /* Execute the stack dummy routine, calling FUNCTION.
473: When it is done, discard the empty frame
474: after storing the contents of all regs into retbuf. */
475: run_stack_dummy (start_sp + CALL_DUMMY_START_OFFSET, retbuf);
476:
477: return value_being_returned (value_type, retbuf);
478: }
479: }
480:
481: /* Create a value for a string constant:
482: Call the function malloc in the inferior to get space for it,
483: then copy the data into that space
484: and then return the address with type char *.
485: PTR points to the string constant data; LEN is number of characters. */
486:
487: value
488: value_string (ptr, len)
489: char *ptr;
490: int len;
491: {
492: register value val;
493: register struct symbol *sym;
494: value blocklen;
495: register char *copy = (char *) alloca (len + 1);
496: char *i = ptr;
497: register char *o = copy, *ibeg = ptr;
498: register int c;
499:
500: /* Copy the string into COPY, processing escapes.
501: We could not conveniently process them in expread
502: because the string there wants to be a substring of the input. */
503:
504: while (i - ibeg < len)
505: {
506: c = *i++;
507: if (c == '\\')
508: {
509: c = parse_escape (&i);
510: if (c == -1)
511: continue;
512: }
513: *o++ = c;
514: }
515: *o = 0;
516:
517: /* Get the length of the string after escapes are processed. */
518:
519: len = o - copy;
520:
521: /* Find the address of malloc in the inferior. */
522:
523: sym = lookup_symbol ("malloc", 0, VAR_NAMESPACE);
524: if (sym != 0)
525: {
526: if (SYMBOL_CLASS (sym) != LOC_BLOCK)
527: error ("\"malloc\" exists in this program but is not a function.");
528: val = value_of_variable (sym);
529: }
530: else
531: {
532: register int i;
533: for (i = 0; i < misc_function_count; i++)
534: if (!strcmp (misc_function_vector[i].name, "malloc"))
535: break;
536: if (i < misc_function_count)
537: val = value_from_long (builtin_type_long,
538: misc_function_vector[i].address);
539: else
540: error ("String constants require the program to have a function \"malloc\".");
541: }
542:
543: blocklen = value_from_long (builtin_type_int, len + 1);
544: val = call_function (val, 1, &blocklen);
545: if (value_zerop (val))
546: error ("No memory available for string constant.");
547: write_memory (value_as_long (val), copy, len + 1);
548: VALUE_TYPE (val) = lookup_pointer_type (builtin_type_char);
549: return val;
550: }
551:
552: /* Given ARG1, a value of type (pointer to a)* structure/union,
553: extract the component named NAME from the ultimate target structure/union
554: and return it as a value with its appropriate type.
555: ERR is used in the error message if ARG1's type is wrong. */
556:
557: value
558: value_struct_elt (arg1, name, err)
559: register value arg1;
560: char *name;
561: char *err;
562: {
563: register struct type *t;
564: register int i;
565:
566: COERCE_ARRAY (arg1);
567:
568: t = VALUE_TYPE (arg1);
569:
570: /* Follow pointers until we get to a non-pointer. */
571:
572: while (TYPE_CODE (t) == TYPE_CODE_PTR)
573: {
574: arg1 = value_ind (arg1);
575: COERCE_ARRAY (arg1);
576: t = VALUE_TYPE (arg1);
577: }
578:
579: if (TYPE_CODE (t) != TYPE_CODE_STRUCT
580: &&
581: TYPE_CODE (t) != TYPE_CODE_UNION)
582: error ("Attempt to extract a component of a value that is not a %s.", err);
583:
584: for (i = TYPE_NFIELDS (t) - 1; i >= 0; i--)
585: {
586: if (!strcmp (TYPE_FIELD_NAME (t, i), name))
587: break;
588: }
589:
590: if (i < 0)
591: error ("Structure has no component named %s.", name);
592:
593: return value_field (arg1, i);
594: }
595:
596: static
597: initialize ()
598: { }
599:
600: END_FILE
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.