diff options
Diffstat (limited to 'gdb/values.c')
| -rw-r--r-- | gdb/values.c | 136 |
1 files changed, 70 insertions, 66 deletions
diff --git a/gdb/values.c b/gdb/values.c index cc90caa..4546622 100644 --- a/gdb/values.c +++ b/gdb/values.c @@ -1,6 +1,6 @@ /* Low level packing and unpacking of values for GDB, the GNU Debugger. - Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, - 1996, 1997, 1998, 1999, 2000 + Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, + 1995, 1996, 1997, 1998, 1999, 2000, 2002. Free Software Foundation, Inc. This file is part of GDB. @@ -41,7 +41,7 @@ void _initialize_values (void); /* Prototypes for local functions. */ -static value_ptr value_headof (value_ptr, struct type *, struct type *); +static struct value *value_headof (struct value *, struct type *, struct type *); static void show_values (char *, int); @@ -59,7 +59,7 @@ static void show_convenience (char *, int); struct value_history_chunk { struct value_history_chunk *next; - value_ptr values[VALUE_HISTORY_CHUNK]; + struct value *values[VALUE_HISTORY_CHUNK]; }; /* Chain of chunks now in use. */ @@ -72,14 +72,14 @@ static int value_history_count; /* Abs number of last entry stored */ (except for those released by calls to release_value) This is so they can be freed after each command. */ -static value_ptr all_values; +static struct value *all_values; /* Allocate a value that has the correct length for type TYPE. */ -value_ptr +struct value * allocate_value (struct type *type) { - register value_ptr val; + struct value *val; struct type *atype = check_typedef (type); val = (struct value *) xmalloc (sizeof (struct value) + TYPE_LENGTH (atype)); @@ -106,7 +106,7 @@ allocate_value (struct type *type) /* Allocate a value that has the correct length for COUNT repetitions type TYPE. */ -value_ptr +struct value * allocate_repeat_value (struct type *type, int count) { int low_bound = current_language->string_lower_bound; /* ??? */ @@ -124,7 +124,7 @@ allocate_repeat_value (struct type *type, int count) /* Return a mark in the value chain. All values allocated after the mark is obtained (except for those released) are subject to being freed if a subsequent value_free_to_mark is passed the mark. */ -value_ptr +struct value * value_mark (void) { return all_values; @@ -133,9 +133,10 @@ value_mark (void) /* Free all values allocated since MARK was obtained by value_mark (except for those released). */ void -value_free_to_mark (value_ptr mark) +value_free_to_mark (struct value *mark) { - value_ptr val, next; + struct value *val; + struct value *next; for (val = all_values; val && val != mark; val = next) { @@ -151,7 +152,8 @@ value_free_to_mark (value_ptr mark) void free_all_values (void) { - register value_ptr val, next; + struct value *val; + struct value *next; for (val = all_values; val; val = next) { @@ -166,9 +168,9 @@ free_all_values (void) so it will not be freed automatically. */ void -release_value (register value_ptr val) +release_value (struct value *val) { - register value_ptr v; + struct value *v; if (all_values == val) { @@ -187,10 +189,11 @@ release_value (register value_ptr val) } /* Release all values up to mark */ -value_ptr -value_release_to_mark (value_ptr mark) +struct value * +value_release_to_mark (struct value *mark) { - value_ptr val, next; + struct value *val; + struct value *next; for (val = next = all_values; next; next = VALUE_NEXT (next)) if (VALUE_NEXT (next) == mark) @@ -207,11 +210,11 @@ value_release_to_mark (value_ptr mark) It contains the same contents, for same memory address, but it's a different block of storage. */ -value_ptr -value_copy (value_ptr arg) +struct value * +value_copy (struct value *arg) { register struct type *encl_type = VALUE_ENCLOSING_TYPE (arg); - register value_ptr val = allocate_value (encl_type); + struct value *val = allocate_value (encl_type); VALUE_TYPE (val) = VALUE_TYPE (arg); VALUE_LVAL (val) = VALUE_LVAL (arg); VALUE_ADDRESS (val) = VALUE_ADDRESS (arg); @@ -243,7 +246,7 @@ value_copy (value_ptr arg) value history index of this new item. */ int -record_latest_value (value_ptr val) +record_latest_value (struct value *val) { int i; @@ -265,7 +268,7 @@ record_latest_value (value_ptr val) i = value_history_count % VALUE_HISTORY_CHUNK; if (i == 0) { - register struct value_history_chunk *new + struct value_history_chunk *new = (struct value_history_chunk *) xmalloc (sizeof (struct value_history_chunk)); memset (new->values, 0, sizeof new->values); @@ -283,10 +286,10 @@ record_latest_value (value_ptr val) /* Return a copy of the value in the history with sequence number NUM. */ -value_ptr +struct value * access_value_history (int num) { - register struct value_history_chunk *chunk; + struct value_history_chunk *chunk; register int i; register int absnum = num; @@ -324,9 +327,9 @@ access_value_history (int num) void clear_value_history (void) { - register struct value_history_chunk *next; + struct value_history_chunk *next; register int i; - register value_ptr val; + struct value *val; while (value_history_chain) { @@ -344,7 +347,7 @@ static void show_values (char *num_exp, int from_tty) { register int i; - register value_ptr val; + struct value *val; static int num = 1; if (num_exp) @@ -415,10 +418,10 @@ lookup_internalvar (char *name) return var; } -value_ptr +struct value * value_of_internalvar (struct internalvar *var) { - register value_ptr val; + struct value *val; #ifdef IS_TRAPPED_INTERNALVAR if (IS_TRAPPED_INTERNALVAR (var->name)) @@ -435,7 +438,7 @@ value_of_internalvar (struct internalvar *var) void set_internalvar_component (struct internalvar *var, int offset, int bitpos, - int bitsize, value_ptr newval) + int bitsize, struct value *newval) { register char *addr = VALUE_CONTENTS (var->value) + offset; @@ -452,9 +455,9 @@ set_internalvar_component (struct internalvar *var, int offset, int bitpos, } void -set_internalvar (struct internalvar *var, value_ptr val) +set_internalvar (struct internalvar *var, struct value *val) { - value_ptr newval; + struct value *newval; #ifdef IS_TRAPPED_INTERNALVAR if (IS_TRAPPED_INTERNALVAR (var->name)) @@ -538,7 +541,7 @@ use \"set\" as in \"set $foo = 5\" to define them.\n"); Does not deallocate the value. */ LONGEST -value_as_long (register value_ptr val) +value_as_long (struct value *val) { /* This coerces arrays and functions, which is necessary (e.g. in disassemble_command). It also dereferences references, which @@ -548,7 +551,7 @@ value_as_long (register value_ptr val) } DOUBLEST -value_as_double (register value_ptr val) +value_as_double (struct value *val) { DOUBLEST foo; int inv; @@ -562,7 +565,7 @@ value_as_double (register value_ptr val) Note that val's type may not actually be a pointer; value_as_long handles all the cases. */ CORE_ADDR -value_as_address (value_ptr val) +value_as_address (struct value *val) { /* Assume a CORE_ADDR can fit in a LONGEST (for now). Not sure whether we want this to be true eventually. */ @@ -784,7 +787,7 @@ unpack_pointer (struct type *type, char *valaddr) /* Get the value of the FIELDN'th field (which must be static) of TYPE. */ -value_ptr +struct value * value_static_field (struct type *type, int fieldno) { CORE_ADDR addr; @@ -836,8 +839,8 @@ value_static_field (struct type *type, int fieldno) than the old enclosing type, you have to allocate more space for the data. The return value is a pointer to the new version of this value structure. */ -value_ptr -value_change_enclosing_type (value_ptr val, struct type *new_encl_type) +struct value * +value_change_enclosing_type (struct value *val, struct type *new_encl_type) { if (TYPE_LENGTH (new_encl_type) <= TYPE_LENGTH (VALUE_ENCLOSING_TYPE (val))) { @@ -846,10 +849,10 @@ value_change_enclosing_type (value_ptr val, struct type *new_encl_type) } else { - value_ptr new_val; - register value_ptr prev; + struct value *new_val; + struct value *prev; - new_val = (value_ptr) xrealloc (val, sizeof (struct value) + TYPE_LENGTH (new_encl_type)); + new_val = (struct value *) xrealloc (val, sizeof (struct value) + TYPE_LENGTH (new_encl_type)); /* We have to make sure this ends up in the same place in the value chain as the original copy, so it's clean-up behavior is the same. @@ -877,11 +880,11 @@ value_change_enclosing_type (value_ptr val, struct type *new_encl_type) extract and return the value of one of its (non-static) fields. FIELDNO says which field. */ -value_ptr -value_primitive_field (register value_ptr arg1, int offset, +struct value * +value_primitive_field (struct value *arg1, int offset, register int fieldno, register struct type *arg_type) { - register value_ptr v; + struct value *v; register struct type *type; CHECK_TYPEDEF (arg_type); @@ -947,8 +950,8 @@ value_primitive_field (register value_ptr arg1, int offset, extract and return the value of one of its (non-static) fields. FIELDNO says which field. */ -value_ptr -value_field (register value_ptr arg1, register int fieldno) +struct value * +value_field (struct value *arg1, register int fieldno) { return value_primitive_field (arg1, 0, fieldno, VALUE_TYPE (arg1)); } @@ -961,11 +964,11 @@ value_field (register value_ptr arg1, register int fieldno) full symbol or a minimal symbol. */ -value_ptr -value_fn_field (value_ptr *arg1p, struct fn_field *f, int j, struct type *type, +struct value * +value_fn_field (struct value **arg1p, struct fn_field *f, int j, struct type *type, int offset) { - register value_ptr v; + struct value *v; register struct type *ftype = TYPE_FN_FIELD_TYPE (f, j); char *physname = TYPE_FN_FIELD_PHYSNAME (f, j); struct symbol *sym; @@ -1022,11 +1025,12 @@ value_fn_field (value_ptr *arg1p, struct fn_field *f, int j, struct type *type, by value_rtti_type efficiently. Consider it gone for 5.1. */ -static value_ptr -value_headof (value_ptr in_arg, struct type *btype, struct type *dtype) +static struct value * +value_headof (struct value *in_arg, struct type *btype, struct type *dtype) { /* First collect the vtables we must look at for this object. */ - value_ptr arg, vtbl; + struct value *arg; + struct value *vtbl; struct symbol *sym; char *demangled_name; struct minimal_symbol *msymbol; @@ -1083,8 +1087,8 @@ value_headof (value_ptr in_arg, struct type *btype, struct type *dtype) of its baseclasses) to figure out the most derived type that ARG could actually be a pointer to. */ -value_ptr -value_from_vtable_info (value_ptr arg, struct type *type) +struct value * +value_from_vtable_info (struct value *arg, struct type *type) { /* Take care of preliminaries. */ if (TYPE_VPTR_FIELDNO (type) < 0) @@ -1290,10 +1294,10 @@ modify_field (char *addr, LONGEST fieldval, int bitpos, int bitsize) /* Convert C numbers into newly allocated values */ -value_ptr +struct value * value_from_longest (struct type *type, register LONGEST num) { - register value_ptr val = allocate_value (type); + struct value *val = allocate_value (type); register enum type_code code; register int len; retry: @@ -1327,10 +1331,10 @@ retry: /* Create a value representing a pointer of type TYPE to the address ADDR. */ -value_ptr +struct value * value_from_pointer (struct type *type, CORE_ADDR addr) { - value_ptr val = allocate_value (type); + struct value *val = allocate_value (type); store_typed_address (VALUE_CONTENTS_RAW (val), type, addr); return val; } @@ -1341,10 +1345,10 @@ value_from_pointer (struct type *type, CORE_ADDR addr) This is analogous to value_from_longest, which also does not use inferior memory. String shall NOT contain embedded nulls. */ -value_ptr +struct value * value_from_string (char *ptr) { - value_ptr val; + struct value *val; int len = strlen (ptr); int lowbound = current_language->string_lower_bound; struct type *rangetype = @@ -1361,10 +1365,10 @@ value_from_string (char *ptr) return val; } -value_ptr +struct value * value_from_double (struct type *type, DOUBLEST num) { - register value_ptr val = allocate_value (type); + struct value *val = allocate_value (type); struct type *base_type = check_typedef (type); register enum type_code code = TYPE_CODE (base_type); register int len = TYPE_LENGTH (base_type); @@ -1394,10 +1398,10 @@ value_from_double (struct type *type, DOUBLEST num) means returning pointer to where structure is vs. returning value). */ /* ARGSUSED */ -value_ptr +struct value * value_being_returned (struct type *valtype, char *retbuf, int struct_return) { - register value_ptr val; + struct value *val; CORE_ADDR addr; /* If this is not defined, just use EXTRACT_RETURN_VALUE instead. */ @@ -1451,7 +1455,7 @@ generic_use_struct_convention (int gcc_p, struct type *value_type) /* ARGSUSED */ int -using_struct_return (value_ptr function, CORE_ADDR funcaddr, +using_struct_return (struct value *function, CORE_ADDR funcaddr, struct type *value_type, int gcc_p) { register enum type_code code = TYPE_CODE (value_type); @@ -1473,7 +1477,7 @@ using_struct_return (value_ptr function, CORE_ADDR funcaddr, function wants to return. */ void -set_return_value (value_ptr val) +set_return_value (struct value *val) { struct type *type = check_typedef (VALUE_TYPE (val)); register enum type_code code = TYPE_CODE (type); |