FreeChainXenon/binutils-gdb
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

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

Browse source 
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.
This commit is contained in:
John Gilmore 1991-09-06 07:09:40 +00:00
parent 2d8fa9ab98
commit 06b6c733ae
5 changed files with 50 additions and 364 deletions
Download patch file Download diff file Expand all files Collapse all files

7
gdb/breakpoint.c
View file

@ -130,7 +130,7 @@ set_breakpoint_count (num)
{ {
breakpoint_count = num; breakpoint_count = num;
set_internalvar (lookup_internalvar ("bpnum"), 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 /* 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); select_frame (get_current_frame (), 0);
value_is_zero value_is_zero
= catch_errors (breakpoint_cond_eval, (char *)(b->cond), = 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 (); free_all_values ();
} }
if (b->cond && value_is_zero) 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 */ b->symtab = 0; /* Be sure we don't point to old dead symtab */
(void) catch_errors (breakpoint_re_set_one, (char *) b, (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. */ /* Blank line to finish off all those mention() messages we just printed. */

8
gdb/convex-tdep.c
View file

@ -339,12 +339,12 @@ value_of_trapped_internalvar (var)
if (!strcmp (name, "vl")) 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)); (LONGEST) *read_vector_register_1 (VL_REGNUM));
} }
else if (!strcmp (name, "vs")) 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)); (LONGEST) *read_vector_register_1 (VS_REGNUM));
} }
else if (!strcmp (name, "vm")) else if (!strcmp (name, "vm"))
@ -376,10 +376,10 @@ value_of_trapped_internalvar (var)
} }
else if (name[0] == 'c') 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]))); read_comm_register (atoi (&name[1])));
else if (name[0] == 'C') 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]))); read_comm_register (atoi (&name[1])));
VALUE_LVAL (val) = lval_internalvar; VALUE_LVAL (val) = lval_internalvar;

306
gdb/remote-vx.c
View file

@ -179,310 +179,6 @@ vx_remove_breakpoint (addr)
return net_break (addr, VX_BREAK_DELETE); 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. /* Start an inferior process and sets inferior_pid to its pid.
EXEC_FILE is the file to run. EXEC_FILE is the file to run.
ALLARGS is a string containing the arguments to the program. ALLARGS is a string containing the arguments to the program.
@ -1413,7 +1109,7 @@ vx_open (args, from_tty)
if (*bootFile) { if (*bootFile) {
printf_filtered ("\t%s: ", bootFile); printf_filtered ("\t%s: ", bootFile);
if (catch_errors (symbol_stub, 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"); puts_filtered ("ok\n");
} else if (from_tty) } else if (from_tty)
printf ("VxWorks kernel symbols not loaded.\n"); printf ("VxWorks kernel symbols not loaded.\n");

11
gdb/solib.c
View file

@ -269,7 +269,7 @@ solib_add (arg_string, from_tty, target)
so->symbols_loaded = 1; so->symbols_loaded = 1;
so->from_tty = from_tty; so->from_tty = from_tty;
catch_errors (symbol_add_stub, (char *)so, 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; int in_debugger;
CORE_ADDR in_debugger_addr; CORE_ADDR in_debugger_addr;
CORE_ADDR breakpoint_addr; CORE_ADDR breakpoint_addr;
int i; int i, j;
/* FIXME: We should look around in the executable code to find _DYNAMIC, /* 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... 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"); i = lookup_misc_func ("_DYNAMIC");
if (i < 0) /* Can't find shared lib ptr. */ if (i < 0) /* Can't find shared lib ptr. */
return; return;
if (misc_function_vector[i].address == 0) /* statically linked program */
return;
/* Get link_dynamic structure */ /* Get link_dynamic structure */
read_memory(misc_function_vector[i].address, j = target_read_memory(misc_function_vector[i].address,
&inferior_dynamic_cpy, &inferior_dynamic_cpy,
sizeof(struct link_dynamic)); sizeof(struct link_dynamic));
if (j) /* unreadable */
return;
/* Calc address of debugger interface structure */ /* Calc address of debugger interface structure */
inferior_debug_addr = (CORE_ADDR)inferior_dynamic_cpy.ldd; inferior_debug_addr = (CORE_ADDR)inferior_dynamic_cpy.ldd;
/* Calc address of `in_debugger' member of debugger interface structure */ /* Calc address of `in_debugger' member of debugger interface structure */

82
gdb/valops.c
View file

@ -3,19 +3,19 @@
This file is part of GDB. 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 it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 1, or (at your option) the Free Software Foundation; either version 2 of the License, or
any later version. (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 but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details. GNU General Public License for more details.
You should have received a copy of the GNU General Public License You should have received a copy of the GNU General Public License
along with GDB; see the file COPYING. If not, write to along with this program; if not, write to the Free Software
the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
#include <stdio.h> #include <stdio.h>
#include "defs.h" #include "defs.h"
@ -60,7 +60,7 @@ value_cast (type, arg2)
return value_from_double (type, value_as_double (arg2)); return value_from_double (type, value_as_double (arg2));
else if ((code1 == TYPE_CODE_INT || code1 == TYPE_CODE_ENUM) else if ((code1 == TYPE_CODE_INT || code1 == TYPE_CODE_ENUM)
&& (scalar || code2 == TYPE_CODE_PTR)) && (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))) else if (TYPE_LENGTH (type) == TYPE_LENGTH (VALUE_TYPE (arg2)))
{ {
if (code1 == TYPE_CODE_PTR && code2 == TYPE_CODE_PTR) 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 /* 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
value_coerce_array (arg1) value_coerce_array (arg1)
value arg1; value arg1;
{ {
register struct type *type; register struct type *type;
register value val;
if (VALUE_LVAL (arg1) != lval_memory) if (VALUE_LVAL (arg1) != lval_memory)
error ("Attempt to take address of value not located in 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. */ Its type is the type of the elements, not an array type. */
type = VALUE_TYPE (arg1); type = VALUE_TYPE (arg1);
/* Get the type of the result. */ return value_from_longest (lookup_pointer_type (type),
type = lookup_pointer_type (type);
val = value_from_long (builtin_type_long,
(LONGEST) (VALUE_ADDRESS (arg1) + VALUE_OFFSET (arg1))); (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 /* Given a value which is a function, return a value which is a pointer
@ -436,18 +432,12 @@ value
value_coerce_function (arg1) value_coerce_function (arg1)
value arg1; value arg1;
{ {
register struct type *type;
register value val;
if (VALUE_LVAL (arg1) != lval_memory) if (VALUE_LVAL (arg1) != lval_memory)
error ("Attempt to take address of value not located in memory."); error ("Attempt to take address of value not located in memory.");
/* Get the type of the result. */ return value_from_longest (lookup_pointer_type (VALUE_TYPE (arg1)),
type = lookup_pointer_type (VALUE_TYPE (arg1));
val = value_from_long (builtin_type_long,
(LONGEST) (VALUE_ADDRESS (arg1) + VALUE_OFFSET (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. */ /* Return a pointer value for the object for which ARG1 is the contents. */
@ -456,12 +446,8 @@ value
value_addr (arg1) value_addr (arg1)
value arg1; value arg1;
{ {
register struct type *type;
register value val;
COERCE_REF(arg1); 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) if (VALUE_REPEATED (arg1)
|| TYPE_CODE (VALUE_TYPE (arg1)) == TYPE_CODE_ARRAY) || TYPE_CODE (VALUE_TYPE (arg1)) == TYPE_CODE_ARRAY)
return value_coerce_array (arg1); return value_coerce_array (arg1);
@ -471,12 +457,8 @@ value_addr (arg1)
if (VALUE_LVAL (arg1) != lval_memory) if (VALUE_LVAL (arg1) != lval_memory)
error ("Attempt to take address of value not located in memory."); error ("Attempt to take address of value not located in memory.");
/* Get the type of the result. */ return value_from_longest (lookup_pointer_type (VALUE_TYPE (arg1)),
type = lookup_pointer_type (VALUE_TYPE (arg1));
val = value_from_long (builtin_type_long,
(LONGEST) (VALUE_ADDRESS (arg1) + VALUE_OFFSET (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. */ /* 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 #endif
/* The value we're going to pass is the address of the thing /* The value we're going to pass is the address of the thing
we just pushed. */ 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. */ #endif /* REG_STRUCT_HAS_ADDR. */
@ -940,17 +923,17 @@ value_string (ptr, len)
else else
{ {
register int j; register int j;
for (j = 0; j < misc_function_count; j++) j = lookup_misc_func ("malloc");
if (!strcmp (misc_function_vector[j].name, "malloc")) if (j >= 0)
break; val = value_from_longest (
if (j < misc_function_count) lookup_pointer_type (lookup_function_type (
val = value_from_long (builtin_type_long, lookup_pointer_type (builtin_type_char))),
(LONGEST) misc_function_vector[j].address); (LONGEST) misc_function_vector[j].address);
else else
error ("String constants require the program to have a function \"malloc\"."); 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); val = target_call_function (val, 1, &blocklen);
if (value_zerop (val)) if (value_zerop (val))
error ("No memory available for string constant."); error ("No memory available for string constant.");
@ -1333,19 +1316,17 @@ value_struct_elt_for_address (domain, intype, name)
struct symbol *sym = struct symbol *sym =
lookup_symbol (phys_name, 0, VAR_NAMESPACE, 0, NULL); lookup_symbol (phys_name, 0, VAR_NAMESPACE, 0, NULL);
if (! sym) error ("Internal error: could not find physical static variable named %s", phys_name); if (! sym) error ("Internal error: could not find physical static variable named %s", phys_name);
v = value_from_long(builtin_type_long, return value_from_longest (
(CORE_ADDR)SYMBOL_BLOCK_VALUE (sym)); lookup_pointer_type (TYPE_FIELD_TYPE (t, i)),
VALUE_TYPE(v) = lookup_pointer_type (TYPE_FIELD_TYPE (t, i)); (LONGEST)SYMBOL_BLOCK_VALUE (sym));
return v;
} }
if (TYPE_FIELD_PACKED (t, i)) if (TYPE_FIELD_PACKED (t, i))
error ("pointers to bitfield members not allowed"); 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)); (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); check_stub_method (t, i, j);
if (TYPE_FN_FIELD_VIRTUAL_P (f, 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)); (LONGEST) TYPE_FN_FIELD_VOFFSET (f, j));
} }
else else
@ -1402,9 +1386,9 @@ value_struct_elt_for_address (domain, intype, name)
struct symbol *s = lookup_symbol (TYPE_FN_FIELD_PHYSNAME (f, j), struct symbol *s = lookup_symbol (TYPE_FN_FIELD_PHYSNAME (f, j),
0, VAR_NAMESPACE, 0, NULL); 0, VAR_NAMESPACE, 0, NULL);
v = locate_var_value (s, 0); 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;
} }
} }