value operations with HP aCC code/runtime. */
extern int hp_som_som_object_present;
-
+extern int overload_debug;
/* Local functions. */
-static int typecmp PARAMS ((int staticp, struct type * t1[], value_ptr t2[]));
+static int typecmp (int staticp, struct type *t1[], value_ptr t2[]);
-static CORE_ADDR find_function_addr PARAMS ((value_ptr, struct type **));
-static value_ptr value_arg_coerce PARAMS ((value_ptr, struct type *, int));
+static CORE_ADDR find_function_addr (value_ptr, struct type **);
+static value_ptr value_arg_coerce (value_ptr, struct type *, int);
-static CORE_ADDR value_push PARAMS ((CORE_ADDR, value_ptr));
+static CORE_ADDR value_push (CORE_ADDR, value_ptr);
-static value_ptr search_struct_field PARAMS ((char *, value_ptr, int,
- struct type *, int));
+static value_ptr search_struct_field (char *, value_ptr, int,
+ struct type *, int);
-static value_ptr search_struct_method PARAMS ((char *, value_ptr *,
- value_ptr *,
- int, int *, struct type *));
+static value_ptr search_struct_method (char *, value_ptr *,
+ value_ptr *,
+ int, int *, struct type *);
-static int check_field_in PARAMS ((struct type *, const char *));
+static int check_field_in (struct type *, const char *);
-static CORE_ADDR allocate_space_in_inferior PARAMS ((int));
+static CORE_ADDR allocate_space_in_inferior (int);
-static value_ptr cast_into_complex PARAMS ((struct type *, value_ptr));
+static value_ptr cast_into_complex (struct type *, value_ptr);
-static struct fn_field *find_method_list PARAMS ((value_ptr * argp, char *method, int offset, int *static_memfuncp, struct type * type, int *num_fns, struct type ** basetype, int *boffset));
+static struct fn_field *find_method_list (value_ptr * argp, char *method,
+ int offset, int *static_memfuncp,
+ struct type *type, int *num_fns,
+ struct type **basetype,
+ int *boffset);
-void _initialize_valops PARAMS ((void));
+void _initialize_valops (void);
#define VALUE_SUBSTRING_START(VAL) VALUE_FRAME(VAL)
/* Find the address of function name NAME in the inferior. */
value_ptr
-find_function_in_inferior (name)
- char *name;
+find_function_in_inferior (char *name)
{
register struct symbol *sym;
sym = lookup_symbol (name, 0, VAR_NAMESPACE, 0, NULL);
if (msymbol != NULL)
{
struct type *type;
- LONGEST maddr;
+ CORE_ADDR maddr;
type = lookup_pointer_type (builtin_type_char);
type = lookup_function_type (type);
type = lookup_pointer_type (type);
- maddr = (LONGEST) SYMBOL_VALUE_ADDRESS (msymbol);
- return value_from_longest (type, maddr);
+ maddr = SYMBOL_VALUE_ADDRESS (msymbol);
+ return value_from_pointer (type, maddr);
}
else
{
and return a value that is a pointer to the allocated space. */
value_ptr
-value_allocate_space_in_inferior (len)
- int len;
+value_allocate_space_in_inferior (int len)
{
value_ptr blocklen;
register value_ptr val = find_function_in_inferior ("malloc");
}
static CORE_ADDR
-allocate_space_in_inferior (len)
- int len;
+allocate_space_in_inferior (int len)
{
return value_as_long (value_allocate_space_in_inferior (len));
}
/* In C++, casts may change pointer or object representations. */
value_ptr
-value_cast (type, arg2)
- struct type *type;
- register value_ptr arg2;
+value_cast (struct type *type, register value_ptr arg2)
{
register enum type_code code1;
register enum type_code code2;
/* With HP aCC, pointers to data members have a bias */
case TYPE_CODE_MEMBER:
retvalp = value_from_longest (type, value_as_long (arg2));
- ptr = (unsigned int *) VALUE_CONTENTS (retvalp); /* force evaluation */
+ /* force evaluation */
+ ptr = (unsigned int *) VALUE_CONTENTS (retvalp);
*ptr &= ~0x20000000; /* zap 29th bit to remove bias */
return retvalp;
}
}
longest = value_as_long (arg2);
- return value_from_longest (type, convert_to_boolean ? (LONGEST) (longest ? 1 : 0) : longest);
+ return value_from_longest (type, convert_to_boolean ?
+ (LONGEST) (longest ? 1 : 0) : longest);
+ }
+ else if (code1 == TYPE_CODE_PTR && (code2 == TYPE_CODE_INT ||
+ code2 == TYPE_CODE_ENUM ||
+ code2 == TYPE_CODE_RANGE))
+ {
+ int ptr_bit = HOST_CHAR_BIT * TYPE_LENGTH (type);
+ LONGEST longest = value_as_long (arg2);
+ if (ptr_bit < sizeof (LONGEST) * HOST_CHAR_BIT)
+ {
+ if (longest >= ((LONGEST) 1 << ptr_bit)
+ || longest <= -((LONGEST) 1 << ptr_bit))
+ warning ("value truncated");
+ }
+ return value_from_longest (type, longest);
}
else if (TYPE_LENGTH (type) == TYPE_LENGTH (type2))
{
value_ptr v2 = value_ind (arg2);
VALUE_ADDRESS (v2) -= VALUE_ADDRESS (v)
+ VALUE_OFFSET (v);
+
+ /* JYG: adjust the new pointer value and
+ embedded offset. */
+ v2->aligner.contents[0] -= VALUE_EMBEDDED_OFFSET (v);
+ VALUE_EMBEDDED_OFFSET (v2) = 0;
+
v2 = value_addr (v2);
VALUE_TYPE (v2) = type;
return v2;
/* Create a value of type TYPE that is zero, and return it. */
value_ptr
-value_zero (type, lv)
- struct type *type;
- enum lval_type lv;
+value_zero (struct type *type, enum lval_type lv)
{
register value_ptr val = allocate_value (type);
return val;
}
-/* Return a value with type TYPE located at ADDR.
+/* Return a value with type TYPE located at ADDR.
Call value_at only if the data needs to be fetched immediately;
if we can be 'lazy' and defer the fetch, perhaps indefinately, call
value_at_lazy instead. value_at_lazy simply records the address of
- the data and sets the lazy-evaluation-required flag. The lazy flag
- is tested in the VALUE_CONTENTS macro, which is used if and when
- the contents are actually required.
+ the data and sets the lazy-evaluation-required flag. The lazy flag
+ is tested in the VALUE_CONTENTS macro, which is used if and when
+ the contents are actually required.
Note: value_at does *NOT* handle embedded offsets; perform such
adjustments before or after calling it. */
value_ptr
-value_at (type, addr, sect)
- struct type *type;
- CORE_ADDR addr;
- asection *sect;
+value_at (struct type *type, CORE_ADDR addr, asection *sect)
{
register value_ptr val;
store_address (VALUE_CONTENTS_RAW (val), 4, num);
}
else
- read_memory_section (addr, VALUE_CONTENTS_ALL_RAW (val), TYPE_LENGTH (type), sect);
+ read_memory (addr, VALUE_CONTENTS_ALL_RAW (val), TYPE_LENGTH (type));
VALUE_LVAL (val) = lval_memory;
VALUE_ADDRESS (val) = addr;
/* Return a lazy value with type TYPE located at ADDR (cf. value_at). */
value_ptr
-value_at_lazy (type, addr, sect)
- struct type *type;
- CORE_ADDR addr;
- asection *sect;
+value_at_lazy (struct type *type, CORE_ADDR addr, asection *sect)
{
register value_ptr val;
return val;
}
-/* Called only from the VALUE_CONTENTS and VALUE_CONTENTS_ALL macros,
- if the current data for a variable needs to be loaded into
- VALUE_CONTENTS(VAL). Fetches the data from the user's process, and
+/* Called only from the VALUE_CONTENTS and VALUE_CONTENTS_ALL macros,
+ if the current data for a variable needs to be loaded into
+ VALUE_CONTENTS(VAL). Fetches the data from the user's process, and
clears the lazy flag to indicate that the data in the buffer is valid.
If the value is zero-length, we avoid calling read_memory, which would
value is ignored. */
int
-value_fetch_lazy (val)
- register value_ptr val;
+value_fetch_lazy (register value_ptr val)
{
CORE_ADDR addr = VALUE_ADDRESS (val) + VALUE_OFFSET (val);
int length = TYPE_LENGTH (VALUE_ENCLOSING_TYPE (val));
store_address (VALUE_CONTENTS_RAW (val), 4, num);
}
else if (length)
- read_memory_section (addr, VALUE_CONTENTS_ALL_RAW (val), length,
- VALUE_BFD_SECTION (val));
+ read_memory (addr, VALUE_CONTENTS_ALL_RAW (val), length);
+
VALUE_LAZY (val) = 0;
return 0;
}
Return a new value with the location of TOVAL and contents of FROMVAL. */
value_ptr
-value_assign (toval, fromval)
- register value_ptr toval, fromval;
+value_assign (register value_ptr toval, register value_ptr fromval)
{
register struct type *type;
register value_ptr val;
if (VALUE_BITSIZE (toval))
{
char buffer[sizeof (LONGEST)];
- int len = REGISTER_RAW_SIZE (VALUE_REGNO (toval));
+ int len =
+ REGISTER_RAW_SIZE (VALUE_REGNO (toval)) - VALUE_OFFSET (toval);
if (len > (int) sizeof (LONGEST))
error ("Can't handle bitfields in registers larger than %d bits.",
/* Extend a value VAL to COUNT repetitions of its type. */
value_ptr
-value_repeat (arg1, count)
- value_ptr arg1;
- int count;
+value_repeat (value_ptr arg1, int count)
{
register value_ptr val;
}
value_ptr
-value_of_variable (var, b)
- struct symbol *var;
- struct block *b;
+value_of_variable (struct symbol *var, struct block *b)
{
value_ptr val;
struct frame_info *frame = NULL;
*/
value_ptr
-value_coerce_array (arg1)
- value_ptr arg1;
+value_coerce_array (value_ptr arg1)
{
register struct type *type = check_typedef (VALUE_TYPE (arg1));
if (VALUE_LVAL (arg1) != lval_memory)
error ("Attempt to take address of value not located in memory.");
- return value_from_longest (lookup_pointer_type (TYPE_TARGET_TYPE (type)),
- (LONGEST) (VALUE_ADDRESS (arg1) + VALUE_OFFSET (arg1)));
+ return value_from_pointer (lookup_pointer_type (TYPE_TARGET_TYPE (type)),
+ (VALUE_ADDRESS (arg1) + VALUE_OFFSET (arg1)));
}
/* Given a value which is a function, return a value which is a pointer
to it. */
value_ptr
-value_coerce_function (arg1)
- value_ptr arg1;
+value_coerce_function (value_ptr arg1)
{
value_ptr retval;
if (VALUE_LVAL (arg1) != lval_memory)
error ("Attempt to take address of value not located in memory.");
- retval = value_from_longest (lookup_pointer_type (VALUE_TYPE (arg1)),
- (LONGEST) (VALUE_ADDRESS (arg1) + VALUE_OFFSET (arg1)));
+ retval = value_from_pointer (lookup_pointer_type (VALUE_TYPE (arg1)),
+ (VALUE_ADDRESS (arg1) + VALUE_OFFSET (arg1)));
VALUE_BFD_SECTION (retval) = VALUE_BFD_SECTION (arg1);
return retval;
}
/* Return a pointer value for the object for which ARG1 is the contents. */
value_ptr
-value_addr (arg1)
- value_ptr arg1;
+value_addr (value_ptr arg1)
{
value_ptr arg2;
error ("Attempt to take address of value not located in memory.");
/* Get target memory address */
- arg2 = value_from_longest (lookup_pointer_type (VALUE_TYPE (arg1)),
- (LONGEST) (VALUE_ADDRESS (arg1)
- + VALUE_OFFSET (arg1)
- + VALUE_EMBEDDED_OFFSET (arg1)));
+ arg2 = value_from_pointer (lookup_pointer_type (VALUE_TYPE (arg1)),
+ (VALUE_ADDRESS (arg1)
+ + VALUE_OFFSET (arg1)
+ + VALUE_EMBEDDED_OFFSET (arg1)));
/* This may be a pointer to a base subobject; so remember the
full derived object's type ... */
/* Given a value of a pointer type, apply the C unary * operator to it. */
value_ptr
-value_ind (arg1)
- value_ptr arg1;
+value_ind (value_ptr arg1)
{
struct type *base_type;
value_ptr arg2;
/* Push one word (the size of object that a register holds). */
CORE_ADDR
-push_word (sp, word)
- CORE_ADDR sp;
- ULONGEST word;
+push_word (CORE_ADDR sp, ULONGEST word)
{
register int len = REGISTER_SIZE;
char buffer[MAX_REGISTER_RAW_SIZE];
/* Push LEN bytes with data at BUFFER. */
CORE_ADDR
-push_bytes (sp, buffer, len)
- CORE_ADDR sp;
- char *buffer;
- int len;
+push_bytes (CORE_ADDR sp, char *buffer, int len)
{
if (INNER_THAN (1, 2))
{
it to be an argument to a function. */
static CORE_ADDR
-value_push (sp, arg)
- register CORE_ADDR sp;
- value_ptr arg;
+value_push (register CORE_ADDR sp, value_ptr arg)
{
register int len = TYPE_LENGTH (VALUE_ENCLOSING_TYPE (arg));
register int container_len = len;
#endif
CORE_ADDR
-default_push_arguments (nargs, args, sp, struct_return, struct_addr)
- int nargs;
- value_ptr *args;
- CORE_ADDR sp;
- int struct_return;
- CORE_ADDR struct_addr;
+default_push_arguments (int nargs, value_ptr *args, CORE_ADDR sp,
+ int struct_return, CORE_ADDR struct_addr)
{
/* ASSERT ( !struct_return); */
int i;
}
-/* If we're calling a function declared without a prototype, should we
- promote floats to doubles? FORMAL and ACTUAL are the types of the
- arguments; FORMAL may be NULL.
-
- If we have no definition for this macro, either from the target or
- from gdbarch, provide a default. */
-#ifndef COERCE_FLOAT_TO_DOUBLE
-#define COERCE_FLOAT_TO_DOUBLE(formal, actual) \
- (default_coerce_float_to_double ((formal), (actual)))
-#endif
-
-
/* A default function for COERCE_FLOAT_TO_DOUBLE: do the coercion only
when we don't have any type for the argument at hand. This occurs
when we have no debug info, or when passing varargs.
IS_PROTOTYPED is non-zero if the function declaration is prototyped. */
static value_ptr
-value_arg_coerce (arg, param_type, is_prototyped)
- value_ptr arg;
- struct type *param_type;
- int is_prototyped;
+value_arg_coerce (value_ptr arg, struct type *param_type, int is_prototyped)
{
register struct type *arg_type = check_typedef (VALUE_TYPE (arg));
register struct type *type
return value_cast (type, arg);
}
-/* Determine a function's address and its return type from its value.
+/* Determine a function's address and its return type from its value.
Calls error() if the function is not valid for calling. */
static CORE_ADDR
-find_function_addr (function, retval_type)
- value_ptr function;
- struct type **retval_type;
+find_function_addr (value_ptr function, struct type **retval_type)
{
register struct type *ftype = check_typedef (VALUE_TYPE (function));
register enum type_code code = TYPE_CODE (ftype);
if (TYPE_CODE (ftype) == TYPE_CODE_FUNC
|| TYPE_CODE (ftype) == TYPE_CODE_METHOD)
{
-#ifdef CONVERT_FROM_FUNC_PTR_ADDR
- /* FIXME: This is a workaround for the unusual function
- pointer representation on the RS/6000, see comment
- in config/rs6000/tm-rs6000.h */
funaddr = CONVERT_FROM_FUNC_PTR_ADDR (funaddr);
-#endif
value_type = TYPE_TARGET_TYPE (ftype);
}
else
ARGS is modified to contain coerced values. */
-static value_ptr hand_function_call PARAMS ((value_ptr function, int nargs, value_ptr * args));
+static value_ptr hand_function_call (value_ptr function, int nargs,
+ value_ptr * args);
static value_ptr
-hand_function_call (function, nargs, args)
- value_ptr function;
- int nargs;
- value_ptr *args;
+hand_function_call (value_ptr function, int nargs, value_ptr *args)
{
register CORE_ADDR sp;
register int i;
/* CALL_DUMMY is an array of words (REGISTER_SIZE), but each word
is in host byte order. Before calling FIX_CALL_DUMMY, we byteswap it
and remove any extra bytes which might exist because ULONGEST is
- bigger than REGISTER_SIZE.
+ bigger than REGISTER_SIZE.
NOTE: This is pretty wierd, as the call dummy is actually a
sequence of instructions. But CISC machines will have
noprocess ();
inf_status = save_inferior_status (1);
- old_chain = make_cleanup ((make_cleanup_func) restore_inferior_status,
- inf_status);
+ old_chain = make_cleanup_restore_inferior_status (inf_status);
/* PUSH_DUMMY_FRAME is responsible for saving the inferior registers
(and POP_FRAME for restoring them). (At least on most machines)
args[i] = value_arg_coerce (args[i], param_type, is_prototyped);
}
- /*elz: this code is to handle the case in which the function to be called
- has a pointer to function as parameter and the corresponding actual argument
+ /*elz: this code is to handle the case in which the function to be called
+ has a pointer to function as parameter and the corresponding actual argument
is the address of a function and not a pointer to function variable.
In aCC compiled code, the calls through pointers to functions (in the body
of the function called by hand) are made via $$dyncall_external which
- requires some registers setting, this is taken care of if we call
- via a function pointer variable, but not via a function address.
+ requires some registers setting, this is taken care of if we call
+ via a function pointer variable, but not via a function address.
In cc this is not a problem. */
if (using_gcc == 0)
/* if this parameter is a pointer to function */
if (TYPE_CODE (param_type) == TYPE_CODE_PTR)
if (TYPE_CODE (param_type->target_type) == TYPE_CODE_FUNC)
- /* elz: FIXME here should go the test about the compiler used
+ /* elz: FIXME here should go the test about the compiler used
to compile the target. We want to issue the error
- message only if the compiler used was HP's aCC.
- If we used HP's cc, then there is no problem and no need
+ message only if the compiler used was HP's aCC.
+ If we used HP's cc, then there is no problem and no need
to return at this point */
if (using_gcc == 0) /* && compiler == aCC */
/* go see if the actual parameter is a variable of type
}
}
-#if defined (REG_STRUCT_HAS_ADDR)
- {
- /* This is a machine like the sparc, where we may need to pass a pointer
- to the structure, not the structure itself. */
- for (i = nargs - 1; i >= 0; i--)
- {
- struct type *arg_type = check_typedef (VALUE_TYPE (args[i]));
- if ((TYPE_CODE (arg_type) == TYPE_CODE_STRUCT
- || TYPE_CODE (arg_type) == TYPE_CODE_UNION
- || TYPE_CODE (arg_type) == TYPE_CODE_ARRAY
- || TYPE_CODE (arg_type) == TYPE_CODE_STRING
- || TYPE_CODE (arg_type) == TYPE_CODE_BITSTRING
- || TYPE_CODE (arg_type) == TYPE_CODE_SET
- || (TYPE_CODE (arg_type) == TYPE_CODE_FLT
- && TYPE_LENGTH (arg_type) > 8)
- )
- && REG_STRUCT_HAS_ADDR (using_gcc, arg_type))
- {
- CORE_ADDR addr;
- int len; /* = TYPE_LENGTH (arg_type); */
- int aligned_len;
- arg_type = check_typedef (VALUE_ENCLOSING_TYPE (args[i]));
- len = TYPE_LENGTH (arg_type);
-
-#ifdef STACK_ALIGN
- /* MVS 11/22/96: I think at least some of this stack_align code is
- really broken. Better to let PUSH_ARGUMENTS adjust the stack in
- a target-defined manner. */
- aligned_len = STACK_ALIGN (len);
-#else
- aligned_len = len;
-#endif
- if (INNER_THAN (1, 2))
- {
- /* stack grows downward */
- sp -= aligned_len;
- }
- else
- {
- /* The stack grows up, so the address of the thing we push
- is the stack pointer before we push it. */
- addr = sp;
- }
- /* Push the structure. */
- write_memory (sp, VALUE_CONTENTS_ALL (args[i]), len);
- if (INNER_THAN (1, 2))
- {
- /* The stack grows down, so the address of the thing we push
- is the stack pointer after we push it. */
- addr = sp;
- }
- else
- {
- /* stack grows upward */
- sp += aligned_len;
- }
- /* The value we're going to pass is the address of the thing
- we just pushed. */
- /*args[i] = value_from_longest (lookup_pointer_type (value_type),
- (LONGEST) addr); */
- args[i] = value_from_longest (lookup_pointer_type (arg_type),
- (LONGEST) addr);
- }
- }
- }
-#endif /* REG_STRUCT_HAS_ADDR. */
+ if (REG_STRUCT_HAS_ADDR_P ())
+ {
+ /* This is a machine like the sparc, where we may need to pass a
+ pointer to the structure, not the structure itself. */
+ for (i = nargs - 1; i >= 0; i--)
+ {
+ struct type *arg_type = check_typedef (VALUE_TYPE (args[i]));
+ if ((TYPE_CODE (arg_type) == TYPE_CODE_STRUCT
+ || TYPE_CODE (arg_type) == TYPE_CODE_UNION
+ || TYPE_CODE (arg_type) == TYPE_CODE_ARRAY
+ || TYPE_CODE (arg_type) == TYPE_CODE_STRING
+ || TYPE_CODE (arg_type) == TYPE_CODE_BITSTRING
+ || TYPE_CODE (arg_type) == TYPE_CODE_SET
+ || (TYPE_CODE (arg_type) == TYPE_CODE_FLT
+ && TYPE_LENGTH (arg_type) > 8)
+ )
+ && REG_STRUCT_HAS_ADDR (using_gcc, arg_type))
+ {
+ CORE_ADDR addr;
+ int len; /* = TYPE_LENGTH (arg_type); */
+ int aligned_len;
+ arg_type = check_typedef (VALUE_ENCLOSING_TYPE (args[i]));
+ len = TYPE_LENGTH (arg_type);
+
+ if (STACK_ALIGN_P ())
+ /* MVS 11/22/96: I think at least some of this
+ stack_align code is really broken. Better to let
+ PUSH_ARGUMENTS adjust the stack in a target-defined
+ manner. */
+ aligned_len = STACK_ALIGN (len);
+ else
+ aligned_len = len;
+ if (INNER_THAN (1, 2))
+ {
+ /* stack grows downward */
+ sp -= aligned_len;
+ }
+ else
+ {
+ /* The stack grows up, so the address of the thing
+ we push is the stack pointer before we push it. */
+ addr = sp;
+ }
+ /* Push the structure. */
+ write_memory (sp, VALUE_CONTENTS_ALL (args[i]), len);
+ if (INNER_THAN (1, 2))
+ {
+ /* The stack grows down, so the address of the thing
+ we push is the stack pointer after we push it. */
+ addr = sp;
+ }
+ else
+ {
+ /* stack grows upward */
+ sp += aligned_len;
+ }
+ /* The value we're going to pass is the address of the
+ thing we just pushed. */
+ /*args[i] = value_from_longest (lookup_pointer_type (value_type),
+ (LONGEST) addr); */
+ args[i] = value_from_pointer (lookup_pointer_type (arg_type),
+ addr);
+ }
+ }
+ }
+
/* Reserve space for the return structure to be written on the
stack, if necessary */
if (struct_return)
{
int len = TYPE_LENGTH (value_type);
-#ifdef STACK_ALIGN
- /* MVS 11/22/96: I think at least some of this stack_align code is
- really broken. Better to let PUSH_ARGUMENTS adjust the stack in
- a target-defined manner. */
- len = STACK_ALIGN (len);
-#endif
+ if (STACK_ALIGN_P ())
+ /* MVS 11/22/96: I think at least some of this stack_align
+ code is really broken. Better to let PUSH_ARGUMENTS adjust
+ the stack in a target-defined manner. */
+ len = STACK_ALIGN (len);
if (INNER_THAN (1, 2))
{
/* stack grows downward */
}
}
-/* elz: on HPPA no need for this extra alignment, maybe it is needed
- on other architectures. This is because all the alignment is taken care
- of in the above code (ifdef REG_STRUCT_HAS_ADDR) and in
- hppa_push_arguments */
-#ifndef NO_EXTRA_ALIGNMENT_NEEDED
-
-#if defined(STACK_ALIGN)
- /* MVS 11/22/96: I think at least some of this stack_align code is
- really broken. Better to let PUSH_ARGUMENTS adjust the stack in
- a target-defined manner. */
- if (INNER_THAN (1, 2))
+ /* elz: on HPPA no need for this extra alignment, maybe it is needed
+ on other architectures. This is because all the alignment is
+ taken care of in the above code (ifdef REG_STRUCT_HAS_ADDR) and
+ in hppa_push_arguments */
+ if (EXTRA_STACK_ALIGNMENT_NEEDED)
{
- /* If stack grows down, we must leave a hole at the top. */
- int len = 0;
-
- for (i = nargs - 1; i >= 0; i--)
- len += TYPE_LENGTH (VALUE_ENCLOSING_TYPE (args[i]));
- if (CALL_DUMMY_STACK_ADJUST_P)
- len += CALL_DUMMY_STACK_ADJUST;
- sp -= STACK_ALIGN (len) - len;
+ /* MVS 11/22/96: I think at least some of this stack_align code
+ is really broken. Better to let PUSH_ARGUMENTS adjust the
+ stack in a target-defined manner. */
+ if (STACK_ALIGN_P () && INNER_THAN (1, 2))
+ {
+ /* If stack grows down, we must leave a hole at the top. */
+ int len = 0;
+
+ for (i = nargs - 1; i >= 0; i--)
+ len += TYPE_LENGTH (VALUE_ENCLOSING_TYPE (args[i]));
+ if (CALL_DUMMY_STACK_ADJUST_P)
+ len += CALL_DUMMY_STACK_ADJUST;
+ sp -= STACK_ALIGN (len) - len;
+ }
}
-#endif /* STACK_ALIGN */
-#endif /* NO_EXTRA_ALIGNMENT_NEEDED */
sp = PUSH_ARGUMENTS (nargs, args, sp, struct_return, struct_addr);
function. Since this doesn't actually involve executing a JSR/BSR
instruction, the return address must be set up by hand, either by
pushing onto the stack or copying into a return-address register
- as appropriate. Formerly this has been done in PUSH_ARGUMENTS,
+ as appropriate. Formerly this has been done in PUSH_ARGUMENTS,
but that's overloading its functionality a bit, so I'm making it
explicit to do it here. */
sp = PUSH_RETURN_ADDRESS (real_pc, sp);
#endif /* PUSH_RETURN_ADDRESS */
-#if defined(STACK_ALIGN)
- if (!INNER_THAN (1, 2))
+ if (STACK_ALIGN_P () && !INNER_THAN (1, 2))
{
/* If stack grows up, we must leave a hole at the bottom, note
that sp already has been advanced for the arguments! */
sp += CALL_DUMMY_STACK_ADJUST;
sp = STACK_ALIGN (sp);
}
-#endif /* STACK_ALIGN */
/* XXX This seems wrong. For stacks that grow down we shouldn't do
anything here! */
it doesn't cost us anything but space and if the function is pcc
it will ignore this value, we will make that assumption.
- Also note that on some machines (like the sparc) pcc uses a
+ Also note that on some machines (like the sparc) pcc uses a
convention like gcc's. */
if (struct_return)
wouldn't happen. (See store_inferior_registers in sparc-nat.c.) */
write_sp (sp);
-#ifdef SAVE_DUMMY_FRAME_TOS
- SAVE_DUMMY_FRAME_TOS (sp);
-#endif
+ if (SAVE_DUMMY_FRAME_TOS_P ())
+ SAVE_DUMMY_FRAME_TOS (sp);
{
char retbuf[REGISTER_BYTES];
}
value_ptr
-call_function_by_hand (function, nargs, args)
- value_ptr function;
- int nargs;
- value_ptr *args;
+call_function_by_hand (value_ptr function, int nargs, value_ptr *args)
{
if (CALL_DUMMY_P)
{
don't currently enforce any restriction on their types). */
value_ptr
-value_array (lowbound, highbound, elemvec)
- int lowbound;
- int highbound;
- value_ptr *elemvec;
+value_array (int lowbound, int highbound, value_ptr *elemvec)
{
int nelem;
int idx;
embedded null bytes. */
value_ptr
-value_string (ptr, len)
- char *ptr;
- int len;
+value_string (char *ptr, int len)
{
value_ptr val;
int lowbound = current_language->string_lower_bound;
}
value_ptr
-value_bitstring (ptr, len)
- char *ptr;
- int len;
+value_bitstring (char *ptr, int len)
{
value_ptr val;
struct type *domain_type = create_range_type (NULL, builtin_type_int,
requested operation is type secure, shouldn't we? FIXME. */
static int
-typecmp (staticp, t1, t2)
- int staticp;
- struct type *t1[];
- value_ptr t2[];
+typecmp (int staticp, struct type *t1[], value_ptr t2[])
{
int i;
continue;
}
- while (TYPE_CODE (tt1) == TYPE_CODE_PTR
- && (TYPE_CODE (tt2) == TYPE_CODE_ARRAY
- || TYPE_CODE (tt2) == TYPE_CODE_PTR))
+ /* djb - 20000715 - Until the new type structure is in the
+ place, and we can attempt things like implicit conversions,
+ we need to do this so you can take something like a map<const
+ char *>, and properly access map["hello"], because the
+ argument to [] will be a reference to a pointer to a char,
+ and the argument will be a pointer to a char. */
+ while ( TYPE_CODE(tt1) == TYPE_CODE_REF ||
+ TYPE_CODE (tt1) == TYPE_CODE_PTR)
{
- tt1 = check_typedef (TYPE_TARGET_TYPE (tt1));
- tt2 = check_typedef (TYPE_TARGET_TYPE (tt2));
+ tt1 = check_typedef( TYPE_TARGET_TYPE(tt1) );
+ }
+ while ( TYPE_CODE(tt2) == TYPE_CODE_ARRAY ||
+ TYPE_CODE(tt2) == TYPE_CODE_PTR ||
+ TYPE_CODE(tt2) == TYPE_CODE_REF)
+ {
+ tt2 = check_typedef( TYPE_TARGET_TYPE(tt2) );
}
if (TYPE_CODE (tt1) == TYPE_CODE (tt2))
continue;
look for a baseclass named NAME. */
static value_ptr
-search_struct_field (name, arg1, offset, type, looking_for_baseclass)
- char *name;
- register value_ptr arg1;
- int offset;
- register struct type *type;
- int looking_for_baseclass;
+search_struct_field (char *name, register value_ptr arg1, int offset,
+ register struct type *type, int looking_for_baseclass)
{
int i;
int nbases = TYPE_N_BASECLASSES (type);
* conventions. */
void
-find_rt_vbase_offset (type, basetype, valaddr, offset, boffset_p, skip_p)
- struct type *type;
- struct type *basetype;
- char *valaddr;
- int offset;
- int *boffset_p;
- int *skip_p;
+find_rt_vbase_offset (struct type *type, struct type *basetype, char *valaddr,
+ int offset, int *boffset_p, int *skip_p)
{
int boffset; /* offset of virtual base */
int index; /* displacement to use in virtual table */
* virtual base entries. Offset is negative -- virtual base entries
* appear _before_ the address point of the virtual table. */
- /* pai: FIXME -- 32x64 problem, if word = 8 bytes, change multiplier
+ /* pai: FIXME -- 32x64 problem, if word = 8 bytes, change multiplier
& use long type */
/* epstein : FIXME -- added param for overlay section. May not be correct */
else return NULL. */
static value_ptr
-search_struct_method (name, arg1p, args, offset, static_memfuncp, type)
- char *name;
- register value_ptr *arg1p, *args;
- int offset, *static_memfuncp;
- register struct type *type;
+search_struct_method (char *name, register value_ptr *arg1p,
+ register value_ptr *args, int offset,
+ int *static_memfuncp, register struct type *type)
{
int i;
value_ptr v;
*static_memfuncp = 1;
v = value_fn_field (arg1p, f, j, type, offset);
if (v != NULL)
- return v;
+ return v;
}
j--;
}
ERR is an error message to be printed in case the field is not found. */
value_ptr
-value_struct_elt (argp, args, name, static_memfuncp, err)
- register value_ptr *argp, *args;
- char *name;
- int *static_memfuncp;
- char *err;
+value_struct_elt (register value_ptr *argp, register value_ptr *args,
+ char *name, int *static_memfuncp, char *err)
{
register struct type *t;
value_ptr v;
}
else
v = search_struct_method (name, argp, args, 0, static_memfuncp, t);
-
+
if (v == (value_ptr) - 1)
{
- error ("Argument list of %s mismatch with component in the structure.", name);
+ error ("One of the arguments you tried to pass to %s could not be converted to what the function wants.", name);
}
else if (v == 0)
{
* BOFFSET is the offset of the base subobject where the method is found */
static struct fn_field *
-find_method_list (argp, method, offset, static_memfuncp, type, num_fns, basetype, boffset)
- value_ptr *argp;
- char *method;
- int offset;
- int *static_memfuncp;
- struct type *type;
- int *num_fns;
- struct type **basetype;
- int *boffset;
+find_method_list (value_ptr *argp, char *method, int offset,
+ int *static_memfuncp, struct type *type, int *num_fns,
+ struct type **basetype, int *boffset)
{
int i;
struct fn_field *f;
* BOFFSET is the offset of the base subobject which defines the method */
struct fn_field *
-value_find_oload_method_list (argp, method, offset, static_memfuncp, num_fns, basetype, boffset)
- value_ptr *argp;
- char *method;
- int offset;
- int *static_memfuncp;
- int *num_fns;
- struct type **basetype;
- int *boffset;
+value_find_oload_method_list (value_ptr *argp, char *method, int offset,
+ int *static_memfuncp, int *num_fns,
+ struct type **basetype, int *boffset)
{
struct type *t;
*/
int
-find_overload_match (arg_types, nargs, name, method, lax, obj, fsym, valp, symp, staticp)
- struct type **arg_types;
- int nargs;
- char *name;
- int method;
- int lax;
- value_ptr obj;
- struct symbol *fsym;
- value_ptr *valp;
- struct symbol **symp;
- int *staticp;
+find_overload_match (struct type **arg_types, int nargs, char *name, int method,
+ int lax, value_ptr obj, struct symbol *fsym,
+ value_ptr *valp, struct symbol **symp, int *staticp)
{
int nparms;
struct type **parm_types;
for (j = 0; j < len2; j++)
{
- if (TYPE_FN_FIELD_STUB (f, j))
+ if (TYPE_FN_FIELD_STUB (f, j) && (!strcmp_iw (TYPE_FN_FIELDLIST_NAME (domain,i),name)))
check_stub_method (domain, i, j);
}
}
default:
break;
}
- free (parm_types);
-#ifdef DEBUG_OLOAD
- /* FIXME: cagney/2000-03-12: Send the output to gdb_stderr. See
- comments above about adding a ``set debug'' command. */
- if (method)
- printf ("Overloaded method instance %s, # of parms %d\n", fns_ptr[ix].physname, nparms);
- else
- printf ("Overloaded function instance %s # of parms %d\n", SYMBOL_DEMANGLED_NAME (oload_syms[ix]), nparms);
- for (jj = 0; jj < nargs; jj++)
- printf ("...Badness @ %d : %d\n", jj, bv->rank[jj]);
- printf ("Overload resolution champion is %d, ambiguous? %d\n", oload_champ, oload_ambiguous);
-#endif
+ xfree (parm_types);
+ if (overload_debug)
+ {
+ if (method)
+ fprintf_filtered (gdb_stderr,"Overloaded method instance %s, # of parms %d\n", fns_ptr[ix].physname, nparms);
+ else
+ fprintf_filtered (gdb_stderr,"Overloaded function instance %s # of parms %d\n", SYMBOL_DEMANGLED_NAME (oload_syms[ix]), nparms);
+ for (jj = 0; jj < nargs; jj++)
+ fprintf_filtered (gdb_stderr,"...Badness @ %d : %d\n", jj, bv->rank[jj]);
+ fprintf_filtered (gdb_stderr,"Overload resolution champion is %d, ambiguous? %d\n", oload_champ, oload_ambiguous);
+ }
} /* end loop over all candidates */
-
/* NOTE: dan/2000-03-10: Seems to be a better idea to just pick one
if they have the exact same goodness. This is because there is no
way to differentiate based on return type, which we need to in
/* Check how bad the best match is */
for (ix = 1; ix <= nargs; ix++)
{
- switch (oload_champ_bv->rank[ix])
- {
- case 10:
- oload_non_standard = 1; /* non-standard type conversions needed */
- break;
- case 100:
- oload_incompatible = 1; /* truly mismatched types */
- break;
- }
+ if (oload_champ_bv->rank[ix] >= 100)
+ oload_incompatible = 1; /* truly mismatched types */
+
+ else if (oload_champ_bv->rank[ix] >= 10)
+ oload_non_standard = 1; /* non-standard type conversions needed */
}
if (oload_incompatible)
{
else
{
*symp = oload_syms[oload_champ];
- free (func_name);
+ xfree (func_name);
}
return oload_incompatible ? 100 : (oload_non_standard ? 10 : 0);
of type TYPE. If TYPE does not have a destructor, or
if NAME is inappropriate for TYPE, an error is signaled. */
int
-destructor_name_p (name, type)
- const char *name;
- const struct type *type;
+destructor_name_p (const char *name, const struct type *type)
{
/* destructors are a special case. */
target structure/union is defined, otherwise, return 0. */
static int
-check_field_in (type, name)
- register struct type *type;
- const char *name;
+check_field_in (register struct type *type, const char *name)
{
register int i;
target structure/union is defined, otherwise, return 0. */
int
-check_field (arg1, name)
- register value_ptr arg1;
- const char *name;
+check_field (register value_ptr arg1, const char *name)
{
register struct type *t;
to resolve user expressions of the form "DOMAIN::NAME". */
value_ptr
-value_struct_elt_for_reference (domain, offset, curtype, name, intype)
- struct type *domain, *curtype, *intype;
- int offset;
- char *name;
+value_struct_elt_for_reference (struct type *domain, int offset,
+ struct type *curtype, char *name,
+ struct type *intype)
{
register struct type *t = curtype;
register int i;
* USING_ENC is the flag that distinguishes the two cases.
* If it is 1, then the offset is for the enclosing object,
* otherwise for the embedded object.
- *
- * This currently works only for RTTI information generated
- * by the HP ANSI C++ compiler (aCC). g++ today (1997-06-10)
- * does not appear to support RTTI. This function returns a
- * NULL value for objects in the g++ runtime model. */
+ *
+ */
struct type *
-value_rtti_type (v, full, top, using_enc)
- value_ptr v;
- int *full;
- int *top;
- int *using_enc;
+value_rtti_type (value_ptr v, int *full, int *top, int *using_enc)
{
struct type *known_type;
struct type *rtti_type;
/* RTTI works only or class objects */
if (TYPE_CODE (known_type) != TYPE_CODE_CLASS)
return NULL;
+ if (TYPE_HAS_VTABLE(known_type))
+ {
+ /* If neither the declared type nor the enclosing type of the
+ * value structure has a HP ANSI C++ style virtual table,
+ * we can't do anything. */
+ if (!TYPE_HAS_VTABLE (known_type))
+ {
+ known_type = VALUE_ENCLOSING_TYPE (v);
+ CHECK_TYPEDEF (known_type);
+ if ((TYPE_CODE (known_type) != TYPE_CODE_CLASS) ||
+ !TYPE_HAS_VTABLE (known_type))
+ return NULL; /* No RTTI, or not HP-compiled types */
+ CHECK_TYPEDEF (known_type);
+ using_enclosing = 1;
+ }
- /* If neither the declared type nor the enclosing type of the
- * value structure has a HP ANSI C++ style virtual table,
- * we can't do anything. */
- if (!TYPE_HAS_VTABLE (known_type))
- {
- known_type = VALUE_ENCLOSING_TYPE (v);
- CHECK_TYPEDEF (known_type);
- if ((TYPE_CODE (known_type) != TYPE_CODE_CLASS) ||
- !TYPE_HAS_VTABLE (known_type))
- return NULL; /* No RTTI, or not HP-compiled types */
- CHECK_TYPEDEF (known_type);
- using_enclosing = 1;
- }
-
- if (using_enclosing && using_enc)
- *using_enc = 1;
-
- /* First get the virtual table address */
- coreptr = *(CORE_ADDR *) ((VALUE_CONTENTS_ALL (v))
- + VALUE_OFFSET (v)
- + (using_enclosing ? 0 : VALUE_EMBEDDED_OFFSET (v)));
- if (coreptr == 0)
- return NULL; /* return silently -- maybe called on gdb-generated value */
-
- /* Fetch the top offset of the object */
- /* FIXME possible 32x64 problem with pointer size & arithmetic */
- vp = value_at (builtin_type_int,
- coreptr + 4 * HP_ACC_TOP_OFFSET_OFFSET,
- VALUE_BFD_SECTION (v));
- top_offset = value_as_long (vp);
- if (top)
- *top = top_offset;
-
- /* Fetch the typeinfo pointer */
- /* FIXME possible 32x64 problem with pointer size & arithmetic */
- vp = value_at (builtin_type_int, coreptr + 4 * HP_ACC_TYPEINFO_OFFSET, VALUE_BFD_SECTION (v));
- /* Indirect through the typeinfo pointer and retrieve the pointer
- * to the string name */
- coreptr = *(CORE_ADDR *) (VALUE_CONTENTS (vp));
- if (!coreptr)
- error ("Retrieved null typeinfo pointer in trying to determine run-time type");
- vp = value_at (builtin_type_int, coreptr + 4, VALUE_BFD_SECTION (v)); /* 4 -> offset of name field */
- /* FIXME possible 32x64 problem */
-
- coreptr = *(CORE_ADDR *) (VALUE_CONTENTS (vp));
-
- read_memory_string (coreptr, rtti_type_name, 256);
-
- if (strlen (rtti_type_name) == 0)
- error ("Retrieved null type name from typeinfo");
+ if (using_enclosing && using_enc)
+ *using_enc = 1;
+
+ /* First get the virtual table address */
+ coreptr = *(CORE_ADDR *) ((VALUE_CONTENTS_ALL (v))
+ + VALUE_OFFSET (v)
+ + (using_enclosing ? 0 : VALUE_EMBEDDED_OFFSET (v)));
+ if (coreptr == 0)
+ return NULL; /* return silently -- maybe called on gdb-generated value */
+
+ /* Fetch the top offset of the object */
+ /* FIXME possible 32x64 problem with pointer size & arithmetic */
+ vp = value_at (builtin_type_int,
+ coreptr + 4 * HP_ACC_TOP_OFFSET_OFFSET,
+ VALUE_BFD_SECTION (v));
+ top_offset = value_as_long (vp);
+ if (top)
+ *top = top_offset;
+
+ /* Fetch the typeinfo pointer */
+ /* FIXME possible 32x64 problem with pointer size & arithmetic */
+ vp = value_at (builtin_type_int, coreptr + 4 * HP_ACC_TYPEINFO_OFFSET, VALUE_BFD_SECTION (v));
+ /* Indirect through the typeinfo pointer and retrieve the pointer
+ * to the string name */
+ coreptr = *(CORE_ADDR *) (VALUE_CONTENTS (vp));
+ if (!coreptr)
+ error ("Retrieved null typeinfo pointer in trying to determine run-time type");
+ vp = value_at (builtin_type_int, coreptr + 4, VALUE_BFD_SECTION (v)); /* 4 -> offset of name field */
+ /* FIXME possible 32x64 problem */
+
+ coreptr = *(CORE_ADDR *) (VALUE_CONTENTS (vp));
+
+ read_memory_string (coreptr, rtti_type_name, 256);
+
+ if (strlen (rtti_type_name) == 0)
+ error ("Retrieved null type name from typeinfo");
+
+ /* search for type */
+ rtti_type = lookup_typename (rtti_type_name, (struct block *) 0, 1);
+
+ if (!rtti_type)
+ error ("Could not find run-time type: invalid type name %s in typeinfo??", rtti_type_name);
+ CHECK_TYPEDEF (rtti_type);
+#if 0
+ printf ("RTTI type name %s, tag %s, full? %d\n", TYPE_NAME (rtti_type), TYPE_TAG_NAME (rtti_type), full ? *full : -1);
+#endif
+ /* Check whether we have the entire object */
+ if (full /* Non-null pointer passed */
+ &&
+ /* Either we checked on the whole object in hand and found the
+ top offset to be zero */
+ (((top_offset == 0) &&
+ using_enclosing &&
+ TYPE_LENGTH (known_type) == TYPE_LENGTH (rtti_type))
+ ||
+ /* Or we checked on the embedded object and top offset was the
+ same as the embedded offset */
+ ((top_offset == VALUE_EMBEDDED_OFFSET (v)) &&
+ !using_enclosing &&
+ TYPE_LENGTH (VALUE_ENCLOSING_TYPE (v)) == TYPE_LENGTH (rtti_type))))
+
+ *full = 1;
+ }
+ else
+ /*
+ Right now this is G++ RTTI. Plan on this changing in the
+ future as i get around to setting the vtables properly for G++
+ compiled stuff. Also, i'll be using the type info functions,
+ which are always right. Deal with it until then.
+ */
+ {
+ CORE_ADDR vtbl;
+ struct minimal_symbol *minsym;
+ struct symbol *sym;
+ char *demangled_name;
+ struct type *btype;
+ /* If the type has no vptr fieldno, try to get it filled in */
+ if (TYPE_VPTR_FIELDNO(known_type) < 0)
+ fill_in_vptr_fieldno(known_type);
+
+ /* If we still can't find one, give up */
+ if (TYPE_VPTR_FIELDNO(known_type) < 0)
+ return NULL;
- /* search for type */
- rtti_type = lookup_typename (rtti_type_name, (struct block *) 0, 1);
+ /* Make sure our basetype and known type match, otherwise, cast
+ so we can get at the vtable properly.
+ */
+ btype = TYPE_VPTR_BASETYPE (known_type);
+ CHECK_TYPEDEF (btype);
+ if (btype != known_type )
+ {
+ v = value_cast (btype, v);
+ if (using_enc)
+ *using_enc=1;
+ }
+ /*
+ We can't use value_ind here, because it would want to use RTTI, and
+ we'd waste a bunch of time figuring out we already know the type.
+ Besides, we don't care about the type, just the actual pointer
+ */
+ if (VALUE_ADDRESS (value_field (v, TYPE_VPTR_FIELDNO (known_type))) == 0)
+ return NULL;
- if (!rtti_type)
- error ("Could not find run-time type: invalid type name %s in typeinfo??", rtti_type_name);
- CHECK_TYPEDEF (rtti_type);
+ /*
+ If we are enclosed by something that isn't us, adjust the
+ address properly and set using_enclosing.
+ */
+ if (VALUE_ENCLOSING_TYPE(v) != VALUE_TYPE(v))
+ {
+ value_ptr tempval;
+ tempval=value_field(v,TYPE_VPTR_FIELDNO(known_type));
+ VALUE_ADDRESS(tempval)+=(TYPE_BASECLASS_BITPOS(known_type,TYPE_VPTR_FIELDNO(known_type))/8);
+ vtbl=value_as_pointer(tempval);
+ using_enclosing=1;
+ }
+ else
+ {
+ vtbl=value_as_pointer(value_field(v,TYPE_VPTR_FIELDNO(known_type)));
+ using_enclosing=0;
+ }
-#if 0 /* debugging */
- printf ("RTTI type name %s, tag %s, full? %d\n", TYPE_NAME (rtti_type), TYPE_TAG_NAME (rtti_type), full ? *full : -1);
-#endif
+ /* Try to find a symbol that is the vtable */
+ minsym=lookup_minimal_symbol_by_pc(vtbl);
+ if (minsym==NULL || (demangled_name=SYMBOL_NAME(minsym))==NULL || !VTBL_PREFIX_P(demangled_name))
+ return NULL;
- /* Check whether we have the entire object */
- if (full /* Non-null pointer passed */
+ /* If we just skip the prefix, we get screwed by namespaces */
+ demangled_name=cplus_demangle(demangled_name,DMGL_PARAMS|DMGL_ANSI);
+ *(strchr(demangled_name,' '))=0;
- &&
- /* Either we checked on the whole object in hand and found the
- top offset to be zero */
- (((top_offset == 0) &&
- using_enclosing &&
- TYPE_LENGTH (known_type) == TYPE_LENGTH (rtti_type))
- ||
- /* Or we checked on the embedded object and top offset was the
- same as the embedded offset */
- ((top_offset == VALUE_EMBEDDED_OFFSET (v)) &&
- !using_enclosing &&
- TYPE_LENGTH (VALUE_ENCLOSING_TYPE (v)) == TYPE_LENGTH (rtti_type))))
+ /* Lookup the type for the name */
+ rtti_type=lookup_typename(demangled_name, (struct block *)0,1);
- *full = 1;
+ if (rtti_type==NULL)
+ return NULL;
+ if (TYPE_N_BASECLASSES(rtti_type) > 1 && full && (*full) != 1)
+ {
+ if (top)
+ *top=TYPE_BASECLASS_BITPOS(rtti_type,TYPE_VPTR_FIELDNO(rtti_type))/8;
+ if (top && ((*top) >0))
+ {
+ if (TYPE_LENGTH(rtti_type) > TYPE_LENGTH(known_type))
+ {
+ if (full)
+ *full=0;
+ }
+ else
+ {
+ if (full)
+ *full=1;
+ }
+ }
+ }
+ else
+ {
+ if (full)
+ *full=1;
+ }
+ if (using_enc)
+ *using_enc=using_enclosing;
+ }
return rtti_type;
}
and refer to the values computed for the object pointed to. */
struct type *
-value_rtti_target_type (v, full, top, using_enc)
- value_ptr v;
- int *full;
- int *top;
- int *using_enc;
+value_rtti_target_type (value_ptr v, int *full, int *top, int *using_enc)
{
value_ptr target;
(Pass RTYPE == NULL if they're not available */
value_ptr
-value_full_object (argp, rtype, xfull, xtop, xusing_enc)
- value_ptr argp;
- struct type *rtype;
- int xfull;
- int xtop;
- int xusing_enc;
-
+value_full_object (value_ptr argp, struct type *rtype, int xfull, int xtop,
+ int xusing_enc)
{
struct type *real_type;
int full = 0;
inappropriate context. */
value_ptr
-value_of_this (complain)
- int complain;
+value_of_this (int complain)
{
struct symbol *func, *sym;
struct block *b;
the original ARRAY. */
value_ptr
-value_slice (array, lowbound, length)
- value_ptr array;
- int lowbound, length;
+value_slice (value_ptr array, int lowbound, int length)
{
struct type *slice_range_type, *slice_type, *range_type;
LONGEST lowerbound, upperbound, offset;
value as a fixed-length array. */
value_ptr
-varying_to_slice (varray)
- value_ptr varray;
+varying_to_slice (value_ptr varray)
{
struct type *vtype = check_typedef (VALUE_TYPE (varray));
LONGEST length = unpack_long (TYPE_FIELD_TYPE (vtype, 0),
return value_slice (value_primitive_field (varray, 0, 1, vtype), 0, length);
}
-/* Create a value for a FORTRAN complex number. Currently most of
- the time values are coerced to COMPLEX*16 (i.e. a complex number
- composed of 2 doubles. This really should be a smarter routine
- that figures out precision inteligently as opposed to assuming
+/* Create a value for a FORTRAN complex number. Currently most of
+ the time values are coerced to COMPLEX*16 (i.e. a complex number
+ composed of 2 doubles. This really should be a smarter routine
+ that figures out precision inteligently as opposed to assuming
doubles. FIXME: fmb */
value_ptr
-value_literal_complex (arg1, arg2, type)
- value_ptr arg1;
- value_ptr arg2;
- struct type *type;
+value_literal_complex (value_ptr arg1, value_ptr arg2, struct type *type)
{
register value_ptr val;
struct type *real_type = TYPE_TARGET_TYPE (type);
/* Cast a value into the appropriate complex data type. */
static value_ptr
-cast_into_complex (type, val)
- struct type *type;
- register value_ptr val;
+cast_into_complex (struct type *type, register value_ptr val)
{
struct type *real_type = TYPE_TARGET_TYPE (type);
if (TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_COMPLEX)
}
void
-_initialize_valops ()
+_initialize_valops (void)
{
#if 0
add_show_from_set