}
soc_con[cnt].tip_sockaddr.sa_family = domain;
- bcopy(soc_con[cnt].tip_string,
- soc_con[cnt].tip_sockaddr.sa_data,
+ memcpy(soc_con[cnt].tip_sockaddr.sa_data,
+ soc_con[cnt].tip_string,
sizeof(soc_con[cnt].tip_sockaddr.sa_data));
if (connect(soc_con[cnt].dfe_sd,
&soc_con[cnt].tip_sockaddr,
dfe_errno = UDIErrorNoSuchConnection;
goto tip_failure;
}
- bcopy(tip_info_p->h_addr,
- (char *)&soc_con[cnt].tip_sockaddr_in.sin_addr,
+ memcpy((char *)&soc_con[cnt].tip_sockaddr_in.sin_addr,
+ tip_info_p->h_addr,
tip_info_p->h_length);
}
soc_con[cnt].tip_sockaddr_in.sin_port
{ udr_errno = UDIErrorIPCInternal;
return -1;
}
- bcopy((char*)object_p, udrs->putbytes, size);
+ memcpy(udrs->putbytes, (char*)object_p, size);
udrs->putbytes += size;
if(udrs->putbytes > udrs->putend) udrs->putend = udrs->putbytes;
}
return -1; /* return error code */
}
} /* read data from character stream buffer */
- bcopy(udrs->getbytes, (char*)object_p, size);
+ memcpy((char*)object_p, udrs->getbytes, size);
udrs->getbytes += size;
}
else
+Wed Sep 1 13:12:43 1993 K. Richard Pixley (rich@sendai.cygnus.com)
+
+ * a68v-nat.c, altos-xdep.c, convex-tdep.c, convex-xdep.c,
+ findvar.c, hppab-nat.c, hppah-nat.c, i386mach-nat.c,
+ irix4-nat.c, m68k-tdep.c, m88k-tdep.c, mipsread.c, regex.c,
+ remote-bug.c, remote-hms.c, rs6000-nat.c, rs6000-tdep.c,
+ sparc-nat.c, stabsread.c, sun3-nat.c, sun386-nat.c, symfile.c,
+ umax-xdep.c, xcoffread.c, 29k-share/udi/udip2soc.c,
+ 29k-share/udi/udr.c, config/a29k/tm-a29k.h, config/arm/tm-arm.h,
+ config/convex/tm-convex.h, config/gould/tm-np1.h,
+ config/gould/tm-pn.h, config/h8300/tm-h8300.h,
+ config/h8500/tm-h8500.h, config/i386/tm-i386aix.h,
+ config/i386/tm-sun386.h, config/i386/tm-symmetry.h,
+ config/i960/tm-i960.h, config/m68k/tm-news.h,
+ config/m88k/tm-m88k.h, config/mips/tm-mips.h,
+ config/ns32k/tm-merlin.h, config/ns32k/tm-umax.h,
+ config/pa/tm-hppa.h, config/pyr/tm-pyr.h,
+ config/rs6000/tm-rs6000.h, config/sh/tm-sh.h,
+ config/tahoe/tm-tahoe.h, config/vax/tm-vax.h,
+ config/z8k/tm-z8k.h, nindy-share/nindy.c: bcopy -> memcpy
+
Wed Sep 1 05:05:53 1993 Peter Schauer (pes@regent.e-technik.tu-muenchen.de)
* mipsread.c (parse_partial_symbols): Use language from FDR if it
(PTRACE_ARG3_TYPE) &inferior_fp_registers, 0);
#endif
- bcopy (&inferior_registers, registers, 16 * 4);
+ memcpy (registers, &inferior_registers, 16 * 4);
#ifdef FP0_REGNUM
- bcopy (&inferior_fp_registers, ®isters[REGISTER_BYTE (FP0_REGNUM)],
+ memcpy (®isters[REGISTER_BYTE (FP0_REGNUM)], &inferior_fp_registers,
sizeof inferior_fp_registers.fps_regs);
#endif
*(int *)®isters[REGISTER_BYTE (PS_REGNUM)] = inferior_registers.r_ps;
*(int *)®isters[REGISTER_BYTE (PC_REGNUM)] = inferior_registers.r_pc;
#ifdef FP0_REGNUM
- bcopy (&inferior_fp_registers.fps_control,
- ®isters[REGISTER_BYTE (FPC_REGNUM)],
+ memcpy (®isters[REGISTER_BYTE (FPC_REGNUM)],
+ &inferior_fp_registers.fps_control,
sizeof inferior_fp_registers - sizeof inferior_fp_registers.fps_regs);
#endif
}
#endif
extern char registers[];
- bcopy (registers, &inferior_registers, 16 * 4);
+ memcpy (&inferior_registers, registers, 16 * 4);
#ifdef FP0_REGNUM
- bcopy (®isters[REGISTER_BYTE (FP0_REGNUM)], &inferior_fp_registers,
+ memcpy (&inferior_fp_registers, ®isters[REGISTER_BYTE (FP0_REGNUM)],
sizeof inferior_fp_registers.fps_regs);
#endif
inferior_registers.r_ps = *(int *)®isters[REGISTER_BYTE (PS_REGNUM)];
inferior_registers.r_pc = *(int *)®isters[REGISTER_BYTE (PC_REGNUM)];
#ifdef FP0_REGNUM
- bcopy (®isters[REGISTER_BYTE (FPC_REGNUM)],
- &inferior_fp_registers.fps_control,
+ memcpy (&inferior_fp_registers.fps_control,
+ ®isters[REGISTER_BYTE (FPC_REGNUM)],
sizeof inferior_fp_registers - sizeof inferior_fp_registers.fps_regs);
#endif
if (core_reg_size < sizeof (struct regs))
error ("Can't find registers in core file");
- bcopy ((char *)regs, registers, 16 * 4);
+ memcpy (registers, (char *)regs, 16 * 4);
supply_register (PS_REGNUM, ®s->r_ps);
supply_register (PC_REGNUM, ®s->r_pc);
if (core_reg_size >= sizeof (struct fpu))
{
#ifdef FP0_REGNUM
- bcopy (fpustruct->f_fpstatus.fps_regs,
- ®isters[REGISTER_BYTE (FP0_REGNUM)],
+ memcpy (®isters[REGISTER_BYTE (FP0_REGNUM)],
+ fpustruct->f_fpstatus.fps_regs,
sizeof fpustruct->f_fpstatus.fps_regs);
- bcopy (&fpustruct->f_fpstatus.fps_control,
- ®isters[REGISTER_BYTE (FPC_REGNUM)],
+ memcpy (®isters[REGISTER_BYTE (FPC_REGNUM)],
+ &fpustruct->f_fpstatus.fps_control,
sizeof fpustruct->f_fpstatus -
sizeof fpustruct->f_fpstatus.fps_regs);
#endif
if (reg_offset > NBPG * UPAGES)
reg_offset -= KERNEL_U_ADDR;
- bcopy (&u.u_exdata, &core_aouthdr, sizeof (AOUTHDR));
+ memcpy (&core_aouthdr, &u.u_exdata, sizeof (AOUTHDR));
printf ("Core file is from \"%s\".\n", u.u_comm);
/* I don't know where to find this info.
to virtual format for register REGNUM. */
#define REGISTER_CONVERT_TO_VIRTUAL(REGNUM,FROM,TO) \
-{ bcopy ((FROM), (TO), 4); }
+{ memcpy ((TO), (FROM), 4); }
/* Convert data from virtual format for register REGNUM
to raw format for register REGNUM. */
#define REGISTER_CONVERT_TO_RAW(REGNUM,FROM,TO) \
-{ bcopy ((FROM), (TO), 4); }
+{ memcpy ((TO), (FROM), 4); }
/* Return the GDB type object for the "standard" data type
of data in register N. */
read_memory (*((int *)(REGBUF) + LRP_REGNUM), (VALBUF) + 16 * 4, \
TYPE_LENGTH (TYPE) - 16 * 4); \
} \
- bcopy (((int *)(REGBUF))+RETURN_REGNUM, (VALBUF), reg_length); \
+ memcpy ((VALBUF), ((int *)(REGBUF))+RETURN_REGNUM, reg_length); \
}
/* Write into appropriate registers a function return value
--- /dev/null
+/* Definitions to make GDB target for an ARM under RISCiX (4.3bsd).
+ Copyright 1986, 1987, 1989, 1991, 1993 Free Software Foundation, Inc.
+
+This file is part of GDB.
+
+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 2 of the License, or
+(at your option) any later version.
+
+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 this program; if not, write to the Free Software
+Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
+
+#define TARGET_BYTE_ORDER LITTLE_ENDIAN
+
+/* IEEE format floating point */
+
+#define IEEE_FLOAT
+
+/* I provide my own xfer_core_file to cope with shared libraries */
+
+#define XFER_CORE_FILE
+
+/* Offset from address of function to start of its code.
+ Zero on most machines. */
+
+#define FUNCTION_START_OFFSET 0
+
+/* Advance PC across any function entry prologue instructions
+ to reach some "real" code. */
+
+#define SKIP_PROLOGUE(pc) pc = skip_prologue(pc)
+
+/* Immediately after a function call, return the saved pc.
+ Can't always go through the frames for this because on some machines
+ the new frame is not set up until the new function executes
+ some instructions. */
+
+#define SAVED_PC_AFTER_CALL(frame) (read_register (LR_REGNUM) & 0x03fffffc)
+
+/* I don't know the real values for these. */
+#define TARGET_UPAGES UPAGES
+#define TARGET_NBPG NBPG
+
+/* Address of end of stack space. */
+
+#define STACK_END_ADDR (0x01000000 - (TARGET_UPAGES * TARGET_NBPG))
+
+/* Stack grows downward. */
+
+#define INNER_THAN <
+
+/* Sequence of bytes for breakpoint instruction. */
+
+#define BREAKPOINT {0x00,0x00,0x18,0xef} /* BKPT_SWI from <sys/ptrace.h> */
+
+/* Amount PC must be decremented by after a breakpoint.
+ This is often the number of bytes in BREAKPOINT
+ but not always. */
+
+#define DECR_PC_AFTER_BREAK 0
+
+/* Nonzero if instruction at PC is a return instruction. */
+
+#define ABOUT_TO_RETURN(pc) \
+ ((read_memory_integer(pc, 4) & 0x0fffffff == 0x01b0f00e) || \
+ (read_memory_integer(pc, 4) & 0x0ffff800 == 0x09eba800))
+
+/* Return 1 if P points to an invalid floating point value.
+ LEN is the length in bytes. */
+
+#define INVALID_FLOAT(p, len) 0
+
+/* code to execute to print interesting information about the
+ * floating point processor (if any)
+ * No need to define if there is nothing to do.
+ */
+#define FLOAT_INFO { arm_float_info (); }
+
+/* Say how long (ordinary) registers are. */
+
+#define REGISTER_TYPE long
+
+/* Number of machine registers */
+
+/* Note: I make a fake copy of the pc in register 25 (calling it ps) so
+ that I can clear the status bits from pc (register 15) */
+
+#define NUM_REGS 26
+
+/* Initializer for an array of names of registers.
+ There should be NUM_REGS strings in this initializer. */
+
+#define REGISTER_NAMES \
+ { "a1", "a2", "a3", "a4", \
+ "v1", "v2", "v3", "v4", "v5", "v6", \
+ "sl", "fp", "ip", "sp", "lr", "pc", \
+ "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7", "fps", "ps" }
+
+/* Register numbers of various important registers.
+ Note that some of these values are "real" register numbers,
+ and correspond to the general registers of the machine,
+ and some are "phony" register numbers which are too large
+ to be actual register numbers as far as the user is concerned
+ but do serve to get the desired values when passed to read_register. */
+
+#define AP_REGNUM 11
+#define FP_REGNUM 11 /* Contains address of executing stack frame */
+#define SP_REGNUM 13 /* Contains address of top of stack */
+#define LR_REGNUM 14 /* address to return to from a function call */
+#define PC_REGNUM 15 /* Contains program counter */
+#define F0_REGNUM 16 /* first floating point register */
+#define FPS_REGNUM 24 /* floating point status register */
+#define PS_REGNUM 25 /* Contains processor status */
+
+
+/* Total amount of space needed to store our copies of the machine's
+ register state, the array `registers'. */
+#define REGISTER_BYTES (16*4 + 12*8 + 4 + 4)
+
+/* Index within `registers' of the first byte of the space for
+ register N. */
+
+#define REGISTER_BYTE(N) (((N) < F0_REGNUM) ? (N)*4 : \
+ (((N) < PS_REGNUM) ? 16*4 + ((N) - 16)*12 : \
+ 16*4 + 8*12 + ((N) - FPS_REGNUM) * 4))
+
+/* Number of bytes of storage in the actual machine representation
+ for register N. On the vax, all regs are 4 bytes. */
+
+#define REGISTER_RAW_SIZE(N) (((N) < F0_REGNUM || (N) >= FPS_REGNUM) ? 4 : 12)
+
+/* Number of bytes of storage in the program's representation
+ for register N. On the vax, all regs are 4 bytes. */
+
+#define REGISTER_VIRTUAL_SIZE(N) (((N) < F0_REGNUM || (N) >= FPS_REGNUM) ? 4 : 8)
+
+/* Largest value REGISTER_RAW_SIZE can have. */
+
+#define MAX_REGISTER_RAW_SIZE 12
+
+/* Largest value REGISTER_VIRTUAL_SIZE can have. */
+
+#define MAX_REGISTER_VIRTUAL_SIZE 8
+
+/* Nonzero if register N requires conversion
+ from raw format to virtual format. */
+
+#define REGISTER_CONVERTIBLE(N) ((unsigned)(N) - F0_REGNUM < 8)
+
+/* Convert data from raw format for register REGNUM
+ to virtual format for register REGNUM. */
+
+#define REGISTER_CONVERT_TO_VIRTUAL(REGNUM,FROM,TO) \
+ if (REGISTER_CONVERTIBLE(REGNUM)) \
+ convert_from_extended((FROM), (TO)); \
+ else \
+ memcpy ((TO), (FROM), 4);
+
+/* Convert data from virtual format for register REGNUM
+ to raw format for register REGNUM. */
+
+#define REGISTER_CONVERT_TO_RAW(REGNUM,FROM,TO) \
+ if (REGISTER_CONVERTIBLE(REGNUM)) \
+ convert_to_extended((FROM), (TO)); \
+ else \
+ memcpy ((TO), (FROM), 4);
+
+/* Return the GDB type object for the "standard" data type
+ of data in register N. */
+
+#define REGISTER_VIRTUAL_TYPE(N) \
+ (((unsigned)(N) - F0_REGNUM) < 8 ? builtin_type_double : builtin_type_int)
+\f
+/* The system C compiler uses a similar structure return convention to gcc */
+
+#define USE_STRUCT_CONVENTION(gcc_p, type) (TYPE_LENGTH (type) > 4)
+
+/* Store the address of the place in which to copy the structure the
+ subroutine will return. This is called from call_function. */
+
+#define STORE_STRUCT_RETURN(ADDR, SP) \
+ { write_register (0, (ADDR)); }
+
+/* Extract from an array REGBUF containing the (raw) register state
+ a function return value of type TYPE, and copy that, in virtual format,
+ into VALBUF. */
+
+#define EXTRACT_RETURN_VALUE(TYPE,REGBUF,VALBUF) \
+ if (TYPE_CODE (TYPE) == TYPE_CODE_FLT) \
+ convert_from_extended(REGBUF + REGISTER_BYTE (F0_REGNUM), VALBUF); \
+ else \
+ memcpy (VALBUF, REGBUF, TYPE_LENGTH (TYPE))
+
+/* Write into appropriate registers a function return value
+ of type TYPE, given in virtual format. */
+
+#define STORE_RETURN_VALUE(TYPE,VALBUF) \
+ if (TYPE_CODE (TYPE) == TYPE_CODE_FLT) { \
+ char _buf[MAX_REGISTER_RAW_SIZE]; \
+ convert_to_extended(VALBUF, _buf); \
+ write_register_bytes (REGISTER_BYTE (F0_REGNUM), _buf, MAX_REGISTER_RAW_SIZE); \
+ } else \
+ write_register_bytes (0, VALBUF, TYPE_LENGTH (TYPE))
+
+/* Extract from an array REGBUF containing the (raw) register state
+ the address in which a function should return its structure value,
+ as a CORE_ADDR (or an expression that can be used as one). */
+
+#define EXTRACT_STRUCT_VALUE_ADDRESS(REGBUF) (*(int *)(REGBUF))
+
+/* Specify that for the native compiler variables for a particular
+ lexical context are listed after the beginning LBRAC instead of
+ before in the executables list of symbols. */
+#define VARIABLES_INSIDE_BLOCK(desc, gcc_p) (!(gcc_p))
+
+\f
+/* Describe the pointer in each stack frame to the previous stack frame
+ (its caller). */
+
+/* FRAME_CHAIN takes a frame's nominal address
+ and produces the frame's chain-pointer.
+
+ However, if FRAME_CHAIN_VALID returns zero,
+ it means the given frame is the outermost one and has no caller. */
+
+/* In the case of the ARM, the frame's nominal address is the FP value,
+ and 12 bytes before comes the saved previous FP value as a 4-byte word. */
+
+#define FRAME_CHAIN(thisframe) \
+ ((thisframe)->pc >= first_object_file_end ? \
+ read_memory_integer ((thisframe)->frame - 12, 4) :\
+ 0)
+
+#define FRAME_CHAIN_VALID(chain, thisframe) \
+ (chain != 0 && (FRAME_SAVED_PC (thisframe) >= first_object_file_end))
+
+/* Define other aspects of the stack frame. */
+
+/* A macro that tells us whether the function invocation represented
+ by FI does not have a frame on the stack associated with it. If it
+ does not, FRAMELESS is set to 1, else 0. */
+#define FRAMELESS_FUNCTION_INVOCATION(FI, FRAMELESS) \
+{ \
+ CORE_ADDR func_start, after_prologue; \
+ func_start = (get_pc_function_start ((FI)->pc) + \
+ FUNCTION_START_OFFSET); \
+ after_prologue = func_start; \
+ SKIP_PROLOGUE (after_prologue); \
+ (FRAMELESS) = (after_prologue == func_start); \
+}
+
+/* Saved Pc. */
+
+#define FRAME_SAVED_PC(FRAME) \
+ (read_memory_integer ((FRAME)->frame - 4, 4) & 0x03fffffc)
+
+#define FRAME_ARGS_ADDRESS(fi) (fi->frame)
+
+#define FRAME_LOCALS_ADDRESS(fi) ((fi)->frame)
+
+/* Return number of args passed to a frame.
+ Can return -1, meaning no way to tell. */
+
+#define FRAME_NUM_ARGS(numargs, fi) (numargs = -1)
+
+/* Return number of bytes at start of arglist that are not really args. */
+
+#define FRAME_ARGS_SKIP 0
+
+/* Put here the code to store, into a struct frame_saved_regs,
+ the addresses of the saved registers of frame described by FRAME_INFO.
+ This includes special registers such as pc and fp saved in special
+ ways in the stack frame. sp is even more special:
+ the address we return for it IS the sp for the next frame. */
+
+#define FRAME_FIND_SAVED_REGS(frame_info, frame_saved_regs) \
+{ \
+ register int regnum; \
+ register int frame; \
+ register int next_addr; \
+ register int return_data_save; \
+ register int saved_register_mask; \
+ bzero (&frame_saved_regs, sizeof frame_saved_regs); \
+ frame = (frame_info)->frame; \
+ return_data_save = read_memory_integer(frame, 4) & 0x03fffffc - 12; \
+ saved_register_mask = \
+ read_memory_integer(return_data_save, 4); \
+ next_addr = frame - 12; \
+ for (regnum = 4; regnum < 10; regnum++) \
+ if (saved_register_mask & (1<<regnum)) { \
+ next_addr -= 4; \
+ (frame_saved_regs).regs[regnum] = next_addr; \
+ } \
+ if (read_memory_integer(return_data_save + 4, 4) == 0xed6d7103) { \
+ next_addr -= 12; \
+ (frame_saved_regs).regs[F0_REGNUM + 7] = next_addr; \
+ } \
+ if (read_memory_integer(return_data_save + 8, 4) == 0xed6d6103) { \
+ next_addr -= 12; \
+ (frame_saved_regs).regs[F0_REGNUM + 6] = next_addr; \
+ } \
+ if (read_memory_integer(return_data_save + 12, 4) == 0xed6d5103) { \
+ next_addr -= 12; \
+ (frame_saved_regs).regs[F0_REGNUM + 5] = next_addr; \
+ } \
+ if (read_memory_integer(return_data_save + 16, 4) == 0xed6d4103) { \
+ next_addr -= 12; \
+ (frame_saved_regs).regs[F0_REGNUM + 4] = next_addr; \
+ } \
+ (frame_saved_regs).regs[SP_REGNUM] = next_addr; \
+ (frame_saved_regs).regs[PC_REGNUM] = frame - 4; \
+ (frame_saved_regs).regs[PS_REGNUM] = frame - 4; \
+ (frame_saved_regs).regs[FP_REGNUM] = frame - 12; \
+}
+\f
+/* Things needed for making the inferior call functions. */
+
+/* Push an empty stack frame, to record the current PC, etc. */
+
+#define PUSH_DUMMY_FRAME \
+{ \
+ register CORE_ADDR sp = read_register (SP_REGNUM); \
+ register int regnum; \
+ /* opcode for ldmdb fp,{v1-v6,fp,ip,lr,pc}^ */ \
+ sp = push_word(sp, 0xe92dbf0); /* dummy return_data_save ins */ \
+ /* push a pointer to the dummy instruction minus 12 */ \
+ sp = push_word(sp, read_register (SP_REGNUM) - 16); \
+ sp = push_word(sp, read_register (PS_REGNUM)); \
+ sp = push_word(sp, read_register (SP_REGNUM)); \
+ sp = push_word(sp, read_register (FP_REGNUM)); \
+ for (regnum = 9; regnum >= 4; regnum --) \
+ sp = push_word(sp, read_register (regnum)); \
+ write_register (FP_REGNUM, read_register (SP_REGNUM) - 8); \
+ write_register (SP_REGNUM, sp); }
+
+/* Discard from the stack the innermost frame, restoring all registers. */
+
+#define POP_FRAME \
+{ \
+ register CORE_ADDR fp = read_register (FP_REGNUM); \
+ register unsigned long return_data_save = \
+ read_memory_integer ( (read_memory_integer (fp, 4) & \
+ 0x03fffffc) - 12, 4); \
+ register int regnum; \
+ write_register (PS_REGNUM, read_memory_integer (fp - 4, 4)); \
+ write_register (PC_REGNUM, read_register (PS_REGNUM) & 0x03fffffc); \
+ write_register (SP_REGNUM, read_memory_integer (fp - 8, 4)); \
+ write_register (FP_REGNUM, read_memory_integer (fp - 12, 4)); \
+ fp -= 12; \
+ for (regnum = 9; regnum >= 4; regnum--) \
+ if (return_data_save & (1<<regnum)) { \
+ fp -= 4; \
+ write_register (regnum, read_memory_integer(fp, 4)); \
+ } \
+ flush_cached_frames (); \
+ set_current_frame (create_new_frame (read_register (FP_REGNUM), \
+ read_pc ())); \
+}
+
+/* This sequence of words is the instructions
+
+ ldmia sp!,{a1-a4}
+ mov lk,pc
+ bl *+8
+ swi bkpt_swi
+
+ Note this is 16 bytes. */
+
+#define CALL_DUMMY {0xe8bd000f, 0xe1a0e00f, 0xeb000000, 0xef180000}
+
+#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) \
+{ \
+ register enum type_code code = TYPE_CODE (type); \
+ register nargs_in_registers, struct_return = 0; \
+ /* fix the load-arguments mask to move the first 4 or less arguments \
+ into a1-a4 but make sure the structure return address in a1 is \
+ not disturbed if the function is returning a structure */ \
+ if ((code == TYPE_CODE_STRUCT || \
+ code == TYPE_CODE_UNION || \
+ code == TYPE_CODE_ARRAY) && \
+ TYPE_LENGTH (type) > 4) { \
+ nargs_in_registers = min(nargs + 1, 4); \
+ struct_return = 1; \
+ } else \
+ nargs_in_registers = min(nargs, 4); \
+ *(char *) dummyname = (1 << nargs_in_registers) - 1 - struct_return; \
+ *(int *)((char *) dummyname + 8) = \
+ (((fun - (pc + 16)) / 4) & 0x00ffffff) | 0xeb000000; }
/* FIXME: Won't work with both h8/300's. */
#define EXTRACT_RETURN_VALUE(TYPE,REGBUF,VALBUF) \
- bcopy ((char *)(REGBUF), VALBUF, TYPE_LENGTH(TYPE))
+ memcpy (VALBUF, (char *)(REGBUF), TYPE_LENGTH(TYPE))
/* Write into appropriate registers a function return value
of type TYPE, given in virtual format. Assumes floats are passed
into VALBUF. */
#define EXTRACT_RETURN_VALUE(TYPE,REGBUF,VALBUF) \
- bcopy ((char *)(REGBUF), VALBUF, TYPE_LENGTH(TYPE))
+ memcpy (VALBUF, (char *)(REGBUF), TYPE_LENGTH(TYPE))
/* Write into appropriate registers a function return value
to virtual format for register REGNUM. */
#undef REGISTER_CONVERT_TO_VIRTUAL
#define REGISTER_CONVERT_TO_VIRTUAL(REGNUM,FROM,TO) \
- ((REGNUM < FP0_REGNUM) ? bcopy ((FROM), (TO), 4) : \
+ ((REGNUM < FP0_REGNUM) ? memcpy ((TO), (FROM), 4) : \
i387_to_double((FROM), (TO)))
/* Convert data from virtual format for register REGNUM
to raw format for register REGNUM. */
#undef REGISTER_CONVERT_TO_RAW
#define REGISTER_CONVERT_TO_RAW(REGNUM,FROM,TO) \
- ((REGNUM < FP0_REGNUM) ? bcopy ((FROM), (TO), 4) : \
+ ((REGNUM < FP0_REGNUM) ? memcpy ((TO), (FROM), 4) : \
double_to_i387((FROM), (TO)))
/* Return the GDB type object for the "standard" data type
{ if ((REGNUM) >= FP0_REGNUM && (REGNUM) < FPC_REGNUM) \
i387_to_double ((FROM), (TO)); \
else \
- bcopy ((FROM), (TO), 4); }
+ memcpy ((TO), (FROM), 4); }
extern void
i387_to_double PARAMS ((char *, char *));
{ if ((REGNUM) >= FP0_REGNUM && (REGNUM) < FPC_REGNUM) \
double_to_i387 ((FROM), (TO)); \
else \
- bcopy ((FROM), (TO), 4); }
+ memcpy ((TO), (FROM), 4); }
extern void
double_to_i387 PARAMS ((char *, char *));
into VALBUF. */
#define EXTRACT_RETURN_VALUE(TYPE,REGBUF,VALBUF) \
- bcopy (REGBUF + REGISTER_BYTE (TYPE_CODE (TYPE) == TYPE_CODE_FLT ? FP0_REGNUM : 11), VALBUF, TYPE_LENGTH (TYPE))
+ memcpy (VALBUF, REGBUF + REGISTER_BYTE (TYPE_CODE (TYPE) == TYPE_CODE_FLT ? FP0_REGNUM : 11), TYPE_LENGTH (TYPE))
/* Write into appropriate registers a function return value
of type TYPE, given in virtual format. */
#undef REGISTER_CONVERT_TO_VIRTUAL
#define REGISTER_CONVERT_TO_VIRTUAL(REGNUM,FROM,TO) \
-((REGNUM < 3) ? bcopy ((FROM), (TO), 4) : \
+((REGNUM < 3) ? memcpy ((TO), (FROM), 4) : \
(REGNUM < 5) ? i387_to_double((FROM), (TO)) : \
-(REGNUM < 8) ? bcopy ((FROM), (TO), 4) : \
+(REGNUM < 8) ? memcpy ((TO), (FROM), 4) : \
(REGNUM < 14) ? i387_to_double((FROM), (TO)) : \
- bcopy ((FROM), (TO), 4))
+ memcpy ((TO), (FROM), 4))
extern void
i387_to_double PARAMS ((char *, char *));
#undef REGISTER_CONVERT_TO_RAW
#define REGISTER_CONVERT_TO_RAW(REGNUM,FROM,TO) \
-((REGNUM < 3) ? bcopy ((FROM), (TO), 4) : \
+((REGNUM < 3) ? memcpy ((TO), (FROM), 4) : \
(REGNUM < 5) ? double_to_i387((FROM), (TO)) : \
-(REGNUM < 8) ? bcopy ((FROM), (TO), 4) : \
+(REGNUM < 8) ? memcpy ((TO), (FROM), 4) : \
(REGNUM < 14) ? double_to_i387((FROM), (TO)) : \
- bcopy ((FROM), (TO), 4))
+ memcpy ((TO), (FROM), 4))
extern void
double_to_i387 PARAMS ((char *, char *));
if ((REGNUM) >= FP0_REGNUM) \
ieee_extended_to_double (&ext_format_i960, (FROM), (double *)(TO)); \
else \
- bcopy ((FROM), (TO), 4); \
+ memcpy ((TO), (FROM), 4); \
}
/* Convert data from virtual format for register REGNUM
if ((REGNUM) >= FP0_REGNUM) \
double_to_ieee_extended (&ext_format_i960, (double *)(FROM), (TO)); \
else \
- bcopy ((FROM), (TO), 4); \
+ memcpy ((TO), (FROM), 4); \
}
On the i960 we just take as many bytes as we need from G0 through G3. */
#define EXTRACT_RETURN_VALUE(TYPE,REGBUF,VALBUF) \
- bcopy(REGBUF+REGISTER_BYTE(G0_REGNUM), VALBUF, TYPE_LENGTH (TYPE))
+ memcpy(VALBUF, REGBUF+REGISTER_BYTE(G0_REGNUM), TYPE_LENGTH (TYPE))
/* If USE_STRUCT_CONVENTION produces a 1,
extract from an array REGBUF containing the (raw) register state
®BUF[REGISTER_BYTE (FP0_REGNUM)], VALBUF); \
} \
else \
- bcopy (REGBUF, VALBUF, TYPE_LENGTH (TYPE)); }
+ memcpy (VALBUF, REGBUF, TYPE_LENGTH (TYPE)); }
/* Write into appropriate registers a function return value
of type TYPE, given in virtual format. */
to virtual format for register REGNUM. */
#define REGISTER_CONVERT_TO_VIRTUAL(REGNUM,FROM,TO) \
- {bcopy ((FROM), (TO), REGISTER_RAW_SIZE (REGNUM));}
+ {memcpy ((TO), (FROM), REGISTER_RAW_SIZE (REGNUM));}
/* Convert data from virtual format for register REGNUM
to raw format for register REGNUM. */
#define REGISTER_CONVERT_TO_RAW(REGNUM,FROM,TO) \
- {bcopy ((FROM), (TO), REGISTER_RAW_SIZE (REGNUM));}
+ {memcpy ((TO), (FROM), REGISTER_RAW_SIZE (REGNUM));}
/* Return the GDB type object for the "standard" data type
of data in register N. */
into consecutive registers starting from r2. */
#define EXTRACT_RETURN_VALUE(TYPE,REGBUF,VALBUF) \
- bcopy (&(((char *)REGBUF)[REGISTER_BYTE(RV_REGNUM)]), (VALBUF), TYPE_LENGTH (TYPE))
+ memcpy ((VALBUF), &(((char *)REGBUF)[REGISTER_BYTE(RV_REGNUM)]), TYPE_LENGTH (TYPE))
#define EXTRACT_STRUCT_VALUE_ADDRESS(REGBUF) (*(int *)(REGBUF))
to virtual format for register REGNUM. */
#define REGISTER_CONVERT_TO_VIRTUAL(REGNUM,FROM,TO) \
- bcopy ((FROM), (TO), 4);
+ memcpy ((TO), (FROM), 4);
/* Convert data from virtual format for register REGNUM
to raw format for register REGNUM. */
#define REGISTER_CONVERT_TO_RAW(REGNUM,FROM,TO) \
- bcopy ((FROM), (TO), 4);
+ memcpy ((TO), (FROM), 4);
/* Return the GDB type object for the "standard" data type
of data in register N. */
to virtual format for register REGNUM. */
#define REGISTER_CONVERT_TO_VIRTUAL(REGNUM,FROM,TO) \
- bcopy ((FROM), (TO), REGISTER_VIRTUAL_SIZE(REGNUM));
+ memcpy ((TO), (FROM), REGISTER_VIRTUAL_SIZE(REGNUM));
/* Convert data from virtual format for register REGNUM
to raw format for register REGNUM. */
#define REGISTER_CONVERT_TO_RAW(REGNUM,FROM,TO) \
- bcopy ((FROM), (TO), REGISTER_VIRTUAL_SIZE(REGNUM));
+ memcpy ((TO), (FROM), REGISTER_VIRTUAL_SIZE(REGNUM));
/* Return the GDB type object for the "standard" data type
of data in register N. */
into VALBUF. */
#define EXTRACT_RETURN_VALUE(TYPE,REGBUF,VALBUF) \
- bcopy (REGBUF, VALBUF, TYPE_LENGTH (TYPE))
+ memcpy (VALBUF, REGBUF, TYPE_LENGTH (TYPE))
/* Write into appropriate registers a function return value
of type TYPE, given in virtual format. */
to virtual format for register REGNUM. */
#define REGISTER_CONVERT_TO_VIRTUAL(REGNUM,FROM,TO) \
- bcopy ((FROM), (TO), REGISTER_VIRTUAL_SIZE(REGNUM));
+ memcpy ((TO), (FROM), REGISTER_VIRTUAL_SIZE(REGNUM));
/* Convert data from virtual format for register REGNUM
to raw format for register REGNUM. */
#define REGISTER_CONVERT_TO_RAW(REGNUM,FROM,TO) \
- bcopy ((FROM), (TO), REGISTER_VIRTUAL_SIZE(REGNUM));
+ memcpy ((TO), (FROM), REGISTER_VIRTUAL_SIZE(REGNUM));
/* Return the GDB type object for the "standard" data type
of data in register N. */
into VALBUF. */
#define EXTRACT_RETURN_VALUE(TYPE,REGBUF,VALBUF) \
- bcopy (REGBUF+REGISTER_BYTE (TYPE_CODE (TYPE) == TYPE_CODE_FLT ? FP0_REGNUM : 0), VALBUF, TYPE_LENGTH (TYPE))
+ memcpy (VALBUF, REGBUF+REGISTER_BYTE (TYPE_CODE (TYPE) == TYPE_CODE_FLT ? FP0_REGNUM : 0), TYPE_LENGTH (TYPE))
/* Write into appropriate registers a function return value
of type TYPE, given in virtual format. */
into VALBUF. */
#define EXTRACT_RETURN_VALUE(TYPE,REGBUF,VALBUF) \
- bcopy ((REGBUF) + REGISTER_BYTE(TYPE_LENGTH(TYPE) > 4 ? \
- FP4_REGNUM :28), VALBUF, TYPE_LENGTH (TYPE))
+ memcpy (VALBUF, (REGBUF) + REGISTER_BYTE(TYPE_LENGTH(TYPE) > 4 ? \
+ FP4_REGNUM :28), TYPE_LENGTH (TYPE))
/* Write into appropriate registers a function return value
of type TYPE, given in virtual format. */
#define OBJ_UNWIND_INFO(obj) ((struct obj_unwind_info *)obj->obj_private)
#define TARGET_READ_PC() target_read_pc ()
+#define TARGET_WRITE_PC(v) target_write_pc (v)
if ((W)==0x57c && breakpoints_inserted) { \
mark_breakpoints_out (); \
insert_breakpoints (); \
- insert_step_breakpoint (); \
} \
resume (0, 0); \
continue; \
to virtual format for register REGNUM. */
#define REGISTER_CONVERT_TO_VIRTUAL(REGNUM,FROM,TO) \
- bcopy ((FROM), (TO), REGISTER_RAW_SIZE (REGNUM))
+ memcpy ((TO), (FROM), REGISTER_RAW_SIZE (REGNUM))
/* Convert data from virtual format for register REGNUM
to raw format for register REGNUM. */
#define REGISTER_CONVERT_TO_RAW(REGNUM,FROM,TO) \
- bcopy ((FROM), (TO), REGISTER_RAW_SIZE (REGNUM))
+ memcpy ((TO), (FROM), REGISTER_RAW_SIZE (REGNUM))
/* Return the GDB type object for the "standard" data type
of data in register N. */
into VALBUF. */
/* #define EXTRACT_RETURN_VALUE(TYPE,REGBUF,VALBUF) \
- bcopy (REGBUF, VALBUF, TYPE_LENGTH (TYPE)) */
+ memcpy (VALBUF, REGBUF, TYPE_LENGTH (TYPE)) */
#define EXTRACT_RETURN_VALUE(TYPE,REGBUF,VALBUF) \
extract_return_value(TYPE,REGBUF,VALBUF)
into VALBUF. */
#define EXTRACT_RETURN_VALUE(TYPE,REGBUF,VALBUF) \
- bcopy ((char *)(REGBUF), VALBUF, TYPE_LENGTH(TYPE))
+ memcpy (VALBUF, (char *)(REGBUF), TYPE_LENGTH(TYPE))
/* Write into appropriate registers a function return value
to virtual format for register REGNUM. */
#define REGISTER_CONVERT_TO_VIRTUAL(REGNUM,FROM,TO) \
- bcopy ((FROM), (TO), 4);
+ memcpy ((TO), (FROM), 4);
/* Convert data from virtual format for register REGNUM
to raw format for register REGNUM. */
#define REGISTER_CONVERT_TO_RAW(REGNUM,FROM,TO) \
- bcopy ((FROM), (TO), 4);
+ memcpy ((TO), (FROM), 4);
/* Return the GDB type object for the "standard" data type
of data in register N. */
into VALBUF. */
#define EXTRACT_RETURN_VALUE(TYPE,REGBUF,VALBUF) \
- bcopy (REGBUF, VALBUF, TYPE_LENGTH (TYPE))
+ memcpy (VALBUF, REGBUF, TYPE_LENGTH (TYPE))
/* Write into appropriate registers a function return value
of type TYPE, given in virtual format. */
#define EXTRACT_RETURN_VALUE(TYPE,REGBUF,VALBUF) \
- bcopy(REGBUF + REGISTER_BYTE(2), VALBUF, TYPE_LENGTH(TYPE));
+ memcpy(VALBUF, REGBUF + REGISTER_BYTE(2), TYPE_LENGTH(TYPE));
/* Write into appropriate registers a function return value
of type TYPE, given in virtual format. */
{
long vm[4];
long i, *p;
- bcopy (read_vector_register_1 (VM_REGNUM), vm, sizeof vm);
+ memcpy (vm, read_vector_register_1 (VM_REGNUM), sizeof vm);
range_type =
create_range_type ((struct type *) NULL, builtin_type_int, 0, len - 1);
type =
create_array_type ((struct type *) NULL, builtin_type_long_long,
range_type);
val = allocate_value (type);
- bcopy (read_vector_register_1 (name[1] - '0'),
- VALUE_CONTENTS (val), TYPE_LENGTH (type));
+ memcpy (VALUE_CONTENTS (val),
+ read_vector_register_1 (name[1] - '0'),
+ TYPE_LENGTH (type));
}
else if (name[0] == 'v')
{
if (thread == inferior_thread)
return;
- bcopy (registers, thread_regs[inferior_thread], REGISTER_BYTES);
+ memcpy (thread_regs[inferior_thread], registers, REGISTER_BYTES);
ps.pi_thread = inferior_thread = thread;
if (have_inferior_p ())
ioctl (inferior_fd, PISETRWTID, &ps);
- bcopy (thread_regs[thread], registers, REGISTER_BYTES);
+ memcpy (registers, thread_regs[thread], REGISTER_BYTES);
}
/* Routine to set or clear a psw bit in the psw and also all psws
#include "inferior.h"
#include "target.h"
+/* Basic byte-swapping routines. GDB has needed these for a long time...
+ All extract a target-format integer at ADDR which is LEN bytes long. */
+
+#if TARGET_CHAR_BIT != 8 || HOST_CHAR_BIT != 8
+ /* 8 bit characters are a pretty safe assumption these days, so we
+ assume it throughout all these swapping routines. If we had to deal with
+ 9 bit characters, we would need to make len be in bits and would have
+ to re-write these routines... */
+ you lose
+#endif
+
+LONGEST
+extract_signed_integer (addr, len)
+ PTR addr;
+ int len;
+{
+ LONGEST retval;
+ unsigned char *p;
+ unsigned char *startaddr = (unsigned char *)addr;
+ unsigned char *endaddr = startaddr + len;
+
+ if (len > sizeof (LONGEST))
+ error ("\
+That operation is not available on integers of more than %d bytes.",
+ sizeof (LONGEST));
+
+ /* Start at the most significant end of the integer, and work towards
+ the least significant. */
+#if TARGET_BYTE_ORDER == BIG_ENDIAN
+ p = startaddr;
+#else
+ p = endaddr - 1;
+#endif
+ /* Do the sign extension once at the start. */
+ retval = (*p ^ 0x80) - 0x80;
+#if TARGET_BYTE_ORDER == BIG_ENDIAN
+ for (++p; p < endaddr; ++p)
+#else
+ for (--p; p >= startaddr; --p)
+#endif
+ {
+ retval = (retval << 8) | *p;
+ }
+ return retval;
+}
+
+unsigned LONGEST
+extract_unsigned_integer (addr, len)
+ PTR addr;
+ int len;
+{
+ unsigned LONGEST retval;
+ unsigned char *p;
+ unsigned char *startaddr = (unsigned char *)addr;
+ unsigned char *endaddr = startaddr + len;
+
+ if (len > sizeof (unsigned LONGEST))
+ error ("\
+That operation is not available on integers of more than %d bytes.",
+ sizeof (unsigned LONGEST));
+
+ /* Start at the most significant end of the integer, and work towards
+ the least significant. */
+ retval = 0;
+#if TARGET_BYTE_ORDER == BIG_ENDIAN
+ for (p = startaddr; p < endaddr; ++p)
+#else
+ for (p = endaddr - 1; p >= startaddr; --p)
+#endif
+ {
+ retval = (retval << 8) | *p;
+ }
+ return retval;
+}
+
+CORE_ADDR
+extract_address (addr, len)
+ PTR addr;
+ int len;
+{
+ /* Assume a CORE_ADDR can fit in a LONGEST (for now). Not sure
+ whether we want this to be true eventually. */
+ return extract_unsigned_integer (addr, len);
+}
+
+void
+store_signed_integer (addr, len, val)
+ PTR addr;
+ int len;
+ LONGEST val;
+{
+ unsigned char *p;
+ unsigned char *startaddr = (unsigned char *)addr;
+ unsigned char *endaddr = startaddr + len;
+
+ /* Start at the least significant end of the integer, and work towards
+ the most significant. */
+#if TARGET_BYTE_ORDER == BIG_ENDIAN
+ for (p = endaddr - 1; p >= startaddr; --p)
+#else
+ for (p = startaddr; p < endaddr; ++p)
+#endif
+ {
+ *p = val & 0xff;
+ val >>= 8;
+ }
+}
+
+void
+store_unsigned_integer (addr, len, val)
+ PTR addr;
+ int len;
+ unsigned LONGEST val;
+{
+ unsigned char *p;
+ unsigned char *startaddr = (unsigned char *)addr;
+ unsigned char *endaddr = startaddr + len;
+
+ /* Start at the least significant end of the integer, and work towards
+ the most significant. */
+#if TARGET_BYTE_ORDER == BIG_ENDIAN
+ for (p = endaddr - 1; p >= startaddr; --p)
+#else
+ for (p = startaddr; p < endaddr; ++p)
+#endif
+ {
+ *p = val & 0xff;
+ val >>= 8;
+ }
+}
+
+void
+store_address (addr, len, val)
+ PTR addr;
+ int len;
+ CORE_ADDR val;
+{
+ /* Assume a CORE_ADDR can fit in a LONGEST (for now). Not sure
+ whether we want this to be true eventually. */
+ store_unsigned_integer (addr, len, (LONGEST)val);
+}
+\f
#if !defined (GET_SAVED_REGISTER)
/* Return the address in which frame FRAME's value of register REGNUM
{
if (raw_buffer != NULL)
{
- *(CORE_ADDR *)raw_buffer = addr;
- /* Put it back in target byte order. */
- SWAP_TARGET_AND_HOST (raw_buffer, sizeof (CORE_ADDR));
+ /* Put it back in target format. */
+ store_address (raw_buffer, REGISTER_RAW_SIZE (regnum), addr);
}
if (addrp != NULL)
*addrp = 0;
int optim;
if (regnum == FP_REGNUM && selected_frame)
{
- memcpy (myaddr, &FRAME_FP(selected_frame), REGISTER_RAW_SIZE(FP_REGNUM));
- SWAP_TARGET_AND_HOST (myaddr, REGISTER_RAW_SIZE(FP_REGNUM)); /* in target order */
+ /* Put it back in target format. */
+ store_address (myaddr, REGISTER_RAW_SIZE(FP_REGNUM),
+ FRAME_FP(selected_frame));
return 0;
}
the caller got the value from the last stop). */
/* Contents of the registers in target byte order.
- We allocate some extra slop since we do a lot of bcopy's around `registers',
+ We allocate some extra slop since we do a lot of memcpy's around `registers',
and failing-soft is better than failing hard. */
char registers[REGISTER_BYTES + /* SLOP */ 256];
target_store_registers (-1);
}
-/* Return the contents of register REGNO, regarding it as an integer. */
-/* FIXME, this loses when the REGISTER_VIRTUAL (REGNO) is true. Also,
- why is the return type CORE_ADDR rather than some integer type? */
+/* Return the raw contents of register REGNO, regarding it as an integer. */
+/* This probably should be returning LONGEST rather than CORE_ADDR. */
CORE_ADDR
read_register (regno)
int regno;
{
- unsigned short sval;
- unsigned int ival;
- unsigned long lval;
- LONGEST llval;
-
- int size;
-
if (!register_valid[regno])
target_fetch_registers (regno);
- size = REGISTER_RAW_SIZE(regno);
-
- if (size == sizeof (unsigned char))
- return registers[REGISTER_BYTE (regno)];
- else if (size == sizeof (sval))
- {
- memcpy (&sval, ®isters[REGISTER_BYTE (regno)], sizeof (sval));
- SWAP_TARGET_AND_HOST (&sval, sizeof (sval));
- return sval;
- }
- else if (size == sizeof (ival))
- {
- memcpy (&ival, ®isters[REGISTER_BYTE (regno)], sizeof (ival));
- SWAP_TARGET_AND_HOST (&ival, sizeof (ival));
- return ival;
- }
- else if (size == sizeof (lval))
- {
- memcpy (&lval, ®isters[REGISTER_BYTE (regno)], sizeof (lval));
- SWAP_TARGET_AND_HOST (&lval, sizeof (lval));
- return lval;
- }
- else if (size == sizeof (llval))
- {
- memcpy (&llval, ®isters[REGISTER_BYTE (regno)], sizeof (llval));
- SWAP_TARGET_AND_HOST (&llval, sizeof (llval));
- return llval;
- }
- else
- {
- error ("GDB Internal Error in read_register() for register %d, size %d",
- regno, REGISTER_RAW_SIZE(regno));
- }
+ return extract_address (®isters[REGISTER_BYTE (regno)],
+ REGISTER_RAW_SIZE(regno));
}
/* Registers we shouldn't try to store. */
#define CANNOT_STORE_REGISTER(regno) 0
#endif
-/* Store VALUE in the register number REGNO, regarded as an integer. */
-/* FIXME, this loses when REGISTER_VIRTUAL (REGNO) is true. Also,
- shouldn't the val arg be a LONGEST or something? */
+/* Store VALUE, into the raw contents of register number REGNO. */
+/* FIXME: The val arg should probably be a LONGEST. */
void
write_register (regno, val)
int regno, val;
{
- unsigned char cval;
- unsigned short sval;
- unsigned int ival;
- unsigned long lval;
- LONGEST llval;
+ PTR buf;
int size;
- PTR ptr;
-
+
/* On the sparc, writing %g0 is a no-op, so we don't even want to change
the registers array if something writes to this register. */
if (CANNOT_STORE_REGISTER (regno))
return;
+ size = REGISTER_RAW_SIZE(regno);
+ buf = alloca (size);
+ store_signed_integer (buf, size, (LONGEST) val);
+
/* If we have a valid copy of the register, and new value == old value,
then don't bother doing the actual store. */
- size = REGISTER_RAW_SIZE(regno);
-
- if (size == sizeof(cval))
- {
- ptr = (PTR) &cval;
- cval = val;
- }
- else if (size == sizeof(sval))
- {
- ptr = (PTR) &sval;
- sval = val;
- }
- else if (size == sizeof(ival))
- {
- ptr = (PTR) &ival;
- ival = val;
- }
- else if (size == sizeof(lval))
- {
- ptr = (PTR) &lval;
- lval = val;
- }
- else if (size == sizeof(llval))
- {
- ptr = (PTR) &llval;
- llval = val;
- }
- else
- {
- error ("GDB Internal Error in write_register() for register %d, size %d",
- regno, size);
- }
-
- SWAP_TARGET_AND_HOST (ptr, size);
if (register_valid [regno])
{
- if (memcmp (®isters[REGISTER_BYTE (regno)],
- ptr, size) == 0)
+ if (memcmp (®isters[REGISTER_BYTE (regno)], buf, size) == 0)
return;
}
target_prepare_to_store ();
- memcpy (®isters[REGISTER_BYTE (regno)], ptr, size);
+ memcpy (®isters[REGISTER_BYTE (regno)], buf, size);
register_valid [regno] = 1;
switch (SYMBOL_CLASS (var))
{
case LOC_CONST:
- memcpy (VALUE_CONTENTS_RAW (v), &SYMBOL_VALUE (var), len);
- SWAP_TARGET_AND_HOST (VALUE_CONTENTS_RAW (v), len);
+ /* Put the constant back in target format. */
+ store_signed_integer (VALUE_CONTENTS_RAW (v), len,
+ (LONGEST) SYMBOL_VALUE (var));
VALUE_LVAL (v) = not_lval;
return v;
case LOC_LABEL:
- addr = SYMBOL_VALUE_ADDRESS (var);
- memcpy (VALUE_CONTENTS_RAW (v), &addr, len);
- SWAP_TARGET_AND_HOST (VALUE_CONTENTS_RAW (v), len);
+ /* Put the constant back in target format. */
+ store_address (VALUE_CONTENTS_RAW (v), len, SYMBOL_VALUE_ADDRESS (var));
VALUE_LVAL (v) = not_lval;
return v;
break;
case LOC_ARG:
- if (SYMBOL_BASEREG_VALID (var))
- {
- addr = FRAME_GET_BASEREG_VALUE (frame, SYMBOL_BASEREG (var));
- }
- else
- {
- fi = get_frame_info (frame);
- if (fi == NULL)
- return 0;
- addr = FRAME_ARGS_ADDRESS (fi);
- }
+ fi = get_frame_info (frame);
+ if (fi == NULL)
+ return 0;
+ addr = FRAME_ARGS_ADDRESS (fi);
if (!addr)
{
return 0;
}
addr += SYMBOL_VALUE (var);
break;
-
+
case LOC_REF_ARG:
- if (SYMBOL_BASEREG_VALID (var))
- {
- addr = FRAME_GET_BASEREG_VALUE (frame, SYMBOL_BASEREG (var));
- }
- else
- {
- fi = get_frame_info (frame);
- if (fi == NULL)
- return 0;
- addr = FRAME_ARGS_ADDRESS (fi);
- }
+ fi = get_frame_info (frame);
+ if (fi == NULL)
+ return 0;
+ addr = FRAME_ARGS_ADDRESS (fi);
if (!addr)
{
return 0;
}
addr += SYMBOL_VALUE (var);
- read_memory (addr, (char *) &addr, sizeof (CORE_ADDR));
+ addr = read_memory_unsigned_integer
+ (addr, TARGET_PTR_BIT / TARGET_CHAR_BIT);
break;
-
+
case LOC_LOCAL:
case LOC_LOCAL_ARG:
- if (SYMBOL_BASEREG_VALID (var))
- {
- addr = FRAME_GET_BASEREG_VALUE (frame, SYMBOL_BASEREG (var));
- }
- else
- {
- fi = get_frame_info (frame);
- if (fi == NULL)
- return 0;
- addr = FRAME_LOCALS_ADDRESS (fi);
- }
+ fi = get_frame_info (frame);
+ if (fi == NULL)
+ return 0;
+ addr = FRAME_LOCALS_ADDRESS (fi);
addr += SYMBOL_VALUE (var);
break;
+ case LOC_BASEREG:
+ case LOC_BASEREG_ARG:
+ {
+ char buf[MAX_REGISTER_RAW_SIZE];
+ get_saved_register (buf, NULL, NULL, frame, SYMBOL_BASEREG (var),
+ NULL);
+ addr = extract_address (buf, REGISTER_RAW_SIZE (SYMBOL_BASEREG (var)));
+ addr += SYMBOL_VALUE (var);
+ break;
+ }
+
case LOC_TYPEDEF:
error ("Cannot look up value of a typedef");
break;
/* Copy data to be written over corresponding part of buffer */
- bcopy (myaddr, (char *) buffer + (memaddr & (sizeof (int) - 1)), len);
+ memcpy ((char *) buffer + (memaddr & (sizeof (int) - 1)), myaddr, len);
/* Write the entire buffer. */
}
/* Copy appropriate bytes out of the buffer. */
- bcopy ((char *) buffer + (memaddr & (sizeof (int) - 1)), myaddr, len);
+ memcpy (myaddr, (char *) buffer + (memaddr & (sizeof (int) - 1)), len);
}
return len;
}
/* Copy data to be written over corresponding part of buffer */
- bcopy (myaddr, (char *) buffer + (memaddr & (sizeof (int) - 1)), len);
+ memcpy ((char *) buffer + (memaddr & (sizeof (int) - 1)), myaddr, len);
/* Write the entire buffer. */
}
/* Copy appropriate bytes out of the buffer. */
- bcopy ((char *) buffer + (memaddr & (sizeof (int) - 1)), myaddr, len);
+ memcpy (myaddr, (char *) buffer + (memaddr & (sizeof (int) - 1)), len);
}
return len;
}
ptrace (PTRACE_GETFPREGS, inferior_pid,
(PTRACE_ARG3_TYPE) &inferior_fp_registers);
- bcopy (&inferior_registers, registers, sizeof inferior_registers);
+ memcpy (registers, &inferior_registers, sizeof inferior_registers);
- bcopy (inferior_fp_registers.f_st,®isters[REGISTER_BYTE (FP0_REGNUM)],
+ memcpy (®isters[REGISTER_BYTE (FP0_REGNUM)],
+ inferior_fp_registers.f_st,
sizeof inferior_fp_registers.f_st);
- bcopy (&inferior_fp_registers.f_ctrl,
- ®isters[REGISTER_BYTE (FPC_REGNUM)],
+ memcpy (®isters[REGISTER_BYTE (FPC_REGNUM)],
+ &inferior_fp_registers.f_ctrl,
sizeof inferior_fp_registers - sizeof inferior_fp_registers.f_st);
}
struct fp_state inferior_fp_registers;
extern char registers[];
- bcopy (registers, &inferior_registers, 20 * 4);
+ memcpy (&inferior_registers, registers, 20 * 4);
- bcopy (®isters[REGISTER_BYTE (FP0_REGNUM)],inferior_fp_registers.f_st,
+ memcpy (inferior_fp_registers.f_st,®isters[REGISTER_BYTE (FP0_REGNUM)],
sizeof inferior_fp_registers.f_st);
- bcopy (®isters[REGISTER_BYTE (FPC_REGNUM)],
- &inferior_fp_registers.f_ctrl,
+ memcpy (&inferior_fp_registers.f_ctrl,
+ ®isters[REGISTER_BYTE (FPC_REGNUM)],
sizeof inferior_fp_registers - sizeof inferior_fp_registers.f_st);
#ifdef PTRACE_FP_BUG
switch (which) {
case 0:
case 1:
- bcopy (core_reg_sect, registers, core_reg_size);
+ memcpy (registers, core_reg_sect, core_reg_size);
break;
case 2:
#ifdef FP0_REGNUM
- bcopy (core_reg_sect,
- ®isters[REGISTER_BYTE (FP0_REGNUM)],
+ memcpy (®isters[REGISTER_BYTE (FP0_REGNUM)],
+ core_reg_sect,
core_reg_size); /* FIXME, probably bogus */
#endif
#ifdef FPC_REGNUM
- bcopy (&corestr.c_fpu.f_fpstatus.f_ctrl,
- ®isters[REGISTER_BYTE (FPC_REGNUM)],
+ memcpy (®isters[REGISTER_BYTE (FPC_REGNUM)],
+ &corestr.c_fpu.f_fpstatus.f_ctrl,
sizeof corestr.c_fpu.f_fpstatus -
sizeof corestr.c_fpu.f_fpstatus.f_st);
#endif
{
from = (char *) ®isters[REGISTER_BYTE (regi)];
to = (char *) &(fpregsetp->fp_r.fp_regs[regi - FP0_REGNUM]);
- bcopy(from, to, REGISTER_RAW_SIZE (regi));
+ memcpy(to, from, REGISTER_RAW_SIZE (regi));
}
}
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
#include "defs.h"
-#include "ieee-float.h"
#include "frame.h"
#include "symtab.h"
-const struct ext_format ext_format_68881 = {
-/* tot sbyte smask expbyte manbyte */
- 12, 0, 0x80, 0,1, 4,8 /* mc68881 */
-};
-
\f
/* Things needed for making the inferior call functions.
It seems like every m68k based machine has almost identical definitions
return (ip);
}
+void
+m68k_find_saved_regs (frame_info, saved_regs)
+ struct frame_info *frame_info;
+ struct frame_saved_regs *saved_regs;
+{
+ register int regnum;
+ register int regmask;
+ register CORE_ADDR next_addr;
+ register CORE_ADDR pc;
+
+ /* First possible address for a pc in a call dummy for this frame. */
+ CORE_ADDR possible_call_dummy_start =
+ (frame_info)->frame - CALL_DUMMY_LENGTH - FP_REGNUM*4 - 4
+#if defined (HAVE_68881)
+ - 8*12
+#endif
+ ;
+
+ int nextinsn;
+ memset (saved_regs, 0, sizeof (*saved_regs));
+ if ((frame_info)->pc >= possible_call_dummy_start
+ && (frame_info)->pc <= (frame_info)->frame)
+ {
+
+ /* It is a call dummy. We could just stop now, since we know
+ what the call dummy saves and where. But this code proceeds
+ to parse the "prologue" which is part of the call dummy.
+ This is needlessly complex, confusing, and also is the only
+ reason that the call dummy is customized based on HAVE_68881.
+ FIXME. */
+
+ next_addr = (frame_info)->frame;
+ pc = possible_call_dummy_start;
+ }
+ else
+ {
+ pc = get_pc_function_start ((frame_info)->pc);
+ /* Verify we have a link a6 instruction next;
+ if not we lose. If we win, find the address above the saved
+ regs using the amount of storage from the link instruction. */
+ if (044016 == read_memory_integer (pc, 2))
+ next_addr = (frame_info)->frame + read_memory_integer (pc += 2, 4), pc+=4;
+ else if (047126 == read_memory_integer (pc, 2))
+ next_addr = (frame_info)->frame + read_memory_integer (pc += 2, 2), pc+=2;
+ else goto lose;
+ /* If have an addal #-n, sp next, adjust next_addr. */
+ if ((0177777 & read_memory_integer (pc, 2)) == 0157774)
+ next_addr += read_memory_integer (pc += 2, 4), pc += 4;
+ }
+ regmask = read_memory_integer (pc + 2, 2);
+#if defined (HAVE_68881)
+ /* Here can come an fmovem. Check for it. */
+ nextinsn = 0xffff & read_memory_integer (pc, 2);
+ if (0xf227 == nextinsn
+ && (regmask & 0xff00) == 0xe000)
+ { pc += 4; /* Regmask's low bit is for register fp7, the first pushed */
+ for (regnum = FP0_REGNUM + 7; regnum >= FP0_REGNUM; regnum--, regmask >>= 1)
+ if (regmask & 1)
+ saved_regs->regs[regnum] = (next_addr -= 12);
+ regmask = read_memory_integer (pc + 2, 2); }
+#endif
+ /* next should be a moveml to (sp) or -(sp) or a movl r,-(sp) */
+ if (0044327 == read_memory_integer (pc, 2))
+ { pc += 4; /* Regmask's low bit is for register 0, the first written */
+ for (regnum = 0; regnum < 16; regnum++, regmask >>= 1)
+ if (regmask & 1)
+ saved_regs->regs[regnum] = (next_addr += 4) - 4; }
+ else if (0044347 == read_memory_integer (pc, 2))
+ {
+ pc += 4; /* Regmask's low bit is for register 15, the first pushed */
+ for (regnum = 15; regnum >= 0; regnum--, regmask >>= 1)
+ if (regmask & 1)
+ saved_regs->regs[regnum] = (next_addr -= 4);
+ }
+ else if (0x2f00 == (0xfff0 & read_memory_integer (pc, 2)))
+ {
+ regnum = 0xf & read_memory_integer (pc, 2); pc += 2;
+ saved_regs->regs[regnum] = (next_addr -= 4);
+ /* gcc, at least, may use a pair of movel instructions when saving
+ exactly 2 registers. */
+ if (0x2f00 == (0xfff0 & read_memory_integer (pc, 2)))
+ {
+ regnum = 0xf & read_memory_integer (pc, 2);
+ pc += 2;
+ saved_regs->regs[regnum] = (next_addr -= 4);
+ }
+ }
+#if defined (HAVE_68881)
+ /* fmovemx to index of sp may follow. */
+ regmask = read_memory_integer (pc + 2, 2);
+ nextinsn = 0xffff & read_memory_integer (pc, 2);
+ if (0xf236 == nextinsn
+ && (regmask & 0xff00) == 0xf000)
+ { pc += 10; /* Regmask's low bit is for register fp0, the first written */
+ for (regnum = FP0_REGNUM + 7; regnum >= FP0_REGNUM; regnum--, regmask >>= 1)
+ if (regmask & 1)
+ saved_regs->regs[regnum] = (next_addr += 12) - 12;
+ regmask = read_memory_integer (pc + 2, 2); }
+#endif
+ /* clrw -(sp); movw ccr,-(sp) may follow. */
+ if (0x426742e7 == read_memory_integer (pc, 4))
+ saved_regs->regs[PS_REGNUM] = (next_addr -= 4);
+ lose: ;
+ saved_regs->regs[SP_REGNUM] = (frame_info)->frame + 8;
+ saved_regs->regs[FP_REGNUM] = (frame_info)->frame;
+ saved_regs->regs[PC_REGNUM] = (frame_info)->frame + 4;
+#ifdef SIG_SP_FP_OFFSET
+ /* Adjust saved SP_REGNUM for fake _sigtramp frames. */
+ if (frame_info->signal_handler_caller && frame_info->next)
+ saved_regs->regs[SP_REGNUM] = frame_info->next->frame + SIG_SP_FP_OFFSET;
+#endif
+}
+
+
#ifdef USE_PROC_FS /* Target dependent support for /proc */
#include <sys/procfs.h>
{
from = (char *) ®isters[REGISTER_BYTE (regi)];
to = (char *) &(fpregsetp -> f_fpregs[regi-FP0_REGNUM][0]);
- bcopy (from, to, REGISTER_RAW_SIZE (regi));
+ memcpy (to, from, REGISTER_RAW_SIZE (regi));
}
}
if ((regno == -1) || (regno == FPC_REGNUM))
get_longjmp_target(pc)
CORE_ADDR *pc;
{
+ char buf[TARGET_PTR_BIT / TARGET_CHAR_BIT];
CORE_ADDR sp, jb_addr;
sp = read_register(SP_REGNUM);
- if (target_read_memory(sp + SP_ARG0, /* Offset of first arg on stack */
- &jb_addr,
- sizeof(CORE_ADDR)))
+ if (target_read_memory (sp + SP_ARG0, /* Offset of first arg on stack */
+ buf,
+ TARGET_PTR_BIT / TARGET_CHAR_BIT))
return 0;
+ jb_addr = extract_address (buf, TARGET_PTR_BIT / TARGET_CHAR_BIT);
- SWAP_TARGET_AND_HOST(&jb_addr, sizeof(CORE_ADDR));
-
- if (target_read_memory(jb_addr + JB_PC * JB_ELEMENT_SIZE, pc,
- sizeof(CORE_ADDR)))
+ if (target_read_memory (jb_addr + JB_PC * JB_ELEMENT_SIZE, buf,
+ TARGET_PTR_BIT / TARGET_CHAR_BIT))
return 0;
- SWAP_TARGET_AND_HOST(pc, sizeof(CORE_ADDR));
+ *pc = extract_address (buf, TARGET_PTR_BIT / TARGET_CHAR_BIT);
return 1;
}
#endif /* GET_LONGJMP_TARGET */
/* Immediately after a function call, return the saved pc before the frame
- is setup. We check for the common case of being inside of a system call,
- and if so, we know that Sun pushes the call # on the stack prior to doing
- the trap. */
+ is setup. For sun3's, we check for the common case of being inside of a
+ system call, and if so, we know that Sun pushes the call # on the stack
+ prior to doing the trap. */
CORE_ADDR
m68k_saved_pc_after_call(frame)
struct frame_info *frame;
{
-#ifdef sun
+#ifdef GDB_TARGET_IS_SUN3
int op;
op = read_memory_integer (frame->pc, 2);
if (op == P_TRAP)
return read_memory_integer (read_register (SP_REGNUM) + 4, 4);
else
-#endif /* sun */
+#endif /* GDB_TARGET_IS_SUN3 */
return read_memory_integer (read_register (SP_REGNUM), 4);
}
{
char retbuf[REGISTER_BYTES];
- bcopy (registers, retbuf, REGISTER_BYTES);
+ memcpy (retbuf, registers, REGISTER_BYTES);
*rval = value_being_returned (value_type, retbuf, struct_return);
return;
}
/* Generate a template for the type of this function. The
types of the arguments will be added as we read the symbol
table. */
- bcopy (SYMBOL_TYPE (s), lookup_function_type (t), sizeof (struct type));
+ memcpy (lookup_function_type (t), SYMBOL_TYPE (s), sizeof (struct type));
#else
SYMBOL_TYPE (s) = lookup_function_type (t);
#endif
#else /* not emacs */
-#define bcopy(s,d,n) memcpy((d),(s),(n))
#define bcmp(s1,s2,n) memcmp((s1),(s2),(n))
#define bzero(s,n) memset((s),0,(n))
return -2;
stackx = (unsigned char **) alloca (2 * (stacke - stackb)
* sizeof (char *));
- bcopy (stackb, stackx, (stacke - stackb) * sizeof (char *));
+ memcpy (stackx, stackb, (stacke - stackb) * sizeof (char *));
stackp = stackx + (stackp - stackb);
stacke = stackx + 2 * (stacke - stackb);
stackb = stackx;
unsigned char **stackx
= (unsigned char **) alloca (2 * (stacke - stackb)
* sizeof (char *));
- bcopy (stackb, stackx, (stacke - stackb) * sizeof (char *));
+ memcpy (stackx, stackb, (stacke - stackb) * sizeof (char *));
stackp = stackx + (stackp - stackb);
stacke = stackx + 2 * (stacke - stackb);
stackb = stackx;
#include "dcache.h"
extern int sleep();
-extern int bcopy();
/* External data declarations */
extern int stop_soon_quietly; /* for wait_for_inferior */
/* Copy data to be written over corresponding part of buffer */
- bcopy (myaddr, (char *) buffer + (memaddr & (sizeof (int) - 1)), len);
+ memcpy ((char *) buffer + (memaddr & (sizeof (int) - 1)), myaddr, len);
/* Write the entire buffer. */
}
/* Copy appropriate bytes out of the buffer. */
- bcopy ((char *) buffer + (memaddr & (sizeof (int) - 1)), myaddr, len);
+ memcpy (myaddr, (char *) buffer + (memaddr & (sizeof (int) - 1)), len);
}
return len;
/* Copy data to be written over corresponding part of buffer */
- bcopy (myaddr, (char *) buffer + (memaddr & (sizeof (int) - 1)), len);
+ memcpy ((char *) buffer + (memaddr & (sizeof (int) - 1)), myaddr, len);
/* Write the entire buffer. */
}
/* Copy appropriate bytes out of the buffer. */
- bcopy ((char *) buffer + (memaddr & (sizeof (int) - 1)), myaddr, len);
+ memcpy (myaddr, (char *) buffer + (memaddr & (sizeof (int) - 1)), len);
}
return len;
if (which == 0) {
/* copy GPRs first. */
- bcopy (core_reg_sect, registers, 32 * 4);
+ memcpy (registers, core_reg_sect, 32 * 4);
/* gdb's internal register template and bfd's register section layout
should share a common include file. FIXMEmgo */
/* then comes special registes. They are supposed to be in the same
order in gdb template and bfd `.reg' section. */
core_reg_sect += (32 * 4);
- bcopy (core_reg_sect, ®isters [REGISTER_BYTE (FIRST_SP_REGNUM)],
+ memcpy (®isters [REGISTER_BYTE (FIRST_SP_REGNUM)], core_reg_sect,
(LAST_SP_REGNUM - FIRST_SP_REGNUM + 1) * 4);
}
/* fetch floating point registers from register section 2 in core bfd. */
else if (which == 2)
- bcopy (core_reg_sect, ®isters [REGISTER_BYTE (FP0_REGNUM)], 32 * 8);
+ memcpy (®isters [REGISTER_BYTE (FP0_REGNUM)], core_reg_sect, 32 * 8);
else
fprintf (stderr, "Gdb error: unknown parameter to fetch_core_registers().\n");
printf (
"Fatal Error: a floating point parameter #%d with a size > 8 is found!\n", argno);
- bcopy (VALUE_CONTENTS (arg),
- ®isters[REGISTER_BYTE(FP0_REGNUM + 1 + f_argno)], len);
+ memcpy (®isters[REGISTER_BYTE(FP0_REGNUM + 1 + f_argno)], VALUE_CONTENTS (arg),
+ len);
++f_argno;
}
while (argbytes < len) {
*(int*)®isters[REGISTER_BYTE(ii+3)] = 0;
- bcopy ( ((char*)VALUE_CONTENTS (arg))+argbytes,
- ®isters[REGISTER_BYTE(ii+3)],
+ memcpy (®isters[REGISTER_BYTE(ii+3)],
+ ((char*)VALUE_CONTENTS (arg))+argbytes,
(len - argbytes) > 4 ? 4 : len - argbytes);
++ii, argbytes += 4;
}
else { /* Argument can fit in one register. No problem. */
*(int*)®isters[REGISTER_BYTE(ii+3)] = 0;
- bcopy (VALUE_CONTENTS (arg), ®isters[REGISTER_BYTE(ii+3)], len);
+ memcpy (®isters[REGISTER_BYTE(ii+3)], VALUE_CONTENTS (arg), len);
}
++argno;
}
printf (
"Fatal Error: a floating point parameter #%d with a size > 8 is found!\n", argno);
- bcopy (VALUE_CONTENTS (arg),
- ®isters[REGISTER_BYTE(FP0_REGNUM + 1 + f_argno)], len);
+ memcpy (®isters[REGISTER_BYTE(FP0_REGNUM + 1 + f_argno)], VALUE_CONTENTS (arg),
+ len);
++f_argno;
}
necessary. */
if (TYPE_LENGTH (valtype) > 4) /* this is a double */
- bcopy (®buf[REGISTER_BYTE (FP0_REGNUM + 1)], valbuf,
+ memcpy (valbuf, ®buf[REGISTER_BYTE (FP0_REGNUM + 1)],
TYPE_LENGTH (valtype));
else { /* float */
- bcopy (®buf[REGISTER_BYTE (FP0_REGNUM + 1)], &dd, 8);
+ memcpy (&dd, ®buf[REGISTER_BYTE (FP0_REGNUM + 1)], 8);
ff = (float)dd;
- bcopy (&ff, valbuf, sizeof(float));
+ memcpy (valbuf, &ff, sizeof(float));
}
}
else
/* return value is copied starting from r3. */
- bcopy (®buf[REGISTER_BYTE (3)], valbuf, TYPE_LENGTH (valtype));
+ memcpy (valbuf, ®buf[REGISTER_BYTE (3)], TYPE_LENGTH (valtype));
}
perror("ptrace_getfpregs");
memcpy (®isters[REGISTER_BYTE (FP0_REGNUM)], &inferior_fp_registers,
sizeof inferior_fp_registers.fpu_fr);
- /* bcopy (&inferior_fp_registers.Fpu_fsr,
- ®isters[REGISTER_BYTE (FPS_REGNUM)],
+ /* memcpy (®isters[REGISTER_BYTE (FPS_REGNUM)],
+ &inferior_fp_registers.Fpu_fsr,
sizeof (FPU_FSR_TYPE)); FIXME??? -- gnu@cyg */
for (i = FP0_REGNUM; i <= FP0_REGNUM+31; i++)
register_valid[i] = 1;
SYMBOL_LANGUAGE (sym) = current_subfile -> language;
SYMBOL_NAME (sym) = (char *)
obstack_alloc (&objfile -> symbol_obstack, ((p - string) + 1));
- /* Open-coded bcopy--saves function call time. */
+ /* Open-coded memcpy--saves function call time. */
/* FIXME: Does it really? Try replacing with simple strcpy and
try it on an executable with a large symbol table. */
+ /* FIXME: considering that gcc can open code memcpy anyway, I
+ doubt it. xoxorich. */
{
register char *p1 = string;
register char *p2 = SYMBOL_NAME (sym);
(PTRACE_ARG3_TYPE) &inferior_fp_registers);
#endif
- bcopy (&inferior_registers, registers, 16 * 4);
+ memcpy (registers, &inferior_registers, 16 * 4);
#ifdef FP0_REGNUM
- bcopy (&inferior_fp_registers, ®isters[REGISTER_BYTE (FP0_REGNUM)],
+ memcpy (®isters[REGISTER_BYTE (FP0_REGNUM)], &inferior_fp_registers,
sizeof inferior_fp_registers.fps_regs);
#endif
*(int *)®isters[REGISTER_BYTE (PS_REGNUM)] = inferior_registers.r_ps;
*(int *)®isters[REGISTER_BYTE (PC_REGNUM)] = inferior_registers.r_pc;
#ifdef FP0_REGNUM
- bcopy (&inferior_fp_registers.fps_control,
- ®isters[REGISTER_BYTE (FPC_REGNUM)],
+ memcpy (®isters[REGISTER_BYTE (FPC_REGNUM)],
+ &inferior_fp_registers.fps_control,
sizeof inferior_fp_registers - sizeof inferior_fp_registers.fps_regs);
#endif
}
#endif
extern char registers[];
- bcopy (registers, &inferior_registers, 16 * 4);
+ memcpy (&inferior_registers, registers, 16 * 4);
#ifdef FP0_REGNUM
- bcopy (®isters[REGISTER_BYTE (FP0_REGNUM)], &inferior_fp_registers,
+ memcpy (&inferior_fp_registers, ®isters[REGISTER_BYTE (FP0_REGNUM)],
sizeof inferior_fp_registers.fps_regs);
#endif
inferior_registers.r_ps = *(int *)®isters[REGISTER_BYTE (PS_REGNUM)];
inferior_registers.r_pc = *(int *)®isters[REGISTER_BYTE (PC_REGNUM)];
#ifdef FP0_REGNUM
- bcopy (®isters[REGISTER_BYTE (FPC_REGNUM)],
- &inferior_fp_registers.fps_control,
+ memcpy (&inferior_fp_registers.fps_control,
+ ®isters[REGISTER_BYTE (FPC_REGNUM)],
sizeof inferior_fp_registers - sizeof inferior_fp_registers.fps_regs);
#endif
if (core_reg_size < sizeof (struct regs))
error ("Can't find registers in core file");
- bcopy ((char *)regs, registers, 16 * 4);
+ memcpy (registers, (char *)regs, 16 * 4);
supply_register (PS_REGNUM, (char *)®s->r_ps);
supply_register (PC_REGNUM, (char *)®s->r_pc);
if (core_reg_size >= sizeof (struct fpu))
{
#ifdef FP0_REGNUM
- bcopy (fpustruct->f_fpstatus.fps_regs,
- ®isters[REGISTER_BYTE (FP0_REGNUM)],
+ memcpy (®isters[REGISTER_BYTE (FP0_REGNUM)],
+ fpustruct->f_fpstatus.fps_regs,
sizeof fpustruct->f_fpstatus.fps_regs);
- bcopy (&fpustruct->f_fpstatus.fps_control,
- ®isters[REGISTER_BYTE (FPC_REGNUM)],
+ memcpy (®isters[REGISTER_BYTE (FPC_REGNUM)],
+ &fpustruct->f_fpstatus.fps_control,
sizeof fpustruct->f_fpstatus -
sizeof fpustruct->f_fpstatus.fps_regs);
#endif
data_offset = sizeof corestr;
stack_offset = sizeof corestr + corestr.c_dsize;
- bcopy (&corestr.c_regs, registers, sizeof corestr.c_regs);
+ memcpy (registers, &corestr.c_regs, sizeof corestr.c_regs);
- bcopy (corestr.c_fpu.f_fpstatus.f_st,
- ®isters[REGISTER_BYTE (FP0_REGNUM)],
+ memcpy (®isters[REGISTER_BYTE (FP0_REGNUM)],
+ corestr.c_fpu.f_fpstatus.f_st,
sizeof corestr.c_fpu.f_fpstatus.f_st);
- bcopy (&corestr.c_fpu.f_fpstatus.f_ctrl,
- ®isters[REGISTER_BYTE (FPC_REGNUM)],
+ memcpy (®isters[REGISTER_BYTE (FPC_REGNUM)],
+ &corestr.c_fpu.f_fpstatus.f_ctrl,
sizeof corestr.c_fpu.f_fpstatus -
sizeof corestr.c_fpu.f_fpstatus.f_st);
/* the struct aouthdr of sun coff is not the struct exec stored
in the core file. */
- bcopy (&corestr.c_aouthdr, &core_aouthdr, sizeof (struct exec));
+ memcpy (&core_aouthdr, &corestr.c_aouthdr, sizeof (struct exec));
#ifndef COFF_ENCAPSULATE
core_aouthdr.magic = corestr.c_aouthdr.a_info;
core_aouthdr.vstamp = /*SUNVERSION*/ 31252;
ptrace (PTRACE_GETFPREGS, inferior_pid,
(PTRACE_ARG3_TYPE) &inferior_fp_registers);
- bcopy (&inferior_registers, registers, sizeof inferior_registers);
+ memcpy (registers, &inferior_registers, sizeof inferior_registers);
- bcopy (inferior_fp_registers.f_st,®isters[REGISTER_BYTE (FP0_REGNUM)],
+ memcpy (®isters[REGISTER_BYTE (FP0_REGNUM)],inferior_fp_registers.f_st,
sizeof inferior_fp_registers.f_st);
- bcopy (&inferior_fp_registers.f_ctrl,
- ®isters[REGISTER_BYTE (FPC_REGNUM)],
+ memcpy (®isters[REGISTER_BYTE (FPC_REGNUM)],
+ &inferior_fp_registers.f_ctrl,
sizeof inferior_fp_registers - sizeof inferior_fp_registers.f_st);
}
struct fp_state inferior_fp_registers;
extern char registers[];
- bcopy (registers, &inferior_registers, 20 * 4);
+ memcpy (&inferior_registers, registers, 20 * 4);
- bcopy (®isters[REGISTER_BYTE (FP0_REGNUM)],inferior_fp_registers.f_st,
+ memcpy (inferior_fp_registers.f_st,
+ ®isters[REGISTER_BYTE (FP0_REGNUM)],
sizeof inferior_fp_registers.f_st);
- bcopy (®isters[REGISTER_BYTE (FPC_REGNUM)],
- &inferior_fp_registers.f_ctrl,
+ memcpy (&inferior_fp_registers.f_ctrl,
+ ®isters[REGISTER_BYTE (FPC_REGNUM)],
sizeof inferior_fp_registers - sizeof inferior_fp_registers.f_st);
#ifdef PTRACE_FP_BUG
static void
find_sym_fns PARAMS ((struct objfile *));
-void
-clear_symtab_users_once PARAMS ((void));
-
/* List of all available sym_fns. On gdb startup, each object file reader
calls add_symtab_fns() to register information on each format it is
prepared to read. */
#endif
\f
-/* In the following sort, we always make sure that
- register debug symbol declarations always come before regular
- debug symbol declarations (as might happen when parameters are
- then put into registers by the compiler).
-
- Since this function is called from within qsort, in an ANSI environment
+/* Since this function is called from within qsort, in an ANSI environment
it must conform to the prototype for qsort, which specifies that the
comparison function takes two "void *" pointers. */
const PTR s2p;
{
register struct symbol **s1, **s2;
- register int namediff;
s1 = (struct symbol **) s1p;
s2 = (struct symbol **) s2p;
- /* Compare the initial characters. */
- namediff = SYMBOL_NAME (*s1)[0] - SYMBOL_NAME (*s2)[0];
- if (namediff != 0) return namediff;
-
- /* If they match, compare the rest of the names. */
- namediff = STRCMP (SYMBOL_NAME (*s1), SYMBOL_NAME (*s2));
- if (namediff != 0) return namediff;
-
- /* For symbols of the same name, registers should come first. */
- return ((SYMBOL_CLASS (*s2) == LOC_REGISTER)
- - (SYMBOL_CLASS (*s1) == LOC_REGISTER));
+ return (STRCMP (SYMBOL_NAME (*s1), SYMBOL_NAME (*s2)));
}
/*
struct obstack *obstackp;
{
register char *p = (char *) obstack_alloc (obstackp, size + 1);
- /* Open-coded bcopy--saves function call time.
+ /* Open-coded memcpy--saves function call time.
These strings are usually short. */
{
register char *p1 = ptr;
{
struct section_offsets *section_offsets;
asection *lowest_sect;
+ struct cleanup *old_chain;
init_entry_point_info (objfile);
find_sym_fns (objfile);
+ /* Make sure that partially constructed symbol tables will be cleaned up
+ if an error occurs during symbol reading. */
+ old_chain = make_cleanup (free_objfile, objfile);
+
if (mainline)
{
+ /* We will modify the main symbol table, make sure that all its users
+ will be cleaned up if an error occurs during symbol reading. */
+ make_cleanup (clear_symtab_users, 0);
+
/* Since no error yet, throw away the old symbol table. */
if (symfile_objfile != NULL)
that this does not mean we found any symbols... */
objfile -> flags |= OBJF_SYMS;
+
+ /* Discard cleanups as symbol reading was successful. */
+
+ discard_cleanups (old_chain);
}
-/* Perform required actions immediately after either reading in the initial
+/* Perform required actions after either reading in the initial
symbols for a new objfile, or mapping in the symbols from a reusable
objfile. */
int mainline;
int verbo;
{
+
+ /* If this is the main symbol file we have to clean up all users of the
+ old main symbol file. Otherwise it is sufficient to fixup all the
+ breakpoints that may have been redefined by this symbol file. */
if (mainline)
{
/* OK, make it the "real" symbol file. */
symfile_objfile = objfile;
- }
- /* If we have wiped out any old symbol tables, clean up. */
- clear_symtab_users_once ();
+ clear_symtab_users ();
+ }
+ else
+ {
+ breakpoint_re_set ();
+ }
/* We're done reading the symbol file; finish off complaints. */
clear_complaints (0, verbo);
-
- /* Fixup all the breakpoints that may have been redefined by this
- symbol file. */
-
- breakpoint_re_set ();
}
/* Process a symbol file, as either the main file or as a dynamically
&& from_tty
&& !query ("Load new symbol table from \"%s\"? ", name))
error ("Not confirmed.");
-
- /* Getting new symbols may change our opinion about what is
- frameless. */
-
- reinit_frame_cache ();
objfile = allocate_objfile (abfd, mapped);
syms_from_objfile (objfile, addr, mainline, from_tty);
}
- new_symfile_objfile (objfile, mainline, from_tty);
-
/* We now have at least a partial symbol table. Check to see if the
user requested that all symbols be read on initial access via either
the gdb startup command line or on a per symbol file basis. Expand
fflush (stdout);
}
+ new_symfile_objfile (objfile, mainline, from_tty);
+
+ /* Getting new symbols may change our opinion about what is
+ frameless. */
+
+ reinit_frame_cache ();
+
return (objfile);
}
error ("Not confirmed.");
free_all_objfiles ();
symfile_objfile = NULL;
- current_source_symtab = NULL;
- current_source_line = 0;
if (from_tty)
{
printf ("No symbol file now.\n");
name = absolute_name; /* Keep 2nd malloc'd copy in bfd */
/* It'll be freed in free_objfile(). */
- sym_bfd = bfd_fdopenr (name, NULL, desc);
+ sym_bfd = bfd_fdopenr (name, gnutarget, desc);
if (!sym_bfd)
{
close (desc);
target_load (arg, from_tty);
}
+/* This version of "load" should be usable for any target. Currently
+ it is just used for remote targets, not inftarg.c or core files,
+ on the theory that only in that case is it useful.
+
+ Avoiding xmodem and the like seems like a win (a) because we don't have
+ to worry about finding it, and (b) On VMS, fork() is very slow and so
+ we don't want to run a subprocess. On the other hand, I'm not sure how
+ performance compares. */
+void
+generic_load (filename, from_tty)
+ char *filename;
+ int from_tty;
+{
+ struct cleanup *old_cleanups;
+ asection *s;
+ bfd *loadfile_bfd = bfd_openr (filename, gnutarget);
+ if (loadfile_bfd == NULL)
+ {
+ perror_with_name (filename);
+ return;
+ }
+ old_cleanups = make_cleanup (bfd_close, loadfile_bfd);
+
+ if (!bfd_check_format (loadfile_bfd, bfd_object))
+ {
+ error ("\"%s\" is not an object file: %s", filename,
+ bfd_errmsg (bfd_error));
+ }
+
+ for (s = loadfile_bfd->sections; s; s = s->next)
+ {
+ if (s->flags & SEC_LOAD)
+ {
+ bfd_size_type size;
+
+ size = bfd_get_section_size_before_reloc (s);
+ if (size > 0)
+ {
+ char *buffer;
+ struct cleanup *old_chain;
+ bfd_vma vma;
+
+ buffer = xmalloc (size);
+ old_chain = make_cleanup (free, buffer);
+
+ vma = bfd_get_section_vma (loadfile_bfd, s);
+
+ /* Is this really necessary? I guess it gives the user something
+ to look at during a long download. */
+ printf_filtered ("Loading section %s, size 0x%x vma 0x%x\n",
+ bfd_get_section_name (loadfile_bfd, s),
+ size, vma);
+
+ bfd_get_section_contents (loadfile_bfd, s, buffer, 0, size);
+
+ target_write_memory (vma, buffer, size);
+
+ do_cleanups (old_chain);
+ }
+ }
+ }
+
+ /* We were doing this in remote-mips.c, I suspect it is right
+ for other targets too. */
+ write_pc (loadfile_bfd->start_address);
+
+ /* FIXME: are we supposed to call symbol_file_add or not? According to
+ a comment from remote-mips.c (where a call to symbol_file_add was
+ commented out), making the call confuses GDB if more than one file is
+ loaded in. remote-nindy.c had no call to symbol_file_add, but remote-vx.c
+ does. */
+
+ do_cleanups (old_cleanups);
+}
+
/* This function allows the addition of incrementally linked object files.
It does not modify any state in the target, only in the debugger. */
}
\f
+/* Reset all data structures in gdb which may contain references to symbol
+ table date. */
+
+void
+clear_symtab_users ()
+{
+ /* Someday, we should do better than this, by only blowing away
+ the things that really need to be blown. */
+ clear_value_history ();
+ clear_displays ();
+ clear_internalvars ();
+ breakpoint_re_set ();
+ set_default_breakpoint (0, 0, 0, 0);
+ current_source_symtab = 0;
+ current_source_line = 0;
+}
+
/* clear_symtab_users_once:
This function is run after symbol reading, or from a cleanup.
reading, is because the cleanup protects us in case of errors, but is
discarded if symbol reading is successful. */
+#if 0
+ /* FIXME: As free_named_symtabs is currently a big noop this function
+ is no longer needed.
+static void
+clear_symtab_users_once PARAMS ((void));
+
static int clear_symtab_users_queued;
static int clear_symtab_users_done;
-void
+static void
clear_symtab_users_once ()
{
/* Enforce once-per-`do_cleanups'-semantics */
return;
clear_symtab_users_done = clear_symtab_users_queued;
- printf ("Resetting debugger state after updating old symbol tables\n");
-
- /* Someday, we should do better than this, by only blowing away
- the things that really need to be blown. */
- clear_value_history ();
- clear_displays ();
- clear_internalvars ();
- breakpoint_re_set ();
- set_default_breakpoint (0, 0, 0, 0);
- current_source_symtab = 0;
+ clear_symtab_users ();
}
+#endif
/* Delete the specified psymtab, and any others that reference it. */
void
_initialize_symfile ()
{
-
- add_com ("symbol-file", class_files, symbol_file_command,
+ struct cmd_list_element *c;
+
+ c = add_cmd ("symbol-file", class_files, symbol_file_command,
"Load symbol table from executable file FILE.\n\
The `file' command can also load symbol tables, as well as setting the file\n\
-to execute.");
+to execute.", &cmdlist);
+ c->completer = filename_completer;
- add_com ("add-symbol-file", class_files, add_symbol_file_command,
+ c = add_cmd ("add-symbol-file", class_files, add_symbol_file_command,
"Load the symbols from FILE, assuming FILE has been dynamically loaded.\n\
-The second argument provides the starting address of the file's text.");
+The second argument provides the starting address of the file's text.",
+ &cmdlist);
+ c->completer = filename_completer;
- add_com ("load", class_files, load_command,
+ c = add_cmd ("load", class_files, load_command,
"Dynamically load FILE into the running program, and record its symbols\n\
-for access from GDB.");
+for access from GDB.", &cmdlist);
+ c->completer = filename_completer;
add_show_from_set
(add_set_cmd ("symbol-reloading", class_support, var_boolean,
stack_offset = data_offset + u.pt_dsize;
reg_offset = 0;
- bcopy (&u.pt_aouthdr, &core_aouthdr, sizeof (AOUTHDR));
+ memcpy (&core_aouthdr, &u.pt_aouthdr, sizeof (AOUTHDR));
printf ("Core file is from \"%s\".\n", u.pt_comm);
if (u.pt_signal > 0)
printf ("Program terminated with signal %d, %s.\n",
if (strtbl == NULL)
return -1;
- bcopy(&length, strtbl, sizeof length);
+ memcpy(strtbl, &length, sizeof length);
if (length == sizeof length)
return 0;
projects / binutils-gdb.git / commitdiff