machines with different sized basic types (ints, ptrs, etc).
(Idea from pierre@la.tce.com (Pierre Willard).)
* value.c (value_from_longest): Rename from value_from_long.
Handle pointer types as well as integers, so that targets with
different pointer sizes from the host can be accomodated.
* breakpoint.c, convex-tdep.c, eval.c, expprint.c, printcmd.c,
valarith.c, valops.c, valprint.c, value.h, values.c: Rename
uses of value_from_long to value_from_longest.
* eval.c, findvar.c, printcmd.c, valarith.c, valops.c: Pass
the correct pointer type to value_from_long{est}.
* remote-vx.c: Remove obsolete code for calling functions via
vxworks kludge interface (it referenced value_from_long).
* valops.c (value_string): Find malloc with lookup_misc_func, not
raw search.
* breakpoint.c, remote-vx.c: Reword strings printed by
catch_errors callers.
{
breakpoint_count = num;
set_internalvar (lookup_internalvar ("bpnum"),
- value_from_long (builtin_type_int, (LONGEST) num));
+ value_from_longest (builtin_type_int, (LONGEST) num));
}
/* Default address, symtab and line to put a breakpoint at
select_frame (get_current_frame (), 0);
value_is_zero
= catch_errors (breakpoint_cond_eval, (char *)(b->cond),
- "Error occurred in testing breakpoint condition.");
+ "Error in testing breakpoint condition:\n");
+ /* FIXME-someday, should give breakpoint # */
free_all_values ();
}
if (b->cond && value_is_zero)
{
b->symtab = 0; /* Be sure we don't point to old dead symtab */
(void) catch_errors (breakpoint_re_set_one, (char *) b,
- "Error in re-setting breakpoint");
+ "Error in re-setting breakpoint:\n");
}
/* Blank line to finish off all those mention() messages we just printed. */
if (!strcmp (name, "vl"))
{
- val = value_from_long (builtin_type_int,
+ val = value_from_longest (builtin_type_int,
(LONGEST) *read_vector_register_1 (VL_REGNUM));
}
else if (!strcmp (name, "vs"))
{
- val = value_from_long (builtin_type_int,
+ val = value_from_longest (builtin_type_int,
(LONGEST) *read_vector_register_1 (VS_REGNUM));
}
else if (!strcmp (name, "vm"))
}
else if (name[0] == 'c')
- val = value_from_long (builtin_type_int,
+ val = value_from_longest (builtin_type_int,
read_comm_register (atoi (&name[1])));
else if (name[0] == 'C')
- val = value_from_long (builtin_type_long_long,
+ val = value_from_longest (builtin_type_long_long,
read_comm_register (atoi (&name[1])));
VALUE_LVAL (val) = lval_internalvar;
return net_break (addr, VX_BREAK_DELETE);
}
-/* Call a function on the VxWorks target system.
- ARGS is a vector of values of arguments (NARGS of them).
- FUNCTION is a value, the function to be called.
- Returns a struct value * representing what the function returned.
- May fail to return, if a breakpoint or signal is hit
- during the execution of the function. */
-
-#ifdef FIXME
-/* FIXME, function calls are really fried. GO back to manual method. */
-value
-vx_call_function (function, nargs, args)
- value function;
- int nargs;
- value *args;
-{
- register CORE_ADDR sp;
- register int i;
- CORE_ADDR start_sp;
- static REGISTER_TYPE dummy[] = CALL_DUMMY;
- REGISTER_TYPE dummy1[sizeof dummy / sizeof (REGISTER_TYPE)];
- CORE_ADDR old_sp;
- struct type *value_type;
- unsigned char struct_return;
- CORE_ADDR struct_addr;
- struct inferior_status inf_status;
- struct cleanup *old_chain;
- CORE_ADDR funaddr;
- int using_gcc;
-
- save_inferior_status (&inf_status, 1);
- 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)
- they are saved on the stack in the inferior. */
- PUSH_DUMMY_FRAME;
-
- old_sp = sp = read_register (SP_REGNUM);
-
-#if 1 INNER_THAN 2 /* Stack grows down */
- sp -= sizeof dummy;
- start_sp = sp;
-#else /* Stack grows up */
- start_sp = sp;
- sp += sizeof dummy;
-#endif
-
- funaddr = find_function_addr (function, &value_type);
-
- {
- struct block *b = block_for_pc (funaddr);
- /* If compiled without -g, assume GCC. */
- using_gcc = b == NULL || BLOCK_GCC_COMPILED (b);
- }
-
- /* Are we returning a value using a structure return or a normal
- value return? */
-
- struct_return = using_struct_return (function, funaddr, value_type,
- using_gcc);
-
- /* Create a call sequence customized for this function
- and the number of arguments for it. */
- bcopy (dummy, dummy1, sizeof dummy);
- FIX_CALL_DUMMY (dummy1, start_sp, funaddr, nargs, args,
- value_type, using_gcc);
-
-#if CALL_DUMMY_LOCATION == ON_STACK
- write_memory (start_sp, dummy1, sizeof dummy);
-
-#else /* Not on stack. */
-#if CALL_DUMMY_LOCATION == BEFORE_TEXT_END
- /* Convex Unix prohibits executing in the stack segment. */
- /* Hope there is empty room at the top of the text segment. */
- {
- static checked = 0;
- if (!checked)
- for (start_sp = text_end - sizeof dummy; start_sp < text_end; ++start_sp)
- if (read_memory_integer (start_sp, 1) != 0)
- error ("text segment full -- no place to put call");
- checked = 1;
- sp = old_sp;
- start_sp = text_end - sizeof dummy;
- write_memory (start_sp, dummy1, sizeof dummy);
- }
-#else /* After text_end. */
- {
- int errcode;
- sp = old_sp;
- start_sp = text_end;
- errcode = target_write_memory (start_sp, dummy1, sizeof dummy);
- if (errcode != 0)
- error ("Cannot write text segment -- call_function failed");
- }
-#endif /* After text_end. */
-#endif /* Not on stack. */
-
-#ifdef STACK_ALIGN
- /* If stack grows down, we must leave a hole at the top. */
- {
- int len = 0;
-
- /* Reserve space for the return structure to be written on the
- stack, if necessary */
-
- if (struct_return)
- len += TYPE_LENGTH (value_type);
-
- for (i = nargs - 1; i >= 0; i--)
- len += TYPE_LENGTH (VALUE_TYPE (value_arg_coerce (args[i])));
-#ifdef CALL_DUMMY_STACK_ADJUST
- len += CALL_DUMMY_STACK_ADJUST;
-#endif
-#if 1 INNER_THAN 2
- sp -= STACK_ALIGN (len) - len;
-#else
- sp += STACK_ALIGN (len) - len;
-#endif
- }
-#endif /* STACK_ALIGN */
-
- /* Reserve space for the return structure to be written on the
- stack, if necessary */
-
- if (struct_return)
- {
-#if 1 INNER_THAN 2
- sp -= TYPE_LENGTH (value_type);
- struct_addr = sp;
-#else
- struct_addr = sp;
- sp += TYPE_LENGTH (value_type);
-#endif
- }
-
-#if defined (REG_STRUCT_HAS_ADDR)
- {
- /* This is a machine like the sparc, where we need to pass a pointer
- to the structure, not the structure itself. */
- if (REG_STRUCT_HAS_ADDR (using_gcc))
- for (i = nargs - 1; i >= 0; i--)
- if (TYPE_CODE (VALUE_TYPE (args[i])) == TYPE_CODE_STRUCT)
- {
- CORE_ADDR addr;
-#if !(1 INNER_THAN 2)
- /* The stack grows up, so the address of the thing we push
- is the stack pointer before we push it. */
- addr = sp;
-#endif
- /* Push the structure. */
- sp = value_push (sp, args[i]);
-#if 1 INNER_THAN 2
- /* The stack grows down, so the address of the thing we push
- is the stack pointer after we push it. */
- addr = sp;
-#endif
- /* The value we're going to pass is the address of the thing
- we just pushed. */
- args[i] = value_from_long (builtin_type_long, (LONGEST) addr);
- }
- }
-#endif /* REG_STRUCT_HAS_ADDR. */
-
-#ifdef PUSH_ARGUMENTS
- PUSH_ARGUMENTS(nargs, args, sp, struct_return, struct_addr);
-#else /* !PUSH_ARGUMENTS */
- for (i = nargs - 1; i >= 0; i--)
- sp = value_arg_push (sp, args[i]);
-#endif /* !PUSH_ARGUMENTS */
-
-#ifdef CALL_DUMMY_STACK_ADJUST
-#if 1 INNER_THAN 2
- sp -= CALL_DUMMY_STACK_ADJUST;
-#else
- sp += CALL_DUMMY_STACK_ADJUST;
-#endif
-#endif /* CALL_DUMMY_STACK_ADJUST */
-
- /* Store the address at which the structure is supposed to be
- written. Note that this (and the code which reserved the space
- above) assumes that gcc was used to compile this function. Since
- 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
- convention like gcc's. */
-
- if (struct_return)
- STORE_STRUCT_RETURN (struct_addr, sp);
-
- /* Write the stack pointer. This is here because the statements above
- might fool with it. On SPARC, this write also stores the register
- window into the right place in the new stack frame, which otherwise
- wouldn't happen. (See write_inferior_registers in sparc-xdep.c.) */
- write_register (SP_REGNUM, sp);
-
- /* Figure out the value returned by the function. */
- {
- char retbuf[REGISTER_BYTES];
-
- /* Execute the stack dummy routine, calling FUNCTION.
- When it is done, discard the empty frame
- after storing the contents of all regs into retbuf. */
- run_stack_dummy (start_sp + CALL_DUMMY_START_OFFSET, retbuf);
-
- do_cleanups (old_chain);
-
- return value_being_returned (value_type, retbuf, struct_return);
- }
-}
-/* should return a value of some sort */
-
-value
-vx_call_function (funcAddr, nargs, args, valueType)
- char *funcAddr;
- int nargs;
- value *args;
- struct type * valueType;
-{
- int i;
- func_call funcInfo;
- arg_value *argValue;
- enum clnt_stat status;
- register int len;
- arg_value funcReturn;
- value gdbValue;
-
- argValue = (arg_value *) xmalloc (nargs * sizeof (arg_value));
-
- bzero (argValue, nargs * sizeof (arg_value));
- bzero (&funcReturn, sizeof (funcReturn));
-
- for (i = nargs - 1; i >= 0; i--)
- {
- len = TYPE_LENGTH (VALUE_TYPE (args [i]));
-
- switch (TYPE_CODE (VALUE_TYPE (args[i])))
- {
- /* XXX put other types here. Where's CHAR, etc??? */
-
- case TYPE_CODE_FLT:
- argValue[i].type = T_FLOAT;
- break;
- case TYPE_CODE_INT:
- case TYPE_CODE_PTR:
- case TYPE_CODE_ENUM:
- case TYPE_CODE_FUNC:
- argValue[i].type = T_INT;
- break;
-
- case TYPE_CODE_UNDEF:
- case TYPE_CODE_ARRAY:
- case TYPE_CODE_STRUCT:
- case TYPE_CODE_UNION:
- case TYPE_CODE_VOID:
- case TYPE_CODE_SET:
- case TYPE_CODE_RANGE:
- case TYPE_CODE_PASCAL_ARRAY:
- case TYPE_CODE_MEMBER: /* C++ */
- case TYPE_CODE_METHOD: /* C++ */
- case TYPE_CODE_REF: /* C++ */
- default:
- error ("No corresponding VxWorks type for %d. CHECK IT OUT!!!\n",
- TYPE_CODE(VALUE_TYPE(args[i])));
- } /* switch */
- if (TYPE_CODE(VALUE_TYPE(args[i])) == TYPE_CODE_FUNC)
- argValue[i].arg_value_u.v_int = VALUE_ADDRESS(args[i]);
- else
- bcopy (VALUE_CONTENTS (args[i]), (char *) &argValue[i].arg_value_u,
- len);
- }
-
- /* XXX what should the type of this function addr be?
- * XXX Both in gdb and vxWorks
- */
- funcInfo.func_addr = (int) funcAddr;
- funcInfo.args.args_len = nargs;
- funcInfo.args.args_val = argValue;
-
- status = net_clnt_call (VX_CALL_FUNC, xdr_func_call, (char *) &funcInfo,
- xdr_arg_value, &funcReturn);
-
- free ((char *) argValue);
-
- if (status == RPC_SUCCESS)
- {
- /* XXX this assumes that vxWorks ALWAYS returns an int, and that
- * XXX gdb isn't expecting anything more
- */
-
- /*******************
- if (funcReturn.type == T_UNKNOWN)
- return YYYXXX...;
- *******************/
- gdbValue = allocate_value (valueType);
- bcopy (&funcReturn.arg_value_u.v_int, VALUE_CONTENTS (gdbValue),
- sizeof (int));
- return gdbValue;
- }
- else
- error (rpcerr);
- }
-#endif /* FIXME */
-
/* Start an inferior process and sets inferior_pid to its pid.
EXEC_FILE is the file to run.
ALLARGS is a string containing the arguments to the program.
if (*bootFile) {
printf_filtered ("\t%s: ", bootFile);
if (catch_errors (symbol_stub, bootFile,
- "Error reading symbols from boot file"))
+ "Error while reading symbols from boot file:\n"))
puts_filtered ("ok\n");
} else if (from_tty)
printf ("VxWorks kernel symbols not loaded.\n");
so->symbols_loaded = 1;
so->from_tty = from_tty;
catch_errors (symbol_add_stub, (char *)so,
- "Error while reading shared library symbols; continuing.");
+ "Error while reading shared library symbols:\n");
}
}
}
int in_debugger;
CORE_ADDR in_debugger_addr;
CORE_ADDR breakpoint_addr;
- int i;
+ int i, j;
/* FIXME: We should look around in the executable code to find _DYNAMIC,
if it isn't in the symbol table. It's not that hard to find...
i = lookup_misc_func ("_DYNAMIC");
if (i < 0) /* Can't find shared lib ptr. */
return;
+ if (misc_function_vector[i].address == 0) /* statically linked program */
+ return;
/* Get link_dynamic structure */
- read_memory(misc_function_vector[i].address,
+ j = target_read_memory(misc_function_vector[i].address,
&inferior_dynamic_cpy,
sizeof(struct link_dynamic));
+ if (j) /* unreadable */
+ return;
+
/* Calc address of debugger interface structure */
inferior_debug_addr = (CORE_ADDR)inferior_dynamic_cpy.ldd;
/* Calc address of `in_debugger' member of debugger interface structure */
This file is part of GDB.
-GDB is free software; you can redistribute it and/or modify
+This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 1, or (at your option)
-any later version.
+the Free Software Foundation; either version 2 of the License, or
+(at your option) any later version.
-GDB is distributed in the hope that it will be useful,
+This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
-along with GDB; see the file COPYING. If not, write to
-the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
+along with this program; if not, write to the Free Software
+Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
#include <stdio.h>
#include "defs.h"
return value_from_double (type, value_as_double (arg2));
else if ((code1 == TYPE_CODE_INT || code1 == TYPE_CODE_ENUM)
&& (scalar || code2 == TYPE_CODE_PTR))
- return value_from_long (type, value_as_long (arg2));
+ return value_from_longest (type, value_as_long (arg2));
else if (TYPE_LENGTH (type) == TYPE_LENGTH (VALUE_TYPE (arg2)))
{
if (code1 == TYPE_CODE_PTR && code2 == TYPE_CODE_PTR)
}
/* Given a value which is an array, return a value which is
- a pointer to its first element. */
+ a pointer to its first (actually, zeroth) element.
+ FIXME, this should be subtracting the array's lower bound. */
value
value_coerce_array (arg1)
value arg1;
{
register struct type *type;
- register value val;
if (VALUE_LVAL (arg1) != lval_memory)
error ("Attempt to take address of value not located in memory.");
Its type is the type of the elements, not an array type. */
type = VALUE_TYPE (arg1);
- /* Get the type of the result. */
- type = lookup_pointer_type (type);
- val = value_from_long (builtin_type_long,
+ return value_from_longest (lookup_pointer_type (type),
(LONGEST) (VALUE_ADDRESS (arg1) + VALUE_OFFSET (arg1)));
- VALUE_TYPE (val) = type;
- return val;
}
/* Given a value which is a function, return a value which is a pointer
value_coerce_function (arg1)
value arg1;
{
- register struct type *type;
- register value val;
if (VALUE_LVAL (arg1) != lval_memory)
error ("Attempt to take address of value not located in memory.");
- /* Get the type of the result. */
- type = lookup_pointer_type (VALUE_TYPE (arg1));
- val = value_from_long (builtin_type_long,
+ return value_from_longest (lookup_pointer_type (VALUE_TYPE (arg1)),
(LONGEST) (VALUE_ADDRESS (arg1) + VALUE_OFFSET (arg1)));
- VALUE_TYPE (val) = type;
- return val;
}
/* Return a pointer value for the object for which ARG1 is the contents. */
value_addr (arg1)
value arg1;
{
- register struct type *type;
- register value val;
COERCE_REF(arg1);
- /* Taking the address of an array is really a no-op
- once the array is coerced to a pointer to its first element. */
if (VALUE_REPEATED (arg1)
|| TYPE_CODE (VALUE_TYPE (arg1)) == TYPE_CODE_ARRAY)
return value_coerce_array (arg1);
if (VALUE_LVAL (arg1) != lval_memory)
error ("Attempt to take address of value not located in memory.");
- /* Get the type of the result. */
- type = lookup_pointer_type (VALUE_TYPE (arg1));
- val = value_from_long (builtin_type_long,
+ return value_from_longest (lookup_pointer_type (VALUE_TYPE (arg1)),
(LONGEST) (VALUE_ADDRESS (arg1) + VALUE_OFFSET (arg1)));
- VALUE_TYPE (val) = type;
- return val;
}
/* Given a value of a pointer type, apply the C unary * operator to it. */
#endif
/* The value we're going to pass is the address of the thing
we just pushed. */
- args[i] = value_from_long (builtin_type_long, (LONGEST) addr);
+ args[i] = value_from_longest (lookup_pointer_type (value_type),
+ (LONGEST) addr);
}
}
#endif /* REG_STRUCT_HAS_ADDR. */
else
{
register int j;
- for (j = 0; j < misc_function_count; j++)
- if (!strcmp (misc_function_vector[j].name, "malloc"))
- break;
- if (j < misc_function_count)
- val = value_from_long (builtin_type_long,
- (LONGEST) misc_function_vector[j].address);
+ j = lookup_misc_func ("malloc");
+ if (j >= 0)
+ val = value_from_longest (
+ lookup_pointer_type (lookup_function_type (
+ lookup_pointer_type (builtin_type_char))),
+ (LONGEST) misc_function_vector[j].address);
else
error ("String constants require the program to have a function \"malloc\".");
}
- blocklen = value_from_long (builtin_type_int, (LONGEST) (len + 1));
+ blocklen = value_from_longest (builtin_type_int, (LONGEST) (len + 1));
val = target_call_function (val, 1, &blocklen);
if (value_zerop (val))
error ("No memory available for string constant.");
struct symbol *sym =
lookup_symbol (phys_name, 0, VAR_NAMESPACE, 0, NULL);
if (! sym) error ("Internal error: could not find physical static variable named %s", phys_name);
- v = value_from_long(builtin_type_long,
- (CORE_ADDR)SYMBOL_BLOCK_VALUE (sym));
- VALUE_TYPE(v) = lookup_pointer_type (TYPE_FIELD_TYPE (t, i));
- return v;
+ return value_from_longest (
+ lookup_pointer_type (TYPE_FIELD_TYPE (t, i)),
+ (LONGEST)SYMBOL_BLOCK_VALUE (sym));
}
if (TYPE_FIELD_PACKED (t, i))
error ("pointers to bitfield members not allowed");
- v = value_from_long (builtin_type_int,
+ return value_from_longest (
+ lookup_pointer_type (
+ lookup_member_type (TYPE_FIELD_TYPE (t, i), baseclass)),
(LONGEST) (TYPE_FIELD_BITPOS (t, i) >> 3));
- VALUE_TYPE (v)
- = lookup_pointer_type (lookup_member_type (TYPE_FIELD_TYPE (t, i), baseclass));
- return v;
}
}
check_stub_method (t, i, j);
if (TYPE_FN_FIELD_VIRTUAL_P (f, j))
{
- v = value_from_long (builtin_type_long,
+ return value_from_longest (
+ lookup_pointer_type (
+ lookup_member_type (TYPE_FN_FIELD_TYPE (f, j),
+ baseclass)),
(LONGEST) TYPE_FN_FIELD_VOFFSET (f, j));
}
else
struct symbol *s = lookup_symbol (TYPE_FN_FIELD_PHYSNAME (f, j),
0, VAR_NAMESPACE, 0, NULL);
v = locate_var_value (s, 0);
+ VALUE_TYPE (v) = lookup_pointer_type (lookup_member_type (TYPE_FN_FIELD_TYPE (f, j), baseclass));
+ return v;
}
- VALUE_TYPE (v) = lookup_pointer_type (lookup_member_type (TYPE_FN_FIELD_TYPE (f, j), baseclass));
- return v;
}
}
projects / binutils-gdb.git / commitdiff