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.

5 files changed, 50 insertions, 364 deletions

diff --git a/gdb/breakpoint.c b/gdb/breakpoint.c
index f290ad5..67d049a 100644
--- a/gdb/breakpoint.c
+++ b/gdb/breakpoint.c
@@ -130,7 +130,7 @@ set_breakpoint_count (num)
 {
   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
@@ -824,7 +824,8 @@ which its expression is valid.\n", b->number);
 	      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)
@@ -2032,7 +2033,7 @@ breakpoint_re_set ()
     {
       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.  */
diff --git a/gdb/convex-tdep.c b/gdb/convex-tdep.c
index 95da97c..d77c25c 100644
--- a/gdb/convex-tdep.c
+++ b/gdb/convex-tdep.c
@@ -339,12 +339,12 @@ value_of_trapped_internalvar (var)
 
   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"))
@@ -376,10 +376,10 @@ value_of_trapped_internalvar (var)
     }
 
   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;
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");
diff --git a/gdb/solib.c b/gdb/solib.c
index f6a9628..6995e50 100644
--- a/gdb/solib.c
+++ b/gdb/solib.c
@@ -269,7 +269,7 @@ solib_add (arg_string, from_tty, target)
 	      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");
 	  }
       }
   }
@@ -378,7 +378,7 @@ solib_create_inferior_hook()
   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... 
@@ -386,11 +386,16 @@ solib_create_inferior_hook()
   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 */
diff --git a/gdb/valops.c b/gdb/valops.c
index 92ec751..b4101b5 100644
--- a/gdb/valops.c
+++ b/gdb/valops.c
@@ -3,19 +3,19 @@
 
 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"
@@ -60,7 +60,7 @@ value_cast (type, arg2)
     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)
@@ -401,14 +401,14 @@ value_of_variable (var)
 }
 
 /* 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.");
@@ -421,12 +421,8 @@ value_coerce_array (arg1)
        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
@@ -436,18 +432,12 @@ value
 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.  */
@@ -456,12 +446,8 @@ value
 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);
@@ -471,12 +457,8 @@ value_addr (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.  */
@@ -825,7 +807,8 @@ call_function_by_hand (function, nargs, args)
 #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.  */
@@ -940,17 +923,17 @@ value_string (ptr, len)
   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.");
@@ -1333,19 +1316,17 @@ value_struct_elt_for_address (domain, intype, name)
 		  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;
 	    }
 	}
 
@@ -1394,7 +1375,10 @@ value_struct_elt_for_address (domain, intype, name)
 	      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
@@ -1402,9 +1386,9 @@ value_struct_elt_for_address (domain, intype, name)
 		  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;
 	    }
 	}