+Wed Mar 2 09:17:55 1994 Jim Kingdon (kingdon@deneb.cygnus.com)
+
+ * breakpoint.c, breakpoint.h, c-valprint.c, ch-valprint.c,
+ cp-valprint.c, eval.c, expprint.c, findvar.c, language.c,
+ objfiles.h, infcmd.c, printcmd.c, stack.c, typeprint.c,
+ valarith.c, valops.c, valprint.c, value.h, values.c: Replace
+ value with value_ptr. This is for the ptx compiler.
+ * objfiles.h, target.h: Don't declare a "sec_ptr" field using a
+ "sec_ptr" typedef.
+ * symm-nat.c: Add a bunch of stuff for symmetry's ptrace stuff.
+ #if 0 i386_float_info.
+ * symm-tdep.c (round): Remove. Also remove sgttyb.
+ * symm-tdep.c: Remove lots of stuff which duplicates stuff from
+ i386-tdep.c. Remove register_addr and ptx_coff_regno_to_gdb.
+ * i386-tdep.c (i386_frame_find_saved_regs): Put in
+ I386_REGNO_TO_SYMMETRY check in case it is needed for Dynix
+ someday.
+ * config/i386/nm-symmetry.h: Change KERNEL_U_ADDR. Move
+ stuff from PTRACE_READ_REGS, PTRACE_WRITE_REGS macros to
+ symm-nat.c. Define CHILD_WAIT and declare child_wait().
+ * config/i386/tm-symmetry.h: Remove call function stuff; stuff in
+ tm-i386v.h is apparently OK.
+ * config/i386/xm-symmetry.h [_SEQUENT_]: Define HAVE_TERMIOS not
+ HAVE_TERMIO. Define MEM_FNS_DECLARED, NEED_POSIX_SETPGID, and
+ USE_O_NOCTTY.
+
Wed Mar 2 11:31:08 1994 Peter Schauer (pes@regent.e-technik.tu-muenchen.de)
* osfsolib.c (xfer_link_map_member): Update to use new
to pass to lookup_internalvar(). */
char *varname;
char *start = ++p;
- value val;
+ value_ptr val;
while (isalnum (*p) || *p == '_')
p++;
call free_all_values. We can't call free_all_values because
we might be in the middle of evaluating a function call. */
- value mark = value_mark ();
- value new_val = evaluate_expression (bs->breakpoint_at->exp);
+ value_ptr mark = value_mark ();
+ value_ptr new_val = evaluate_expression (bs->breakpoint_at->exp);
if (!value_equal (bs->breakpoint_at->val, new_val))
{
release_value (new_val);
}
if (vt_address && vtblprint)
{
- value vt_val;
+ value_ptr vt_val;
struct symbol *wsym = (struct symbol *)NULL;
struct type *wtype;
struct symtab *s;
{
if (TYPE_CODE (TYPE_TARGET_TYPE (type)) != TYPE_CODE_UNDEF)
{
- value deref_val =
+ value_ptr deref_val =
value_at
(TYPE_TARGET_TYPE (type),
unpack_pointer (lookup_pointer_type (builtin_type_void),
{
if (TYPE_CODE (TYPE_TARGET_TYPE (type)) != TYPE_CODE_UNDEF)
{
- value deref_val =
+ value_ptr deref_val =
value_at
(TYPE_TARGET_TYPE (type),
unpack_pointer (lookup_pointer_type (builtin_type_void),
fputs_filtered (": ", stream);
if (TYPE_FIELD_PACKED (type, i))
{
- value v;
+ value_ptr v;
/* Bitfields require special handling, especially due to byte
order problems. */
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
-#ifdef _SEQUENT_
-/* ptx */
-#define PTRACE_READ_REGS(pid,regaddr) mptrace (XPT_RREGS, (pid), (regaddr), 0)
-#define PTRACE_WRITE_REGS(pid,regaddr) \
- mptrace (XPT_WREGS, (pid), (regadddr), 0)
-#else
-/* dynix */
-#define PTRACE_READ_REGS(pid,regaddr) ptrace (XPT_RREGS, (pid), (regaddr), 0)
-#define PTRACE_WRITE_REGS(pid,regaddr) \
- ptrace (XPT_WREGS, (pid), (regadddr), 0)
-#endif
-
/* Override copies of {fetch,store}_inferior_registers in infptrace.c. */
#define FETCH_INFERIOR_REGISTERS
+#ifdef _SEQUENT_
+#define CHILD_WAIT
+extern int child_wait PARAMS ((int, struct target_waitstatus *));
+#endif
+
/* This is the amount to subtract from u.u_ar0
to get the offset in the core file of the register values. */
#ifdef _SEQUENT_
-#define KERNEL_U_ADDR (0xffffe000) /* VA_UBLOCK */ /* ptx */
+#include <sys/param.h>
+#include <sys/user.h>
+#include <sys/mc_vmparam.h>
+/* VA_UAREA is defined in <sys/mc_vmparam.h>, and is dependant upon
+ sizeof(struct user) */
+#define KERNEL_U_ADDR (VA_UAREA) /* ptx */
#else
#define KERNEL_U_ADDR (0x80000000 - (UPAGES * NBPG)) /* dynix */
#endif
/* ptx, not dynix */
#define SDB_REG_TO_REGNUM(value) ptx_coff_regno_to_gdb(value)
extern int ptx_coff_regno_to_gdb();
+
#endif /* _SEQUENT_ */
#define START_INFERIOR_TRAPS_EXPECTED 2
/* For Symmetry, this is really the 'leave' instruction, which */
/* is right before the ret */
-#undef
+#undef ABOUT_TO_RETURN
#define ABOUT_TO_RETURN(pc) (read_memory_integer (pc, 1) == 0xc9)
#if 0
/* Get %fp2 - %fp31 by addition, since they are contiguous */
#undef SP_REGNUM
-#define SP_REGNUM 14 /* Contains address of top of stack */
+#define SP_REGNUM 14 /* esp--Contains address of top of stack */
+#define ESP_REGNUM 14
#undef FP_REGNUM
-#define FP_REGNUM 15 /* Contains address of executing stack frame */
+#define FP_REGNUM 15 /* ebp--Contains address of executing stack frame */
+#define EBP_REGNUM 15
#undef PC_REGNUM
-#define PC_REGNUM 16 /* Contains program counter */
+#define PC_REGNUM 16 /* eip--Contains program counter */
+#define EIP_REGNUM 16
#undef PS_REGNUM
-#define PS_REGNUM 17 /* Contains processor status */
+#define PS_REGNUM 17 /* eflags--Contains processor status */
+#define EFLAGS_REGNUM 17
#ifndef _SEQUENT_
/* dynix, not ptx. For ptx, see register_addr in symm-tdep.c */
((int) &foo.u_fpasave.fpa_regs[(regno)-18] - (int)&foo); \
} \
}
+#endif /* not _SEQUENT_ */
+
+#ifdef _SEQUENT_
+/* ptx. For Dynix, see above */
+
+/*
+ * For ptx, this is a little bit bizarre, since the register block
+ * is below the u area in memory. This means that blockend here ends
+ * up being negative (for the call from coredep.c) since the value in
+ * u.u_ar0 will be less than KERNEL_U_ADDR (and coredep.c passes us
+ * u.u_ar0 - KERNEL_U_ADDR in blockend). Since we also define
+ * FETCH_INFERIOR_REGISTERS (and supply our own functions for that),
+ * the core file case will be the only use of this function.
+ */
+
+#define REGISTER_U_ADDR(addr, blockend, regno) \
+{ struct user foo; /* needed for finding fpu regs */ \
+switch (regno) { \
+ case 0: \
+ addr = blockend + (NBPG * UPAGES) - sizeof(struct user) + (EAX * sizeof(int)); break; \
+ case 1: \
+ addr = blockend + (NBPG * UPAGES) - sizeof(struct user) + (EDX * sizeof(int)); break; \
+ case 2: \
+ addr = blockend + (NBPG * UPAGES) - sizeof(struct user) + (ECX * sizeof(int)); break; \
+ case 3: /* st(0) */ \
+ addr = blockend - KERNEL_U_ADDR + \
+ ((int)&foo.u_fpusave.fpu_stack[0][0] - (int)&foo); \
+ break; \
+ case 4: /* st(1) */ \
+ addr = blockend - KERNEL_U_ADDR + \
+ ((int) &foo.u_fpusave.fpu_stack[1][0] - (int)&foo); \
+ break; \
+ case 5: \
+ addr = blockend + (NBPG * UPAGES) - sizeof(struct user) + (EBX * sizeof(int)); break; \
+ case 6: \
+ addr = blockend + (NBPG * UPAGES) - sizeof(struct user) + (ESI * sizeof(int)); break; \
+ case 7: \
+ addr = blockend + (NBPG * UPAGES) - sizeof(struct user) + (EDI * sizeof(int)); break; \
+ case 8: /* st(2) */ \
+ addr = blockend - KERNEL_U_ADDR + \
+ ((int) &foo.u_fpusave.fpu_stack[2][0] - (int)&foo); \
+ break; \
+ case 9: /* st(3) */ \
+ addr = blockend - KERNEL_U_ADDR + \
+ ((int) &foo.u_fpusave.fpu_stack[3][0] - (int)&foo); \
+ break; \
+ case 10: /* st(4) */ \
+ addr = blockend - KERNEL_U_ADDR + \
+ ((int) &foo.u_fpusave.fpu_stack[4][0] - (int)&foo); \
+ break; \
+ case 11: /* st(5) */ \
+ addr = blockend - KERNEL_U_ADDR + \
+ ((int) &foo.u_fpusave.fpu_stack[5][0] - (int)&foo); \
+ break; \
+ case 12: /* st(6) */ \
+ addr = blockend - KERNEL_U_ADDR + \
+ ((int) &foo.u_fpusave.fpu_stack[6][0] - (int)&foo); \
+ break; \
+ case 13: /* st(7) */ \
+ addr = blockend - KERNEL_U_ADDR + \
+ ((int) &foo.u_fpusave.fpu_stack[7][0] - (int)&foo); \
+ break; \
+ case 14: \
+ addr = blockend + (NBPG * UPAGES) - sizeof(struct user) + (ESP * sizeof(int)); break; \
+ case 15: \
+ addr = blockend + (NBPG * UPAGES) - sizeof(struct user) + (EBP * sizeof(int)); break; \
+ case 16: \
+ addr = blockend + (NBPG * UPAGES) - sizeof(struct user) + (EIP * sizeof(int)); break; \
+ case 17: \
+ addr = blockend + (NBPG * UPAGES) - sizeof(struct user) + (FLAGS * sizeof(int)); break; \
+ case 18: /* fp1 */ \
+ case 19: /* fp2 */ \
+ case 20: /* fp3 */ \
+ case 21: /* fp4 */ \
+ case 22: /* fp5 */ \
+ case 23: /* fp6 */ \
+ case 24: /* fp7 */ \
+ case 25: /* fp8 */ \
+ case 26: /* fp9 */ \
+ case 27: /* fp10 */ \
+ case 28: /* fp11 */ \
+ case 29: /* fp12 */ \
+ case 30: /* fp13 */ \
+ case 31: /* fp14 */ \
+ case 32: /* fp15 */ \
+ case 33: /* fp16 */ \
+ case 34: /* fp17 */ \
+ case 35: /* fp18 */ \
+ case 36: /* fp19 */ \
+ case 37: /* fp20 */ \
+ case 38: /* fp21 */ \
+ case 39: /* fp22 */ \
+ case 40: /* fp23 */ \
+ case 41: /* fp24 */ \
+ case 42: /* fp25 */ \
+ case 43: /* fp26 */ \
+ case 44: /* fp27 */ \
+ case 45: /* fp28 */ \
+ case 46: /* fp29 */ \
+ case 47: /* fp30 */ \
+ case 48: /* fp31 */ \
+ addr = blockend - KERNEL_U_ADDR + \
+ ((int) &foo.u_fpasave.fpa_regs[(regno)-18] - (int)&foo); \
+ } \
+}
#endif /* _SEQUENT_ */
\f
+#undef FRAME_CHAIN
+#define FRAME_CHAIN(thisframe) ((thisframe)->pc == 0 ? \
+ 0 : read_memory_integer((thisframe)->frame, 4))
+
+#define FRAME_CHAIN_VALID(chain, thisframe) \
+ ((chain) != 0)
+
+#undef FRAME_ARGS_SKIP
+#define FRAME_ARGS_SKIP 0
+
/* Total amount of space needed to store our copies of the machine's
register state, the array `registers'. */
/* 10 i386 registers, 8 i387 registers, and 31 Weitek 1167 registers */
symmetry_extract_return_value(TYPE, REGBUF, VALBUF)
\f
-/* Things needed for making the inferior call functions. FIXME: Merge
- this with the main 386 stuff. */
-
-#define PUSH_DUMMY_FRAME \
-{ CORE_ADDR sp = read_register (SP_REGNUM); \
- int regnum; \
- sp = push_word (sp, read_register (PC_REGNUM)); \
- sp = push_word (sp, read_register (FP_REGNUM)); \
- write_register (FP_REGNUM, sp); \
- for (regnum = 0; regnum < NUM_REGS; regnum++) \
- sp = push_word (sp, read_register (regnum)); \
- write_register (SP_REGNUM, sp); \
-}
-
-#define POP_FRAME \
-{ \
- FRAME frame = get_current_frame (); \
- CORE_ADDR fp; \
- int regnum; \
- struct frame_saved_regs fsr; \
- struct frame_info *fi; \
- fi = get_frame_info (frame); \
- fp = fi->frame; \
- get_frame_saved_regs (fi, &fsr); \
- for (regnum = 0; regnum < NUM_REGS; regnum++) { \
- CORE_ADDR adr; \
- adr = fsr.regs[regnum]; \
- if (adr) \
- write_register (regnum, read_memory_integer (adr, 4)); \
- } \
- write_register (FP_REGNUM, read_memory_integer (fp, 4)); \
- write_register (PC_REGNUM, read_memory_integer (fp + 4, 4)); \
- write_register (SP_REGNUM, fp + 8); \
- flush_cached_frames (); \
- set_current_frame ( create_new_frame (read_register (FP_REGNUM), \
- read_pc ())); \
-}
-
-/* from i386-dep.c, worked better than my original... */
-/* This sequence of words is the instructions
- * call (32-bit offset)
- * int 3
- * This is 6 bytes.
- */
-
-#define CALL_DUMMY { 0x223344e8, 0xcc11 }
-
-#define CALL_DUMMY_LENGTH 8
-
-#define CALL_DUMMY_START_OFFSET 0 /* Start execution at beginning of dummy */
-
-/* Insert the specified number of args and function address
- into a call sequence of the above form stored at DUMMYNAME. */
-
-#define FIX_CALL_DUMMY(dummyname, pc, fun, nargs, args, type, gcc_p) \
-{ \
- int from, to, delta, loc; \
- loc = (int)(read_register (SP_REGNUM) - CALL_DUMMY_LENGTH); \
- from = loc + 5; \
- to = (int)(fun); \
- delta = to - from; \
- *(int *)((char *)(dummyname) + 1) = delta; \
-}
-
extern void
print_387_control_word PARAMS ((unsigned int));
#ifdef _SEQUENT_
/* ptx */
-#define HAVE_TERMIO
+#define HAVE_TERMIOS
#define USG
+
+#define MEM_FNS_DECLARED
+
+#define NEED_POSIX_SETPGID
+
+#define USE_O_NOCTTY
+
#else
/* dynix */
#define PTRACE_DETACH XPT_UNDEBUG
#define ATTACH_DETACH */
+#ifdef _SEQUENT_
+/* ptx does attach as of ptx version 2.1 */
+#define ATTACH_DETACH 1
+
#define HOST_BYTE_ORDER LITTLE_ENDIAN
/* We must fetch all the regs before storing, since we store all at once. */
}
if (TYPE_FIELD_PACKED (type, i))
{
- value v;
+ value_ptr v;
/* Bitfields require special handling, especially due to byte
order problems. */
#if 0 /* Currently unused */
struct type *
-binop_result_type(v1,v2)
- value v1,v2;
+binop_result_type (v1, v2)
+ value_ptr v1, v2;
{
int l1,l2,size,uns;
/* Returns non-zero if the value VAL represents a true value. */
int
value_true (val)
- value val;
+ value_ptr val;
{
/* It is possible that we should have some sort of error if a non-boolean
value is used in this context. Possibly dependent on some kind of
void
binop_type_check(arg1,arg2,op)
- value arg1,arg2;
+ value_ptr arg1,arg2;
int op;
{
struct type *t1, *t2;
return;
t1=VALUE_TYPE(arg1);
- if (arg2!=(value)NULL)
+ if (arg2 != NULL)
t2=VALUE_TYPE(arg2);
else
t2=NULL;
addresses", but that's not true; addr & endaddr are actual memory
addresses. */
CORE_ADDR offset;
-
- sec_ptr sec_ptr; /* BFD section pointer */
+
+ /* For the ptx compiler, we can't use the sec_ptr typedef when the field's
+ name is sec_ptr. We really should rename the field (or better yet,
+ the typedef should be bfd_sec_ptr). */
+ struct sec *sec_ptr; /* BFD section pointer */
/* Objfile this section is part of. Not currently used, but I'm sure
that someone will want the bfd that the sec_ptr goes with or something
/* Contents of last address examined.
This is not valid past the end of the `x' command! */
-static value last_examine_value;
+static value_ptr last_examine_value;
/* Largest offset between a symbolic value and an address, that will be
printed as `0x1234 <symbol+offset>'. */
do_examine PARAMS ((struct format_data, CORE_ADDR));
static void
-print_formatted PARAMS ((value, int, int));
+print_formatted PARAMS ((value_ptr, int, int));
static struct format_data
decode_format PARAMS ((char **, int, int));
break;
}
-#ifndef CC_HAS_LONG_LONG
- /* Make sure 'g' size is not used on integer types.
- Well, actually, we can handle hex. */
- if (val.size == 'g' && val.format != 'f' && val.format != 'x')
- val.size = 'w';
-#endif
-
while (*p == ' ' || *p == '\t') p++;
*string_ptr = p;
{
case 'a':
case 's':
- /* Addresses must be words. */
+ /* Pick the appropriate size for an address. */
+#if TARGET_PTR_BIT == 64
+ val.size = osize ? 'g' : osize;
+ break;
+#else /* Not 64 */
+#if TARGET_PTR_BIT == 32
val.size = osize ? 'w' : osize;
break;
+#else /* Not 32 */
+#if TARGET_PTR_BIT == 16
+ val.size = osize ? 'h' : osize;
+ break;
+#else /* Not 16 */
+ #error Bad value for TARGET_PTR_BIT
+#endif /* Not 16 */
+#endif /* Not 32 */
+#endif /* Not 64 */
+ break;
case 'f':
/* Floating point has to be word or giantword. */
if (osize == 'w' || osize == 'g')
static void
print_formatted (val, format, size)
- register value val;
+ register value_ptr val;
register int format;
int size;
{
struct expression *expr;
register struct cleanup *old_chain = 0;
register char format = 0;
- register value val;
+ register value_ptr val;
struct format_data fmt;
int cleanup = 0;
&& ( TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_STRUCT
|| TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_UNION))
{
- value v;
+ value_ptr v;
v = value_from_vtable_info (val, TYPE_TARGET_TYPE (type));
if (v != 0)
struct expression *expr;
register struct cleanup *old_chain;
register char format = 0;
- register value val;
+ register value_ptr val;
struct format_data fmt;
if (exp && *exp == '/')
FRAME frame;
GDB_FILE *stream;
{
- value val = read_var_value (var, frame);
+ value_ptr val = read_var_value (var, frame);
value_print (val, stream, 0, Val_pretty_default);
}
int first = 1;
register int i;
register struct symbol *sym;
- register value val;
+ register value_ptr val;
/* Offset of next stack argument beyond the one we have seen that is
at the highest offset.
-1 if we haven't come to a stack argument yet. */
register char *f;
register char *s = arg;
char *string;
- value *val_args;
+ value_ptr *val_args;
char *substrings;
char *current_substring;
int nargs = 0;
int allocated_args = 20;
struct cleanup *old_cleanups;
- val_args = (value *) xmalloc (allocated_args * sizeof (value));
+ val_args = (value_ptr *) xmalloc (allocated_args * sizeof (value_ptr));
old_cleanups = make_cleanup (free_current_contents, &val_args);
if (s == 0)
case '\\':
*f++ = '\\';
break;
+ case 'a':
+#ifdef __STDC__
+ *f++ = '\a';
+#else
+ *f++ = '\007'; /* Bell */
+#endif
+ break;
+ case 'b':
+ *f++ = '\b';
+ break;
+ case 'f':
+ *f++ = '\f';
+ break;
case 'n':
*f++ = '\n';
break;
+ case 'r':
+ *f++ = '\r';
+ break;
case 't':
*f++ = '\t';
break;
- case 'r':
- *f++ = '\r';
+ case 'v':
+ *f++ = '\v';
break;
case '"':
*f++ = '"';
break;
default:
/* ??? TODO: handle other escape sequences */
- error ("Unrecognized \\ escape character in format string.");
+ error ("Unrecognized escape character \\%c in format string.",
+ c);
}
break;
{
char *s1;
if (nargs == allocated_args)
- val_args = (value *) xrealloc ((char *) val_args,
- (allocated_args *= 2)
- * sizeof (value));
+ val_args = (value_ptr *) xrealloc ((char *) val_args,
+ (allocated_args *= 2)
+ * sizeof (value_ptr));
s1 = s;
val_args[nargs] = parse_to_comma_and_eval (&s1);
/* Sequent Symmetry host interface, for GDB when running under Unix.
- Copyright 1986, 1987, 1989, 1991, 1992 Free Software Foundation, Inc.
+ Copyright 1986, 1987, 1989, 1991, 1992, 1994 Free Software Foundation, Inc.
This file is part of GDB.
#include "frame.h"
#include "inferior.h"
#include "symtab.h"
+#include "target.h"
+/* FIXME: What is the _INKERNEL define for? */
+#define _INKERNEL
#include <signal.h>
+#undef _INKERNEL
+#include <sys/wait.h>
#include <sys/param.h>
#include <sys/user.h>
+#include <sys/proc.h>
#include <sys/dir.h>
#include <sys/ioctl.h>
#include <sys/stat.h>
+#include <sys/ptrace.h>
#include "gdbcore.h"
#include <fcntl.h>
#include <sgtty.h>
regs.pr_fpa.fpa_regs[i] =
*(int *)®isters[REGISTER_BYTE(FP1_REGNUM+i)];
}
- PTRACE_WRITE_REGS (inferior_pid, (PTRACE_ARG3_TYPE) ®s);
+ mptrace (XPT_WREGS, inferior_pid, (PTRACE_ARG3_TYPE) ®s, 0);
}
void
registers_fetched ();
- PTRACE_READ_REGS (inferior_pid, (PTRACE_ARG3_TYPE) ®s);
+ mptrace (XPT_RREGS, (pid), (regaddr), 0);
*(int *)®isters[REGISTER_BYTE(EAX_REGNUM)] = regs.pr_eax;
*(int *)®isters[REGISTER_BYTE(EBX_REGNUM)] = regs.pr_ebx;
*(int *)®isters[REGISTER_BYTE(ECX_REGNUM)] = regs.pr_ecx;
for (i = 9; i >= 0; i--)
printf_unfiltered ("%02x", ep.pr_fpu.fpu_stack[fpreg][i]);
- i387_to_double (ep.pr_fpu.fpu_stack[fpreg], (char *)&val);
+ i387_to_double ((char *)ep.pr_fpu.fpu_stack[fpreg], (char *)&val);
printf_unfiltered (" %g\n", val);
}
if (ep.pr_fpu.fpu_rsvd1)
if (pcr_tmp & FPA_PCR_20MHZ) printf_unfiltered(" 20MHZ");
if (pcr_tmp & FPA_PCR_CC_Z) printf_unfiltered(" Z");
if (pcr_tmp & FPA_PCR_CC_C2) printf_unfiltered(" C2");
+
+ /* Dynix defines FPA_PCR_CC_C0 to 0x100 and ptx defines
+ FPA_PCR_CC_C1 to 0x100. Use whichever is defined and assume
+ the OS knows what it is doing. */
+#ifdef FPA_PCR_CC_C1
if (pcr_tmp & FPA_PCR_CC_C1) printf_unfiltered(" C1");
- switch (pcr_tmp) {
- case FPA_PCR_CC_Z:
+#endif
+#ifdef FPA_PCR_CC_C0
+ if (pcr_tmp & FPA_PCR_CC_C1) printf_unfiltered(" C0");
+#endif
+
+ switch (pcr_tmp)
+ {
+ case FPA_PCR_CC_Z:
printf_unfiltered(" (Equal)");
break;
- case FPA_PCR_CC_C1:
+#ifdef FPA_PCR_CC_C1
+ case FPA_PCR_CC_C1:
+#endif
+#ifdef FPA_PCR_CC_C0
+ case FPA_PCR_CC_C0:
+#endif
printf_unfiltered(" (Less than)");
break;
- case 0:
+ case 0:
printf_unfiltered(" (Greater than)");
break;
- case FPA_PCR_CC_Z | FPA_PCR_CC_C1 | FPA_PCR_CC_C2:
+ case FPA_PCR_CC_Z |
+#ifdef FPA_PCR_CC_C1
+ FPA_PCR_CC_C1
+#else
+ FPA_PCR_CC_C0
+#endif
+ | FPA_PCR_CC_C2:
printf_unfiltered(" (Unordered)");
break;
- default:
+ default:
printf_unfiltered(" (Undefined)");
break;
- }
+ }
printf_unfiltered("\n");
pcr_tmp = pcr & FPA_PCR_AE;
printf_unfiltered("\tAE= %#x", pcr_tmp);
}
}
+#if 0 /* disabled because it doesn't go through the target vector. */
i386_float_info ()
{
char ubuf[UPAGES*NBPG];
print_fpu_status(regset);
print_fpa_status(regset);
}
+#endif
+
+static volatile int got_sigchld;
+
+/*ARGSUSED*/
+/* This will eventually be more interesting. */
+void
+sigchld_handler(signo)
+ int signo;
+{
+ got_sigchld++;
+}
+
+/*
+ * Signals for which the default action does not cause the process
+ * to die. See <sys/signal.h> for where this came from (alas, we
+ * can't use those macros directly)
+ */
+#ifndef sigmask
+#define sigmask(s) (1 << ((s) - 1))
+#endif
+#define SIGNALS_DFL_SAFE sigmask(SIGSTOP) | sigmask(SIGTSTP) | \
+ sigmask(SIGTTIN) | sigmask(SIGTTOU) | sigmask(SIGCHLD) | \
+ sigmask(SIGCONT) | sigmask(SIGWINCH) | sigmask(SIGPWR) | \
+ sigmask(SIGURG) | sigmask(SIGPOLL)
+
+
+/*
+ * Thanks to XPT_MPDEBUGGER, we have to mange child_wait().
+ */
+int
+child_wait(pid, status)
+ int pid;
+ struct target_waitstatus *status;
+{
+ int save_errno, rv, xvaloff, saoff, sa_hand;
+ struct pt_stop pt;
+ struct user u;
+ sigset_t set;
+ /* Host signal number for a signal which the inferior terminates with, or
+ 0 if it hasn't terminated due to a signal. */
+ static int death_by_signal = 0;
+#ifdef SVR4_SHARED_LIBS /* use this to distinguish ptx 2 vs ptx 4 */
+ prstatus_t pstatus;
+#endif
+
+ do {
+ if (attach_flag)
+ set_sigint_trap(); /* Causes SIGINT to be passed on to the
+ attached process. */
+ save_errno = errno;
+
+ got_sigchld = 0;
+
+ sigemptyset(&set);
+
+ while (got_sigchld == 0) {
+ sigsuspend(&set);
+ }
+
+ if (attach_flag)
+ clear_sigint_trap();
+
+ rv = mptrace(XPT_STOPSTAT, 0, (char *)&pt, 0);
+ if (-1 == rv) {
+ printf("XPT_STOPSTAT: errno %d\n", errno); /* DEBUG */
+ continue;
+ }
+
+ pid = pt.ps_pid;
+
+ if (pid != inferior_pid) {
+ /* NOTE: the mystery fork in csh/tcsh needs to be ignored.
+ * We should not return new children for the initial run
+ * of a process until it has done the exec.
+ */
+ /* inferior probably forked; send it on its way */
+ rv = mptrace(XPT_UNDEBUG, pid, 0, 0);
+ if (-1 == rv) {
+ printf("child_wait: XPT_UNDEBUG: pid %d: %s\n", pid,
+ safe_strerror(errno));
+ }
+ continue;
+ }
+ /* FIXME: Do we deal with fork notification correctly? */
+ switch (pt.ps_reason) {
+ case PTS_FORK:
+ /* multi proc: treat like PTS_EXEC */
+ /*
+ * Pretend this didn't happen, since gdb isn't set up
+ * to deal with stops on fork.
+ */
+ rv = ptrace(PT_CONTSIG, pid, 1, 0);
+ if (-1 == rv) {
+ printf("PTS_FORK: PT_CONTSIG: error %d\n", errno);
+ }
+ continue;
+ case PTS_EXEC:
+ /*
+ * Pretend this is a SIGTRAP.
+ */
+ status->kind = TARGET_WAITKIND_STOPPED;
+ status->value.sig = TARGET_SIGNAL_TRAP;
+ break;
+ case PTS_EXIT:
+ /*
+ * Note: we stop before the exit actually occurs. Extract
+ * the exit code from the uarea. If we're stopped in the
+ * exit() system call, the exit code will be in
+ * u.u_ap[0]. An exit due to an uncaught signal will have
+ * something else in here, see the comment in the default:
+ * case, below. Finally,let the process exit.
+ */
+ if (death_by_signal)
+ {
+ status->kind = TARGET_WAITKIND_SIGNALED;
+ status->value.sig = target_signal_from_host (death_by_signal);
+ death_by_signal = 0;
+ break;
+ }
+ xvaloff = (unsigned long)&u.u_ap[0] - (unsigned long)&u;
+ errno = 0;
+ rv = ptrace(PT_RUSER, pid, (char *)xvaloff, 0);
+ status->kind = TARGET_WAITKIND_EXITED;
+ status->value.integer = rv;
+ /*
+ * addr & data to mptrace() don't matter here, since
+ * the process is already dead.
+ */
+ rv = mptrace(XPT_UNDEBUG, pid, 0, 0);
+ if (-1 == rv) {
+ printf("child_wait: PTS_EXIT: XPT_UNDEBUG: pid %d error %d\n", pid,
+ errno);
+ }
+ break;
+ case PTS_WATCHPT_HIT:
+ fatal("PTS_WATCHPT_HIT\n");
+ break;
+ default:
+ /* stopped by signal */
+ status->kind = TARGET_WAITKIND_STOPPED;
+ status->value.sig = target_signal_from_host (pt.ps_reason);
+ death_by_signal = 0;
+
+ if (0 == (SIGNALS_DFL_SAFE & sigmask(pt.ps_reason))) {
+ break;
+ }
+ /* else default action of signal is to die */
+#ifdef SVR4_SHARED_LIBS
+ rv = ptrace(PT_GET_PRSTATUS, pid, (char *)&pstatus, 0);
+ if (-1 == rv)
+ error("child_wait: signal %d PT_GET_PRSTATUS: %s\n",
+ pt.ps_reason, safe_strerror(errno));
+ if (pstatus.pr_cursig != pt.ps_reason) {
+ printf("pstatus signal %d, pt signal %d\n",
+ pstatus.pr_cursig, pt.ps_reason);
+ }
+ sa_hand = (int)pstatus.pr_action.sa_handler;
+#else
+ saoff = (unsigned long)&u.u_sa[0] - (unsigned long)&u;
+ saoff += sizeof(struct sigaction) * (pt.ps_reason - 1);
+ errno = 0;
+ sa_hand = ptrace(PT_RUSER, pid, (char *)saoff, 0);
+ if (errno)
+ error("child_wait: signal %d: RUSER: %s\n",
+ pt.ps_reason, safe_strerror(errno));
+#endif
+ if ((int)SIG_DFL == sa_hand) {
+ /* we will be dying */
+ death_by_signal = pt.ps_reason;
+ }
+ break;
+ }
+
+ } while (pid != inferior_pid); /* Some other child died or stopped */
+
+ return pid;
+}
+
+
+\f
+/* This function simply calls ptrace with the given arguments.
+ It exists so that all calls to ptrace are isolated in this
+ machine-dependent file. */
+int
+call_ptrace (request, pid, addr, data)
+ int request, pid;
+ PTRACE_ARG3_TYPE addr;
+ int data;
+{
+ return ptrace (request, pid, addr, data);
+}
+
+int
+call_mptrace(request, pid, addr, data)
+ int request, pid;
+ PTRACE_ARG3_TYPE addr;
+ int data;
+{
+ return mptrace(request, pid, addr, data);
+}
+
+#if defined (DEBUG_PTRACE)
+/* For the rest of the file, use an extra level of indirection */
+/* This lets us breakpoint usefully on call_ptrace. */
+#define ptrace call_ptrace
+#define mptrace call_mptrace
+#endif
+
+void
+kill_inferior ()
+{
+ if (inferior_pid == 0)
+ return;
+ /*
+ * Don't use PT_KILL, since the child will stop again with a PTS_EXIT.
+ * Just hit him with SIGKILL (so he stops) and detach.
+ */
+ kill (inferior_pid, SIGKILL);
+ detach(SIGKILL);
+ target_mourn_inferior ();
+}
+
+/* Resume execution of the inferior process.
+ If STEP is nonzero, single-step it.
+ If SIGNAL is nonzero, give it that signal. */
+
+void
+child_resume (pid, step, signal)
+ int pid;
+ int step;
+ int signal;
+{
+ errno = 0;
+
+ if (pid == -1)
+ pid = inferior_pid;
+
+ /* An address of (PTRACE_ARG3_TYPE)1 tells ptrace to continue from where
+ it was. (If GDB wanted it to start some other way, we have already
+ written a new PC value to the child.)
+
+ If this system does not support PT_SSTEP, a higher level function will
+ have called single_step() to transmute the step request into a
+ continue request (by setting breakpoints on all possible successor
+ instructions), so we don't have to worry about that here. */
+
+ if (step)
+ ptrace (PT_SSTEP, pid, (PTRACE_ARG3_TYPE) 1, signal);
+ else
+ ptrace (PT_CONTSIG, pid, (PTRACE_ARG3_TYPE) 1, signal);
+
+ if (errno)
+ perror_with_name ("ptrace");
+}
+\f
+#ifdef ATTACH_DETACH
+/* Start debugging the process whose number is PID. */
+int
+attach (pid)
+ int pid;
+{
+ sigset_t set;
+ int rv;
+
+ rv = mptrace(XPT_DEBUG, pid, 0, 0);
+ if (-1 == rv) {
+ error("mptrace(XPT_DEBUG): %s", safe_strerror(errno));
+ }
+ rv = mptrace(XPT_SIGNAL, pid, 0, SIGSTOP);
+ if (-1 == rv) {
+ error("mptrace(XPT_SIGNAL): %s", safe_strerror(errno));
+ }
+ attach_flag = 1;
+ return pid;
+}
+
+void
+detach (signo)
+ int signo;
+{
+ int rv;
+
+ rv = mptrace(XPT_UNDEBUG, inferior_pid, 1, signo);
+ if (-1 == rv) {
+ error("mptrace(XPT_UNDEBUG): %s", safe_strerror(errno));
+ }
+ attach_flag = 0;
+}
+
+#endif /* ATTACH_DETACH */
+\f
+/* Default the type of the ptrace transfer to int. */
+#ifndef PTRACE_XFER_TYPE
+#define PTRACE_XFER_TYPE int
+#endif
+
+\f
+/* NOTE! I tried using PTRACE_READDATA, etc., to read and write memory
+ in the NEW_SUN_PTRACE case.
+ It ought to be straightforward. But it appears that writing did
+ not write the data that I specified. I cannot understand where
+ it got the data that it actually did write. */
+
+/* Copy LEN bytes to or from inferior's memory starting at MEMADDR
+ to debugger memory starting at MYADDR. Copy to inferior if
+ WRITE is nonzero.
+
+ Returns the length copied, which is either the LEN argument or zero.
+ This xfer function does not do partial moves, since child_ops
+ doesn't allow memory operations to cross below us in the target stack
+ anyway. */
+
+int
+child_xfer_memory (memaddr, myaddr, len, write, target)
+ CORE_ADDR memaddr;
+ char *myaddr;
+ int len;
+ int write;
+ struct target_ops *target; /* ignored */
+{
+ register int i;
+ /* Round starting address down to longword boundary. */
+ register CORE_ADDR addr = memaddr & - sizeof (PTRACE_XFER_TYPE);
+ /* Round ending address up; get number of longwords that makes. */
+ register int count
+ = (((memaddr + len) - addr) + sizeof (PTRACE_XFER_TYPE) - 1)
+ / sizeof (PTRACE_XFER_TYPE);
+ /* Allocate buffer of that many longwords. */
+ register PTRACE_XFER_TYPE *buffer
+ = (PTRACE_XFER_TYPE *) alloca (count * sizeof (PTRACE_XFER_TYPE));
+
+ if (write)
+ {
+ /* Fill start and end extra bytes of buffer with existing memory data. */
+
+ if (addr != memaddr || len < (int) sizeof (PTRACE_XFER_TYPE)) {
+ /* Need part of initial word -- fetch it. */
+ buffer[0] = ptrace (PT_RTEXT, inferior_pid, (PTRACE_ARG3_TYPE) addr,
+ 0);
+ }
+
+ if (count > 1) /* FIXME, avoid if even boundary */
+ {
+ buffer[count - 1]
+ = ptrace (PT_RTEXT, inferior_pid,
+ ((PTRACE_ARG3_TYPE)
+ (addr + (count - 1) * sizeof (PTRACE_XFER_TYPE))),
+ 0);
+ }
+
+ /* Copy data to be written over corresponding part of buffer */
+
+ memcpy ((char *) buffer + (memaddr & (sizeof (PTRACE_XFER_TYPE) - 1)),
+ myaddr,
+ len);
+
+ /* Write the entire buffer. */
+
+ for (i = 0; i < count; i++, addr += sizeof (PTRACE_XFER_TYPE))
+ {
+ errno = 0;
+ ptrace (PT_WRITE_D, inferior_pid, (PTRACE_ARG3_TYPE) addr,
+ buffer[i]);
+ if (errno)
+ {
+ /* Using the appropriate one (I or D) is necessary for
+ Gould NP1, at least. */
+ errno = 0;
+ ptrace (PT_WTEXT, inferior_pid, (PTRACE_ARG3_TYPE) addr,
+ buffer[i]);
+ }
+ if (errno)
+ return 0;
+ }
+ }
+ else
+ {
+ /* Read all the longwords */
+ for (i = 0; i < count; i++, addr += sizeof (PTRACE_XFER_TYPE))
+ {
+ errno = 0;
+ buffer[i] = ptrace (PT_RTEXT, inferior_pid,
+ (PTRACE_ARG3_TYPE) addr, 0);
+ if (errno)
+ return 0;
+ QUIT;
+ }
+
+ /* Copy appropriate bytes out of the buffer. */
+ memcpy (myaddr,
+ (char *) buffer + (memaddr & (sizeof (PTRACE_XFER_TYPE) - 1)),
+ len);
+ }
+ return len;
+}
+
+
+void
+_initialize_symm_nat ()
+{
+/*
+ * the MPDEBUGGER is necessary for process tree debugging and attach
+ * to work, but it alters the behavior of debugged processes, so other
+ * things (at least child_wait()) will have to change to accomodate
+ * that.
+ *
+ * Note that attach is not implemented in dynix 3, and not in ptx
+ * until version 2.1 of the OS.
+ */
+ int rv;
+ sigset_t set;
+ struct sigaction sact;
+
+ rv = mptrace(XPT_MPDEBUGGER, 0, 0, 0);
+ if (-1 == rv) {
+ fatal("_initialize_symm_nat(): mptrace(XPT_MPDEBUGGER): %s",
+ safe_strerror(errno));
+ }
+
+ /*
+ * Under MPDEBUGGER, we get SIGCLHD when a traced process does
+ * anything of interest.
+ */
+
+ /*
+ * Block SIGCHLD. We leave it blocked all the time, and then
+ * call sigsuspend() in child_wait() to wait for the child
+ * to do something. None of these ought to fail, but check anyway.
+ */
+ sigemptyset(&set);
+ rv = sigaddset(&set, SIGCHLD);
+ if (-1 == rv) {
+ fatal("_initialize_symm_nat(): sigaddset(SIGCHLD): %s",
+ safe_strerror(errno));
+ }
+ rv = sigprocmask(SIG_BLOCK, &set, (sigset_t *)NULL);
+ if (-1 == rv) {
+ fatal("_initialize_symm_nat(): sigprocmask(SIG_BLOCK): %s",
+ safe_strerror(errno));
+ }
+
+ sact.sa_handler = sigchld_handler;
+ sigemptyset(&sact.sa_mask);
+ sact.sa_flags = SA_NOCLDWAIT; /* keep the zombies away */
+ rv = sigaction(SIGCHLD, &sact, (struct sigaction *)NULL);
+ if (-1 == rv) {
+ fatal("_initialize_symm_nat(): sigaction(SIGCHLD): %s",
+ safe_strerror(errno));
+ }
+}
-/* Sequent Symmetry target interface, for GDB when running under Unix.
- Copyright (C) 1986, 1987, 1989, 1991 Free Software Foundation, Inc.
+/* Sequent Symmetry target interface, for GDB.
+ Copyright (C) 1986, 1987, 1989, 1991, 1994 Free Software Foundation, Inc.
This file is part of GDB.
#include "gdbcore.h"
#include <fcntl.h>
-static long i386_get_frame_setup ();
-static i386_follow_jump ();
-
-#include <sgtty.h>
-#define TERMINAL struct sgttyb
-
-/* rounds 'one' up to divide evenly by 'two' */
-
-int
-round(one,two)
-register int one, two;
-
-{
- register int temp;
- temp = (one/two)*two;
- if (one != temp) {
- temp += two;
- }
- return temp;
-}
-
-
-static CORE_ADDR codestream_next_addr;
-static CORE_ADDR codestream_addr;
-static unsigned char codestream_buf[sizeof (int)];
-static int codestream_off;
-static int codestream_cnt;
-
-#define codestream_tell() (codestream_addr + codestream_off)
-#define codestream_peek() (codestream_cnt == 0 ? \
- codestream_fill(1): codestream_buf[codestream_off])
-#define codestream_get() (codestream_cnt-- == 0 ? \
- codestream_fill(0) : codestream_buf[codestream_off++])
-
-
-static unsigned char
-codestream_fill (peek_flag)
-{
- codestream_addr = codestream_next_addr;
- codestream_next_addr += sizeof (int);
- codestream_off = 0;
- codestream_cnt = sizeof (int);
- read_memory (codestream_addr,
- (unsigned char *)codestream_buf,
- sizeof (int));
-
- if (peek_flag)
- return (codestream_peek());
- else
- return (codestream_get());
-}
-
-static void
-codestream_seek (place)
-{
- codestream_next_addr = place & -sizeof (int);
- codestream_cnt = 0;
- codestream_fill (1);
- while (codestream_tell() != place)
- codestream_get ();
-}
-
-static void
-codestream_read (buf, count)
- unsigned char *buf;
-{
- unsigned char *p;
- int i;
- p = buf;
- for (i = 0; i < count; i++)
- *p++ = codestream_get ();
-}
-
/*
* Following macro translates i386 opcode register numbers to Symmetry
* register numbers. This is used by FRAME_FIND_SAVED_REGS.
#define I386_REGNO_TO_SYMMETRY(n) \
((n)==0?0 :(n)==1?2 :(n)==2?1 :(n)==3?5 :(n)==4?14 :(n)==5?15 :(n))
-/* from i386-dep.c */
-i386_frame_find_saved_regs (fip, fsrp)
- struct frame_info *fip;
- struct frame_saved_regs *fsrp;
-{
- unsigned long locals;
- unsigned char *p;
- unsigned char op;
- CORE_ADDR dummy_bottom;
- CORE_ADDR adr;
- int i;
-
- memset (fsrp, 0, sizeof *fsrp);
-
- /* if frame is the end of a dummy, compute where the
- * beginning would be
- */
- dummy_bottom = fip->frame - 4 - NUM_REGS*4 - CALL_DUMMY_LENGTH;
-
- /* check if the PC is in the stack, in a dummy frame */
- if (dummy_bottom <= fip->pc && fip->pc <= fip->frame)
- {
- /* all regs were saved by push_call_dummy () */
- adr = fip->frame - 4;
- for (i = 0; i < NUM_REGS; i++)
- {
- fsrp->regs[i] = adr;
- adr -= 4;
- }
- return;
- }
-
- locals = i386_get_frame_setup (get_pc_function_start (fip->pc));
-
- if (locals >= 0)
- {
- adr = fip->frame - 4 - locals;
- for (i = 0; i < 8; i++)
- {
- op = codestream_get ();
- if (op < 0x50 || op > 0x57)
- break;
- fsrp->regs[I386_REGNO_TO_SYMMETRY(op - 0x50)] = adr;
- adr -= 4;
- }
- }
-
- fsrp->regs[PC_REGNUM] = fip->frame + 4;
- fsrp->regs[FP_REGNUM] = fip->frame;
-}
-
-static long
-i386_get_frame_setup (pc)
-{
- unsigned char op;
-
- codestream_seek (pc);
-
- i386_follow_jump ();
-
- op = codestream_get ();
-
- if (op == 0x58) /* popl %eax */
- {
- /*
- * this function must start with
- *
- * popl %eax 0x58
- * xchgl %eax, (%esp) 0x87 0x04 0x24
- * or xchgl %eax, 0(%esp) 0x87 0x44 0x24 0x00
- *
- * (the system 5 compiler puts out the second xchg
- * inst, and the assembler doesn't try to optimize it,
- * so the 'sib' form gets generated)
- *
- * this sequence is used to get the address of the return
- * buffer for a function that returns a structure
- */
- int pos;
- unsigned char buf[4];
- static unsigned char proto1[3] = { 0x87,0x04,0x24 };
- static unsigned char proto2[4] = { 0x87,0x44,0x24,0x00 };
- pos = codestream_tell ();
- codestream_read (buf, 4);
- if (memcmp (buf, proto1, 3) == 0)
- pos += 3;
- else if (memcmp (buf, proto2, 4) == 0)
- pos += 4;
-
- codestream_seek (pos);
- op = codestream_get (); /* update next opcode */
- }
-
- if (op == 0x55) /* pushl %esp */
- {
- if (codestream_get () != 0x8b) /* movl %esp, %ebp (2bytes) */
- return (-1);
- if (codestream_get () != 0xec)
- return (-1);
- /*
- * check for stack adjustment
- *
- * subl $XXX, %esp
- *
- * note: you can't subtract a 16 bit immediate
- * from a 32 bit reg, so we don't have to worry
- * about a data16 prefix
- */
- op = codestream_peek ();
- if (op == 0x83) /* subl with 8 bit immed */
- {
- codestream_get ();
- if (codestream_get () != 0xec)
- return (-1);
- /* subl with signed byte immediate
- * (though it wouldn't make sense to be negative)
- */
- return (codestream_get());
- }
- else if (op == 0x81) /* subl with 32 bit immed */
- {
- int locals;
- if (codestream_get () != 0xec)
- return (-1);
- /* subl with 32 bit immediate */
- codestream_read ((unsigned char *)&locals, 4);
- return (locals);
- }
- else
- {
- return (0);
- }
- }
- else if (op == 0xc8)
- {
- /* enter instruction: arg is 16 unsigned immed */
- unsigned short slocals;
- codestream_read ((unsigned char *)&slocals, 2);
- codestream_get (); /* flush final byte of enter instruction */
- return (slocals);
- }
- return (-1);
-}
-
-/* next instruction is a jump, move to target */
-static
-i386_follow_jump ()
-{
- int long_delta;
- short short_delta;
- char byte_delta;
- int data16;
- int pos;
-
- pos = codestream_tell ();
-
- data16 = 0;
- if (codestream_peek () == 0x66)
- {
- codestream_get ();
- data16 = 1;
- }
-
- switch (codestream_get ())
- {
- case 0xe9:
- /* relative jump: if data16 == 0, disp32, else disp16 */
- if (data16)
- {
- codestream_read ((unsigned char *)&short_delta, 2);
- pos += short_delta + 3; /* include size of jmp inst */
- }
- else
- {
- codestream_read ((unsigned char *)&long_delta, 4);
- pos += long_delta + 5;
- }
- break;
- case 0xeb:
- /* relative jump, disp8 (ignore data16) */
- codestream_read ((unsigned char *)&byte_delta, 1);
- pos += byte_delta + 2;
- break;
- }
- codestream_seek (pos + data16);
-}
-
-/* return pc of first real instruction */
-/* from i386-dep.c */
-
-i386_skip_prologue (pc)
-{
- unsigned char op;
- int i;
-
- if (i386_get_frame_setup (pc) < 0)
- return (pc);
-
- /* found valid frame setup - codestream now points to
- * start of push instructions for saving registers
- */
-
- /* skip over register saves */
- for (i = 0; i < 8; i++)
- {
- op = codestream_peek ();
- /* break if not pushl inst */
- if (op < 0x50 || op > 0x57)
- break;
- codestream_get ();
- }
-
- i386_follow_jump ();
-
- return (codestream_tell ());
-}
-
void
symmetry_extract_return_value(type, regbuf, valbuf)
struct type *type;
memcpy (valbuf, regbuf, TYPE_LENGTH (type));
}
}
-
-#ifdef _SEQUENT_ /* ptx, not dynix */
-/*
- * Convert compiler register number to gdb internal
- * register number. The PTX C compiler only really
- * puts things in %edi, %esi and %ebx, but it can't hurt
- * to be complete here.
- */
-int
-ptx_coff_regno_to_gdb(regno)
- int regno;
-{
- return I386_REGNO_TO_SYMMETRY(regno);
-}
-
-/* For ptx, the value in blockend will be meaningless. This function
- merely returns the proper offset given the register number. This
- is much easier, because under ptx, the upage is set up with the
- user struct on "top", and the registers "beneath" it (and thus defines
- TRAD_CORE_USER_OFFSET in bfd). */
-
-/* The following table is for ptx 1.3. In theory it should not change with
- the OS version, but if it does we should (if possible) figure out a way
- to accept both the old and the new formats. */
-
-static unsigned int reg_offsets[NUM_REGS] = {
-/*
- * u.u_ar0 = 0xfffff8d0
- * VA_UBLOCK = 0xffffe000
- * VA_UAREA = 0xfffff8e8
- * struct user at ublock offset 0x18e8
- * registers at ublock offset 0x18d0
- */
-0x18d0, /* eax */
-0x18c8, /* eax */
-0x18cc, /* eax */
-0x1be0, /* st0 */
-0x1bea, /* st1 */
-0x18c4, /* ebx */
-0x18b8, /* esi */
-0x18b4, /* edi */
-0x1bf4, /* st2 */
-0x1bfe, /* st3 */
-0x1c08, /* st4 */
-0x1c12, /* st5 */
-0x1c1c, /* st6 */
-0x1c26, /* st7 */
-0x18e0, /* esp */
-0x18bc, /* ebp */
-0x18d4, /* eip */
-0x18dc, /* flags */
-0x1c38, /* fp1 */
-0x1c3c, /* fp2 */
-0x1c40, /* fp3 */
-0x1c44, /* fp4 */
-0x1c48, /* fp5 */
-0x1c4c, /* fp6 */
-0x1c50, /* fp7 */
-0x1c54, /* fp8 */
-0x1c58, /* fp9 */
-0x1c5c, /* fp10 */
-0x1c60, /* fp11 */
-0x1c64, /* fp12 */
-0x1c68, /* fp13 */
-0x1c6c, /* fp14 */
-0x1c70, /* fp15 */
-0x1c74, /* fp16 */
-0x1c78, /* fp17 */
-0x1c7c, /* fp18 */
-0x1c80, /* fp19 */
-0x1c84, /* fp20 */
-0x1c88, /* fp21 */
-0x1c8c, /* fp22 */
-0x1c90, /* fp23 */
-0x1c94, /* fp24 */
-0x1c98, /* fp25 */
-0x1c9c, /* fp26 */
-0x1ca0, /* fp27 */
-0x1ca4, /* fp28 */
-0x1ca8, /* fp29 */
-0x1cac, /* fp30 */
-0x1cb0, /* fp31 */
-};
-
-unsigned int
-register_addr (regno, blockend)
- int regno, blockend;
-{
- if ((regno < 0) || (regno >= NUM_REGS)) {
- error("Invalid register number %d.", regno);
- }
- return reg_offsets[regno];
-}
-#endif /* _SEQUENT_ */
struct section_table {
CORE_ADDR addr; /* Lowest address in section */
CORE_ADDR endaddr; /* 1+highest address in section */
- sec_ptr sec_ptr; /* BFD section pointer */
+
+ /* For the ptx compiler, we can't use the sec_ptr typedef when the field's
+ name is sec_ptr. We really should rename the field (or better yet,
+ the typedef should be bfd_sec_ptr). */
+ struct sec *sec_ptr; /* BFD section pointer */
+
bfd *bfd; /* BFD file pointer */
};
int show;
{
struct expression *expr;
- register value val;
+ register value_ptr val;
register struct cleanup *old_chain = NULL;
if (exp)
char *typename;
int from_tty;
{
- register value val;
+ register value_ptr val;
register struct type *type;
register struct cleanup *old_chain;
struct expression *expr;
static void
set_output_radix_1 PARAMS ((int, unsigned));
-static void
-value_print_array_elements PARAMS ((value, GDB_FILE *, int, enum val_prettyprint));
+static void value_print_array_elements PARAMS ((value_ptr, GDB_FILE *, int,
+ enum val_prettyprint));
/* Maximum number of chars to print for a string pointer value or vector
contents, or UINT_MAX for no limit. Note that "set print elements 0"
int
value_print (val, stream, format, pretty)
- value val;
+ value_ptr val;
GDB_FILE *stream;
int format;
enum val_prettyprint pretty;
static void
value_print_array_elements (val, stream, format, pretty)
- value val;
+ value_ptr val;
GDB_FILE *stream;
int format;
enum val_prettyprint pretty;
};
-typedef struct value *value;
+typedef struct value *value_ptr;
#define VALUE_TYPE(val) (val)->type
#define VALUE_LAZY(val) (val)->lazy
#define VALUE_CONTENTS_RAW(val) ((char *) (val)->aligner.contents)
#define VALUE_CONTENTS(val) ((void)(VALUE_LAZY(val) && value_fetch_lazy(val)),\
VALUE_CONTENTS_RAW(val))
-extern int
-value_fetch_lazy PARAMS ((value val));
+extern int value_fetch_lazy PARAMS ((value_ptr val));
#define VALUE_LVAL(val) (val)->lval
#define VALUE_ADDRESS(val) (val)->location.address
{
struct internalvar *next;
char *name;
- value value;
+ value_ptr value;
};
/* Pointer to member function. Depends on compiler implementation. */
extern void
print_address_demangle PARAMS ((CORE_ADDR, GDB_FILE *, int));
-extern LONGEST
-value_as_long PARAMS ((value val));
+extern LONGEST value_as_long PARAMS ((value_ptr val));
-extern double
-value_as_double PARAMS ((value val));
+extern double value_as_double PARAMS ((value_ptr val));
-extern CORE_ADDR
-value_as_pointer PARAMS ((value val));
+extern CORE_ADDR value_as_pointer PARAMS ((value_ptr val));
-extern LONGEST
-unpack_long PARAMS ((struct type *type, char *valaddr));
+extern LONGEST unpack_long PARAMS ((struct type *type, char *valaddr));
-extern double
-unpack_double PARAMS ((struct type *type, char *valaddr, int *invp));
+extern double unpack_double PARAMS ((struct type *type, char *valaddr,
+ int *invp));
extern CORE_ADDR unpack_pointer PARAMS ((struct type *type, char *valaddr));
extern LONGEST unpack_field_as_long PARAMS ((struct type *type, char *valaddr,
int fieldno));
-extern value value_from_longest PARAMS ((struct type *type, LONGEST num));
+extern value_ptr value_from_longest PARAMS ((struct type *type, LONGEST num));
-extern value value_from_double PARAMS ((struct type *type, double num));
+extern value_ptr value_from_double PARAMS ((struct type *type, double num));
-extern value value_at PARAMS ((struct type *type, CORE_ADDR addr));
+extern value_ptr value_at PARAMS ((struct type *type, CORE_ADDR addr));
-extern value value_at_lazy PARAMS ((struct type *type, CORE_ADDR addr));
+extern value_ptr value_at_lazy PARAMS ((struct type *type, CORE_ADDR addr));
/* FIXME: Assumes equivalence of "struct frame_info *" and "FRAME" */
-extern value value_from_register PARAMS ((struct type *type, int regnum,
+extern value_ptr value_from_register PARAMS ((struct type *type, int regnum,
struct frame_info * frame));
-extern value value_of_variable PARAMS ((struct symbol *var, struct block *b));
+extern value_ptr value_of_variable PARAMS ((struct symbol *var,
+ struct block *b));
-extern value value_of_register PARAMS ((int regnum));
+extern value_ptr value_of_register PARAMS ((int regnum));
extern int symbol_read_needs_frame PARAMS ((struct symbol *));
/* FIXME: Assumes equivalence of "struct frame_info *" and "FRAME" */
-extern value read_var_value PARAMS ((struct symbol *var,
- struct frame_info *frame));
+extern value_ptr read_var_value PARAMS ((struct symbol *var,
+ struct frame_info *frame));
/* FIXME: Assumes equivalence of "struct frame_info *" and "FRAME" */
-extern value locate_var_value PARAMS ((struct symbol *var,
+extern value_ptr locate_var_value PARAMS ((struct symbol *var,
struct frame_info *frame));
-extern value allocate_value PARAMS ((struct type *type));
+extern value_ptr allocate_value PARAMS ((struct type *type));
-extern value allocate_repeat_value PARAMS ((struct type *type, int count));
+extern value_ptr allocate_repeat_value PARAMS ((struct type *type, int count));
-extern value value_mark PARAMS ((void));
+extern value_ptr value_mark PARAMS ((void));
-extern void value_free_to_mark PARAMS ((value mark));
+extern void value_free_to_mark PARAMS ((value_ptr mark));
-extern value value_string PARAMS ((char *ptr, int len));
+extern value_ptr value_string PARAMS ((char *ptr, int len));
-extern value value_array PARAMS ((int lowbound, int highbound,
- value *elemvec));
+extern value_ptr value_array PARAMS ((int lowbound, int highbound,
+ value_ptr *elemvec));
-extern value value_concat PARAMS ((value arg1, value arg2));
+extern value_ptr value_concat PARAMS ((value_ptr arg1, value_ptr arg2));
-extern value value_binop PARAMS ((value arg1, value arg2, enum exp_opcode op));
+extern value_ptr value_binop PARAMS ((value_ptr arg1, value_ptr arg2,
+ enum exp_opcode op));
-extern value value_add PARAMS ((value arg1, value arg2));
+extern value_ptr value_add PARAMS ((value_ptr arg1, value_ptr arg2));
-extern value value_sub PARAMS ((value arg1, value arg2));
+extern value_ptr value_sub PARAMS ((value_ptr arg1, value_ptr arg2));
-extern value value_coerce_array PARAMS ((value arg1));
+extern value_ptr value_coerce_array PARAMS ((value_ptr arg1));
-extern value value_coerce_function PARAMS ((value arg1));
+extern value_ptr value_coerce_function PARAMS ((value_ptr arg1));
-extern value value_ind PARAMS ((value arg1));
+extern value_ptr value_ind PARAMS ((value_ptr arg1));
-extern value value_addr PARAMS ((value arg1));
+extern value_ptr value_addr PARAMS ((value_ptr arg1));
-extern value value_assign PARAMS ((value toval, value fromval));
+extern value_ptr value_assign PARAMS ((value_ptr toval, value_ptr fromval));
-extern value value_neg PARAMS ((value arg1));
+extern value_ptr value_neg PARAMS ((value_ptr arg1));
-extern value value_complement PARAMS ((value arg1));
+extern value_ptr value_complement PARAMS ((value_ptr arg1));
-extern value value_struct_elt PARAMS ((value *argp, value *args, char *name,
- int *static_memfuncp, char *err));
+extern value_ptr value_struct_elt PARAMS ((value_ptr *argp, value *args,
+ char *name,
+ int *static_memfuncp, char *err));
-extern value value_struct_elt_for_reference PARAMS ((struct type *domain,
- int offset,
- struct type *curtype,
- char *name,
- struct type *intype));
+extern value_ptr value_struct_elt_for_reference PARAMS ((struct type *domain,
+ int offset,
+ struct type *curtype,
+ char *name,
+ struct type *intype));
-extern value value_field PARAMS ((value arg1, int fieldno));
+extern value_ptr value_field PARAMS ((value_ptr arg1, int fieldno));
-extern value value_primitive_field PARAMS ((value arg1, int offset,
- int fieldno,
- struct type *arg_type));
+extern value_ptr value_primitive_field PARAMS ((value_ptr arg1, int offset,
+ int fieldno,
+ struct type *arg_type));
-extern value value_cast PARAMS ((struct type *type, value arg2));
+extern value_ptr value_cast PARAMS ((struct type *type, value_ptr arg2));
-extern value value_zero PARAMS ((struct type *type, enum lval_type lv));
+extern value_ptr value_zero PARAMS ((struct type *type, enum lval_type lv));
-extern value value_repeat PARAMS ((value arg1, int count));
+extern value_ptr value_repeat PARAMS ((value_ptr arg1, int count));
-extern value value_subscript PARAMS ((value array, value idx));
+extern value_ptr value_subscript PARAMS ((value_ptr array, value_ptr idx));
-extern value value_from_vtable_info PARAMS ((value arg, struct type *type));
+extern value_ptr value_from_vtable_info PARAMS ((value_ptr arg,
+ struct type *type));
-extern value value_being_returned PARAMS ((struct type *valtype,
- char retbuf[REGISTER_BYTES],
- int struct_return));
+extern value_ptr value_being_returned PARAMS ((struct type *valtype,
+ char retbuf[REGISTER_BYTES],
+ int struct_return));
-extern value value_in PARAMS ((value element, value set));
+extern value_ptr value_in PARAMS ((value_ptr element, value_ptr set));
extern int value_bit_index PARAMS ((struct type *type, char *addr, int index));
-extern int
-using_struct_return PARAMS ((value function, CORE_ADDR funcaddr,
- struct type *value_type, int gcc_p));
+extern int using_struct_return PARAMS ((value_ptr function, CORE_ADDR funcaddr,
+ struct type *value_type, int gcc_p));
-extern void
-set_return_value PARAMS ((value val));
+extern void set_return_value PARAMS ((value_ptr val));
-extern value
-evaluate_expression PARAMS ((struct expression *exp));
+extern value_ptr evaluate_expression PARAMS ((struct expression *exp));
-extern value
-evaluate_type PARAMS ((struct expression *exp));
+extern value_ptr evaluate_type PARAMS ((struct expression *exp));
-extern value
-parse_and_eval PARAMS ((char *exp));
+extern value_ptr parse_and_eval PARAMS ((char *exp));
-extern value
-parse_to_comma_and_eval PARAMS ((char **expp));
+extern value_ptr parse_to_comma_and_eval PARAMS ((char **expp));
-extern struct type *
-parse_and_eval_type PARAMS ((char *p, int length));
+extern struct type *parse_and_eval_type PARAMS ((char *p, int length));
-extern CORE_ADDR
-parse_and_eval_address PARAMS ((char *exp));
+extern CORE_ADDR parse_and_eval_address PARAMS ((char *exp));
-extern CORE_ADDR
-parse_and_eval_address_1 PARAMS ((char **expptr));
+extern CORE_ADDR parse_and_eval_address_1 PARAMS ((char **expptr));
-extern value
-access_value_history PARAMS ((int num));
+extern value_ptr access_value_history PARAMS ((int num));
-extern value
-value_of_internalvar PARAMS ((struct internalvar *var));
+extern value_ptr value_of_internalvar PARAMS ((struct internalvar *var));
-extern void
-set_internalvar PARAMS ((struct internalvar *var, value val));
+extern void set_internalvar PARAMS ((struct internalvar *var, value_ptr val));
-extern void
-set_internalvar_component PARAMS ((struct internalvar *var, int offset,
- int bitpos, int bitsize,
- value newvalue));
+extern void set_internalvar_component PARAMS ((struct internalvar *var,
+ int offset,
+ int bitpos, int bitsize,
+ value_ptr newvalue));
-extern struct internalvar *
-lookup_internalvar PARAMS ((char *name));
+extern struct internalvar *lookup_internalvar PARAMS ((char *name));
-extern int
-value_equal PARAMS ((value arg1, value arg2));
+extern int value_equal PARAMS ((value_ptr arg1, value_ptr arg2));
-extern int
-value_less PARAMS ((value arg1, value arg2));
+extern int value_less PARAMS ((value_ptr arg1, value_ptr arg2));
-extern int
-value_logical_not PARAMS ((value arg1));
+extern int value_logical_not PARAMS ((value_ptr arg1));
/* C++ */
-extern value
-value_of_this PARAMS ((int complain));
+extern value_ptr value_of_this PARAMS ((int complain));
-extern value
-value_x_binop PARAMS ((value arg1, value arg2, enum exp_opcode op,
- enum exp_opcode otherop));
+extern value_ptr value_x_binop PARAMS ((value_ptr arg1, value_ptr arg2,
+ enum exp_opcode op,
+ enum exp_opcode otherop));
-extern value
-value_x_unop PARAMS ((value arg1, enum exp_opcode op));
+extern value_ptr value_x_unop PARAMS ((value_ptr arg1, enum exp_opcode op));
-extern value
-value_fn_field PARAMS ((value *arg1p, struct fn_field *f, int j,
- struct type* type, int offset));
+extern value_ptr value_fn_field PARAMS ((value_ptr *arg1p, struct fn_field *f,
+ int j,
+ struct type* type, int offset));
-extern value
-value_virtual_fn_field PARAMS ((value *arg1p, struct fn_field *f, int j,
- struct type *type, int offset));
+extern value_ptr value_virtual_fn_field PARAMS ((value_ptr *arg1p,
+ struct fn_field *f, int j,
+ struct type *type,
+ int offset));
-extern int
-binop_user_defined_p PARAMS ((enum exp_opcode op, value arg1, value arg2));
+extern int binop_user_defined_p PARAMS ((enum exp_opcode op,
+ value_ptr arg1, value_ptr arg2));
-extern int
-unop_user_defined_p PARAMS ((enum exp_opcode op, value arg1));
+extern int unop_user_defined_p PARAMS ((enum exp_opcode op, value_ptr arg1));
-extern int
-destructor_name_p PARAMS ((const char *name, const struct type *type));
+extern int destructor_name_p PARAMS ((const char *name,
+ const struct type *type));
#define value_free(val) free ((PTR)val)
-extern void
-free_all_values PARAMS ((void));
+extern void free_all_values PARAMS ((void));
-extern void
-release_value PARAMS ((value val));
+extern void release_value PARAMS ((value_ptr val));
-extern int
-record_latest_value PARAMS ((value val));
+extern int record_latest_value PARAMS ((value_ptr val));
-extern void
-registers_changed PARAMS ((void));
+extern void registers_changed PARAMS ((void));
-extern void
-read_register_bytes PARAMS ((int regbyte, char *myaddr, int len));
+extern void read_register_bytes PARAMS ((int regbyte, char *myaddr, int len));
-extern void
-write_register_bytes PARAMS ((int regbyte, char *myaddr, int len));
+extern void write_register_bytes PARAMS ((int regbyte, char *myaddr, int len));
extern void
read_register_gen PARAMS ((int regno, char *myaddr));
type_print PARAMS ((struct type *type, char *varstring, GDB_FILE *stream,
int show));
-extern char *
-baseclass_addr PARAMS ((struct type *type, int index, char *valaddr,
- value *valuep, int *errp));
+extern char *baseclass_addr PARAMS ((struct type *type, int index,
+ char *valaddr,
+ value_ptr *valuep, int *errp));
extern void
print_longest PARAMS ((GDB_FILE *stream, int format, int use_local,
extern void
print_floating PARAMS ((char *valaddr, struct type *type, GDB_FILE *stream));
-extern int
-value_print PARAMS ((value val, GDB_FILE *stream, int format,
- enum val_prettyprint pretty));
+extern int value_print PARAMS ((value_ptr val, GDB_FILE *stream, int format,
+ enum val_prettyprint pretty));
extern int
val_print PARAMS ((struct type *type, char *valaddr, CORE_ADDR address,
print_variable_value PARAMS ((struct symbol *var, struct frame_info *frame,
GDB_FILE *stream));
-extern value
-value_arg_coerce PARAMS ((value));
+extern value_ptr value_arg_coerce PARAMS ((value_ptr));
-extern int
-check_field PARAMS ((value, const char *));
+extern int check_field PARAMS ((value_ptr, const char *));
extern void
c_typedef_print PARAMS ((struct type *type, struct symbol *new, GDB_FILE *stream));
/* From values.c */
-extern value
-value_copy PARAMS ((value));
+extern value_ptr value_copy PARAMS ((value_ptr));
-extern int
-baseclass_offset PARAMS ((struct type *, int, value, int));
+extern int baseclass_offset PARAMS ((struct type *, int, value_ptr, int));
/* From valops.c */
-extern value
-call_function_by_hand PARAMS ((value, int, value *));
+extern value_ptr call_function_by_hand PARAMS ((value_ptr, int, value_ptr *));
#endif /* !defined (VALUE_H) */
/* Local function prototypes. */
-static value
-value_headof PARAMS ((value, struct type *, struct type *));
+static value_ptr value_headof PARAMS ((value, struct type *, struct type *));
-static void
-show_values PARAMS ((char *, int));
+static void show_values PARAMS ((char *, int));
-static void
-show_convenience PARAMS ((char *, int));
+static void show_convenience PARAMS ((char *, int));
/* The value-history records all the values printed
by print commands during this session. Each chunk
struct value_history_chunk
{
struct value_history_chunk *next;
- value values[VALUE_HISTORY_CHUNK];
+ value_ptr values[VALUE_HISTORY_CHUNK];
};
/* Chain of chunks now in use. */
(except for those released by calls to release_value)
This is so they can be freed after each command. */
-static value all_values;
+static value_ptr all_values;
/* Allocate a value that has the correct length for type TYPE. */
-value
+value_ptr
allocate_value (type)
struct type *type;
{
- register value val;
+ register value_ptr val;
check_stub_type (type);
- val = (value) xmalloc (sizeof (struct value) + TYPE_LENGTH (type));
+ val = (struct value *) xmalloc (sizeof (struct value) + TYPE_LENGTH (type));
VALUE_NEXT (val) = all_values;
all_values = val;
VALUE_TYPE (val) = type;
/* Allocate a value that has the correct length
for COUNT repetitions type TYPE. */
-value
+value_ptr
allocate_repeat_value (type, count)
struct type *type;
int count;
{
- register value val;
+ register value_ptr val;
- val = (value) xmalloc (sizeof (struct value) + TYPE_LENGTH (type) * count);
+ val =
+ (value_ptr) xmalloc (sizeof (struct value) + TYPE_LENGTH (type) * count);
VALUE_NEXT (val) = all_values;
all_values = val;
VALUE_TYPE (val) = type;
/* Return a mark in the value chain. All values allocated after the
mark is obtained (except for those released) are subject to being freed
if a subsequent value_free_to_mark is passed the mark. */
-value
+value_ptr
value_mark ()
{
return all_values;
(except for those released). */
void
value_free_to_mark (mark)
- value mark;
+ value_ptr mark;
{
- value val, next;
+ value_ptr val, next;
for (val = all_values; val && val != mark; val = next)
{
void
free_all_values ()
{
- register value val, next;
+ register value_ptr val, next;
for (val = all_values; val; val = next)
{
void
release_value (val)
- register value val;
+ register value_ptr val;
{
- register value v;
+ register value_ptr v;
if (all_values == val)
{
It contains the same contents, for same memory address,
but it's a different block of storage. */
-value
+value_ptr
value_copy (arg)
- value arg;
+ value_ptr arg;
{
- register value val;
+ register value_ptr val;
register struct type *type = VALUE_TYPE (arg);
if (VALUE_REPEATED (arg))
val = allocate_repeat_value (type, VALUE_REPETITIONS (arg));
int
record_latest_value (val)
- value val;
+ value_ptr val;
{
int i;
/* Return a copy of the value in the history with sequence number NUM. */
-value
+value_ptr
access_value_history (num)
int num;
{
{
register struct value_history_chunk *next;
register int i;
- register value val;
+ register value_ptr val;
while (value_history_chain)
{
int from_tty;
{
register int i;
- register value val;
+ register value_ptr val;
static int num = 1;
if (num_exp)
return var;
}
-value
+value_ptr
value_of_internalvar (var)
struct internalvar *var;
{
- register value val;
+ register value_ptr val;
#ifdef IS_TRAPPED_INTERNALVAR
if (IS_TRAPPED_INTERNALVAR (var->name))
set_internalvar_component (var, offset, bitpos, bitsize, newval)
struct internalvar *var;
int offset, bitpos, bitsize;
- value newval;
+ value_ptr newval;
{
register char *addr = VALUE_CONTENTS (var->value) + offset;
void
set_internalvar (var, val)
struct internalvar *var;
- value val;
+ value_ptr val;
{
#ifdef IS_TRAPPED_INTERNALVAR
if (IS_TRAPPED_INTERNALVAR (var->name))
LONGEST
value_as_long (val)
- register value val;
+ register value_ptr val;
{
/* This coerces arrays and functions, which is necessary (e.g.
in disassemble_command). It also dereferences references, which
double
value_as_double (val)
- register value val;
+ register value_ptr val;
{
double foo;
int inv;
Does not deallocate the value. */
CORE_ADDR
value_as_pointer (val)
- value val;
+ value_ptr val;
{
/* Assume a CORE_ADDR can fit in a LONGEST (for now). Not sure
whether we want this to be true eventually. */
For C++, must also be able to return values from static fields */
-value
+value_ptr
value_primitive_field (arg1, offset, fieldno, arg_type)
- register value arg1;
+ register value_ptr arg1;
int offset;
register int fieldno;
register struct type *arg_type;
{
- register value v;
+ register value_ptr v;
register struct type *type;
check_stub_type (arg_type);
For C++, must also be able to return values from static fields */
-value
+value_ptr
value_field (arg1, fieldno)
- register value arg1;
+ register value_ptr arg1;
register int fieldno;
{
return value_primitive_field (arg1, 0, fieldno, VALUE_TYPE (arg1));
F is the list of member functions which contains the desired method.
J is an index into F which provides the desired method. */
-value
+value_ptr
value_fn_field (arg1p, f, j, type, offset)
- value *arg1p;
+ value_ptr *arg1p;
struct fn_field *f;
int j;
struct type *type;
int offset;
{
- register value v;
+ register value_ptr v;
register struct type *ftype = TYPE_FN_FIELD_TYPE (f, j);
struct symbol *sym;
sym = lookup_symbol (TYPE_FN_FIELD_PHYSNAME (f, j),
0, VAR_NAMESPACE, 0, NULL);
if (! sym)
- return (value)NULL;
+ return NULL;
/*
error ("Internal error: could not find physical method named %s",
TYPE_FN_FIELD_PHYSNAME (f, j));
J is an index into F which provides the desired virtual function.
TYPE is the type in which F is located. */
-value
+value_ptr
value_virtual_fn_field (arg1p, f, j, type, offset)
- value *arg1p;
+ value_ptr *arg1p;
struct fn_field *f;
int j;
struct type *type;
int offset;
{
- value arg1 = *arg1p;
+ value_ptr arg1 = *arg1p;
/* First, get the virtual function table pointer. That comes
with a strange type, so cast it to type `pointer to long' (which
should serve just fine as a function type). Then, index into
the table, and convert final value to appropriate function type. */
- value entry, vfn, vtbl;
- value vi = value_from_longest (builtin_type_int,
- (LONGEST) TYPE_FN_FIELD_VOFFSET (f, j));
+ value_ptr entry, vfn, vtbl;
+ value_ptr vi = value_from_longest (builtin_type_int,
+ (LONGEST) TYPE_FN_FIELD_VOFFSET (f, j));
struct type *fcontext = TYPE_FN_FIELD_FCONTEXT (f, j);
struct type *context;
if (fcontext == NULL)
FIXME-tiemann: should work with dossier entries as well. */
-static value
+static value_ptr
value_headof (in_arg, btype, dtype)
- value in_arg;
+ value_ptr in_arg;
struct type *btype, *dtype;
{
/* First collect the vtables we must look at for this object. */
/* FIXME-tiemann: right now, just look at top-most vtable. */
- value arg, vtbl, entry, best_entry = 0;
+ value_ptr arg, vtbl, entry, best_entry = 0;
int i, nelems;
int offset, best_offset = 0;
struct symbol *sym;
of its baseclasses) to figure out the most derived type that ARG
could actually be a pointer to. */
-value
+value_ptr
value_from_vtable_info (arg, type)
- value arg;
+ value_ptr arg;
struct type *type;
{
/* Take care of preliminaries. */
baseclass_offset (type, index, arg, offset)
struct type *type;
int index;
- value arg;
+ value_ptr arg;
int offset;
{
struct type *basetype = TYPE_BASECLASS (type, index);
struct type *type;
int index;
char *valaddr;
- value *valuep;
+ value_ptr *valuep;
int *errp;
{
struct type *basetype = TYPE_BASECLASS (type, index);
{
if (vb_match (type, i, basetype))
{
- value val = allocate_value (basetype);
+ value_ptr val = allocate_value (basetype);
CORE_ADDR addr;
int status;
\f
/* Convert C numbers into newly allocated values */
-value
+value_ptr
value_from_longest (type, num)
struct type *type;
register LONGEST num;
{
- register value val = allocate_value (type);
+ register value_ptr val = allocate_value (type);
register enum type_code code = TYPE_CODE (type);
register int len = TYPE_LENGTH (type);
return val;
}
-value
+value_ptr
value_from_double (type, num)
struct type *type;
double num;
{
- register value val = allocate_value (type);
+ register value_ptr val = allocate_value (type);
register enum type_code code = TYPE_CODE (type);
register int len = TYPE_LENGTH (type);
0 when it is using the value returning conventions (this often
means returning pointer to where structure is vs. returning value). */
-value
+value_ptr
value_being_returned (valtype, retbuf, struct_return)
register struct type *valtype;
char retbuf[REGISTER_BYTES];
int struct_return;
/*ARGSUSED*/
{
- register value val;
+ register value_ptr val;
CORE_ADDR addr;
#if defined (EXTRACT_STRUCT_VALUE_ADDRESS)
int
using_struct_return (function, funcaddr, value_type, gcc_p)
- value function;
+ value_ptr function;
CORE_ADDR funcaddr;
struct type *value_type;
int gcc_p;
void
set_return_value (val)
- value val;
+ value_ptr val;
{
register enum type_code code = TYPE_CODE (VALUE_TYPE (val));
double dbuf;
projects / binutils-gdb.git / commitdiff