Fix some infrastructure to be able to cope with host and target

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.

1 files changed, 1 insertions, 305 deletions

diff --git a/gdb/remote-vx.c b/gdb/remote-vx.c
index 59cd053..7b00a68 100644
--- a/gdb/remote-vx.c
+++ b/gdb/remote-vx.c
@@ -179,310 +179,6 @@ vx_remove_breakpoint (addr)
     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.
@@ -1413,7 +1109,7 @@ vx_open (args, from_tty)
       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");