X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Fremote-vx.c;h=6824f80d4c07aa233becc28fbad51bc4c994c19a;hb=25286543da71d927d59a7479e7e1bd0a1b9e1321;hp=171e712ed6dd1b6b10d57ba6b89b16c8d19de30c;hpb=8f1f2a72bd2009b97fe1e2139072359e25068e3e;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/remote-vx.c b/gdb/remote-vx.c index 171e712ed6..6824f80d4c 100644 --- a/gdb/remote-vx.c +++ b/gdb/remote-vx.c @@ -1,5 +1,5 @@ /* Memory-access and commands for remote VxWorks processes, for GDB. - Copyright (C) 1990-1991 Free Software Foundation, Inc. + Copyright 1990, 1991, 1992 Free Software Foundation, Inc. Contributed by Wind River Systems and Cygnus Support. This file is part of GDB. @@ -19,7 +19,6 @@ along with this program; if not, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ #include "defs.h" -#include "param.h" #include "frame.h" #include "inferior.h" #include "wait.h" @@ -27,32 +26,32 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ #include "gdbcore.h" #include "command.h" #include "symtab.h" -#include "symfile.h" /* for struct complaint */ +#include "complaints.h" +#include "gdbcmd.h" -#include #include #include #include #include #include -#include #include +#define malloc bogon_malloc /* Sun claims "char *malloc()" not void * */ #define free bogon_free /* Sun claims "int free()" not void */ +#define realloc bogon_realloc /* Sun claims "char *realloc()", not void * */ #include +#undef malloc #undef free +#undef realloc #include /* UTek's doesn't #incl this */ #include -#include -#include "xdr_ptrace.h" -#include "xdr_ld.h" -#include "xdr_rdb.h" -#include "dbgRpcLib.h" - -/* get rid of value.h if possible */ -#include +#include "vx-share/ptrace.h" +#include "vx-share/xdr_ptrace.h" +#include "vx-share/xdr_ld.h" +#include "vx-share/xdr_rdb.h" +#include "vx-share/dbgRpcLib.h" + #include - -extern value call_function_by_hand (); + extern void symbol_file_command (); extern int stop_soon_quietly; /* for wait_for_inferior */ @@ -88,7 +87,7 @@ static char *find_white_space (); /* Tell the VxWorks target system to download a file. The load addresses of the text, data, and bss segments are - stored in pTextAddr, pDataAddr, and *pBssAddr (respectively). + stored in *pTextAddr, *pDataAddr, and *pBssAddr (respectively). Returns 0 for success, -1 for failure. */ static int @@ -109,7 +108,7 @@ net_load (filename, pTextAddr, pDataAddr, pBssAddr) The load on the target side can take quite a while, easily more than 10 seconds. The user can kill this call by typing CTRL-C if there really is a problem with the load. - + Do not change the tv_sec value without checking -- select() imposes a limit of 10**8 on it for no good reason that I can see... */ @@ -121,7 +120,7 @@ net_load (filename, pTextAddr, pDataAddr, pBssAddr) if (status == RPC_SUCCESS) { - if (*ldstruct.name == NULL) /* load failed on VxWorks side */ + if (*ldstruct.name == 0) /* load failed on VxWorks side */ return -1; *pTextAddr = ldstruct.txt_addr; *pDataAddr = ldstruct.data_addr; @@ -163,7 +162,7 @@ net_break (addr, procnum) /* returns 0 if successful, errno otherwise */ -int +static int vx_insert_breakpoint (addr) int addr; { @@ -172,317 +171,13 @@ vx_insert_breakpoint (addr) /* returns 0 if successful, errno otherwise */ -int +static int vx_remove_breakpoint (addr) int addr; { return net_break (addr, VX_BREAK_DELETE); } -/* Call a function on the VxWorks target system. - ARGS is a vector of values of arguments (NARGS of them). - FUNCTION is a value, the function to be called. - Returns a struct value * representing what the function returned. - May fail to return, if a breakpoint or signal is hit - during the execution of the function. */ - -#ifdef FIXME -/* FIXME, function calls are really fried. GO back to manual method. */ -value -vx_call_function (function, nargs, args) - value function; - int nargs; - value *args; -{ - register CORE_ADDR sp; - register int i; - CORE_ADDR start_sp; - static REGISTER_TYPE dummy[] = CALL_DUMMY; - REGISTER_TYPE dummy1[sizeof dummy / sizeof (REGISTER_TYPE)]; - CORE_ADDR old_sp; - struct type *value_type; - unsigned char struct_return; - CORE_ADDR struct_addr; - struct inferior_status inf_status; - struct cleanup *old_chain; - CORE_ADDR funaddr; - int using_gcc; - - save_inferior_status (&inf_status, 1); - old_chain = make_cleanup (restore_inferior_status, &inf_status); - - /* PUSH_DUMMY_FRAME is responsible for saving the inferior registers - (and POP_FRAME for restoring them). (At least on most machines) - they are saved on the stack in the inferior. */ - PUSH_DUMMY_FRAME; - - old_sp = sp = read_register (SP_REGNUM); - -#if 1 INNER_THAN 2 /* Stack grows down */ - sp -= sizeof dummy; - start_sp = sp; -#else /* Stack grows up */ - start_sp = sp; - sp += sizeof dummy; -#endif - - funaddr = find_function_addr (function, &value_type); - - { - struct block *b = block_for_pc (funaddr); - /* If compiled without -g, assume GCC. */ - using_gcc = b == NULL || BLOCK_GCC_COMPILED (b); - } - - /* Are we returning a value using a structure return or a normal - value return? */ - - struct_return = using_struct_return (function, funaddr, value_type, - using_gcc); - - /* Create a call sequence customized for this function - and the number of arguments for it. */ - bcopy (dummy, dummy1, sizeof dummy); - FIX_CALL_DUMMY (dummy1, start_sp, funaddr, nargs, args, - value_type, using_gcc); - -#if CALL_DUMMY_LOCATION == ON_STACK - write_memory (start_sp, dummy1, sizeof dummy); - -#else /* Not on stack. */ -#if CALL_DUMMY_LOCATION == BEFORE_TEXT_END - /* Convex Unix prohibits executing in the stack segment. */ - /* Hope there is empty room at the top of the text segment. */ - { - static checked = 0; - if (!checked) - for (start_sp = text_end - sizeof dummy; start_sp < text_end; ++start_sp) - if (read_memory_integer (start_sp, 1) != 0) - error ("text segment full -- no place to put call"); - checked = 1; - sp = old_sp; - start_sp = text_end - sizeof dummy; - write_memory (start_sp, dummy1, sizeof dummy); - } -#else /* After text_end. */ - { - int errcode; - sp = old_sp; - start_sp = text_end; - errcode = target_write_memory (start_sp, dummy1, sizeof dummy); - if (errcode != 0) - error ("Cannot write text segment -- call_function failed"); - } -#endif /* After text_end. */ -#endif /* Not on stack. */ - -#ifdef STACK_ALIGN - /* If stack grows down, we must leave a hole at the top. */ - { - int len = 0; - - /* Reserve space for the return structure to be written on the - stack, if necessary */ - - if (struct_return) - len += TYPE_LENGTH (value_type); - - for (i = nargs - 1; i >= 0; i--) - len += TYPE_LENGTH (VALUE_TYPE (value_arg_coerce (args[i]))); -#ifdef CALL_DUMMY_STACK_ADJUST - len += CALL_DUMMY_STACK_ADJUST; -#endif -#if 1 INNER_THAN 2 - sp -= STACK_ALIGN (len) - len; -#else - sp += STACK_ALIGN (len) - len; -#endif - } -#endif /* STACK_ALIGN */ - - /* Reserve space for the return structure to be written on the - stack, if necessary */ - - if (struct_return) - { -#if 1 INNER_THAN 2 - sp -= TYPE_LENGTH (value_type); - struct_addr = sp; -#else - struct_addr = sp; - sp += TYPE_LENGTH (value_type); -#endif - } - -#if defined (REG_STRUCT_HAS_ADDR) - { - /* This is a machine like the sparc, where we need to pass a pointer - to the structure, not the structure itself. */ - if (REG_STRUCT_HAS_ADDR (using_gcc)) - for (i = nargs - 1; i >= 0; i--) - if (TYPE_CODE (VALUE_TYPE (args[i])) == TYPE_CODE_STRUCT) - { - CORE_ADDR addr; -#if !(1 INNER_THAN 2) - /* The stack grows up, so the address of the thing we push - is the stack pointer before we push it. */ - addr = sp; -#endif - /* Push the structure. */ - sp = value_push (sp, args[i]); -#if 1 INNER_THAN 2 - /* The stack grows down, so the address of the thing we push - is the stack pointer after we push it. */ - addr = sp; -#endif - /* The value we're going to pass is the address of the thing - we just pushed. */ - args[i] = value_from_long (builtin_type_long, (LONGEST) addr); - } - } -#endif /* REG_STRUCT_HAS_ADDR. */ - -#ifdef PUSH_ARGUMENTS - PUSH_ARGUMENTS(nargs, args, sp, struct_return, struct_addr); -#else /* !PUSH_ARGUMENTS */ - for (i = nargs - 1; i >= 0; i--) - sp = value_arg_push (sp, args[i]); -#endif /* !PUSH_ARGUMENTS */ - -#ifdef CALL_DUMMY_STACK_ADJUST -#if 1 INNER_THAN 2 - sp -= CALL_DUMMY_STACK_ADJUST; -#else - sp += CALL_DUMMY_STACK_ADJUST; -#endif -#endif /* CALL_DUMMY_STACK_ADJUST */ - - /* Store the address at which the structure is supposed to be - written. Note that this (and the code which reserved the space - above) assumes that gcc was used to compile this function. Since - it doesn't cost us anything but space and if the function is pcc - it will ignore this value, we will make that assumption. - - Also note that on some machines (like the sparc) pcc uses a - convention like gcc's. */ - - if (struct_return) - STORE_STRUCT_RETURN (struct_addr, sp); - - /* Write the stack pointer. This is here because the statements above - might fool with it. On SPARC, this write also stores the register - window into the right place in the new stack frame, which otherwise - wouldn't happen. (See write_inferior_registers in sparc-xdep.c.) */ - write_register (SP_REGNUM, sp); - - /* Figure out the value returned by the function. */ - { - char retbuf[REGISTER_BYTES]; - - /* Execute the stack dummy routine, calling FUNCTION. - When it is done, discard the empty frame - after storing the contents of all regs into retbuf. */ - run_stack_dummy (start_sp + CALL_DUMMY_START_OFFSET, retbuf); - - do_cleanups (old_chain); - - return value_being_returned (value_type, retbuf, struct_return); - } -} -/* should return a value of some sort */ - -value -vx_call_function (funcAddr, nargs, args, valueType) - char *funcAddr; - int nargs; - value *args; - struct type * valueType; -{ - int i; - func_call funcInfo; - arg_value *argValue; - enum clnt_stat status; - register int len; - arg_value funcReturn; - value gdbValue; - - argValue = (arg_value *) xmalloc (nargs * sizeof (arg_value)); - - bzero (argValue, nargs * sizeof (arg_value)); - bzero (&funcReturn, sizeof (funcReturn)); - - for (i = nargs - 1; i >= 0; i--) - { - len = TYPE_LENGTH (VALUE_TYPE (args [i])); - - switch (TYPE_CODE (VALUE_TYPE (args[i]))) - { - /* XXX put other types here. Where's CHAR, etc??? */ - - case TYPE_CODE_FLT: - argValue[i].type = T_FLOAT; - break; - case TYPE_CODE_INT: - case TYPE_CODE_PTR: - case TYPE_CODE_ENUM: - case TYPE_CODE_FUNC: - argValue[i].type = T_INT; - break; - - case TYPE_CODE_UNDEF: - case TYPE_CODE_ARRAY: - case TYPE_CODE_STRUCT: - case TYPE_CODE_UNION: - case TYPE_CODE_VOID: - case TYPE_CODE_SET: - case TYPE_CODE_RANGE: - case TYPE_CODE_PASCAL_ARRAY: - case TYPE_CODE_MEMBER: /* C++ */ - case TYPE_CODE_METHOD: /* C++ */ - case TYPE_CODE_REF: /* C++ */ - default: - error ("No corresponding VxWorks type for %d. CHECK IT OUT!!!\n", - TYPE_CODE(VALUE_TYPE(args[i]))); - } /* switch */ - if (TYPE_CODE(VALUE_TYPE(args[i])) == TYPE_CODE_FUNC) - argValue[i].arg_value_u.v_int = VALUE_ADDRESS(args[i]); - else - bcopy (VALUE_CONTENTS (args[i]), (char *) &argValue[i].arg_value_u, - len); - } - - /* XXX what should the type of this function addr be? - * XXX Both in gdb and vxWorks - */ - funcInfo.func_addr = (int) funcAddr; - funcInfo.args.args_len = nargs; - funcInfo.args.args_val = argValue; - - status = net_clnt_call (VX_CALL_FUNC, xdr_func_call, (char *) &funcInfo, - xdr_arg_value, &funcReturn); - - free ((char *) argValue); - - if (status == RPC_SUCCESS) - { - /* XXX this assumes that vxWorks ALWAYS returns an int, and that - * XXX gdb isn't expecting anything more - */ - - /******************* - if (funcReturn.type == T_UNKNOWN) - return YYYXXX...; - *******************/ - gdbValue = allocate_value (valueType); - bcopy (&funcReturn.arg_value_u.v_int, VALUE_CONTENTS (gdbValue), - sizeof (int)); - return gdbValue; - } - else - error (rpcerr); - } -#endif /* FIXME */ - /* Start an inferior process and sets inferior_pid to its pid. EXEC_FILE is the file to run. ALLARGS is a string containing the arguments to the program. @@ -490,7 +185,7 @@ vx_call_function (funcAddr, nargs, args, valueType) Returns process id. Errors reported with error(). On VxWorks, we ignore exec_file. */ -void +static void vx_create_inferior (exec_file, args, env) char *exec_file; char *args; @@ -527,10 +222,6 @@ vx_create_inferior (exec_file, args, env) push_target (&vx_run_ops); inferior_pid = taskStart.pid; -#if defined (START_INFERIOR_HOOK) - START_INFERIOR_HOOK (); -#endif - /* We will get a trace trap after one instruction. Insert breakpoints and continue. */ @@ -543,8 +234,6 @@ vx_create_inferior (exec_file, args, env) /* Install inferior's terminal modes. */ target_terminal_inferior (); - /* remote_start(args); */ - /* trap_expected = 0; */ stop_soon_quietly = 1; wait_for_inferior (); /* Get the task spawn event */ stop_soon_quietly = 0; @@ -638,7 +327,7 @@ find_white_space (p) to the debugged task. Returns -1 if remote wait failed, task status otherwise. */ -int +static int net_wait (pEvent) RDB_EVENT *pEvent; { @@ -656,7 +345,7 @@ net_wait (pEvent) /* Suspend the remote task. Returns -1 if suspend fails on target system, 0 otherwise. */ -int +static int net_quit () { int pid; @@ -678,15 +367,15 @@ net_quit () /* Read a register or registers from the remote system. */ -int +static void vx_read_register (regno) int regno; { int status; Rptrace ptrace_in; Ptrace_return ptrace_out; - struct regs inferior_registers; - struct fp_status inferior_fp_registers; + C_bytes in_data; + C_bytes out_data; extern char registers[]; bzero ((char *) &ptrace_in, sizeof (ptrace_in)); @@ -696,105 +385,56 @@ vx_read_register (regno) registers_fetched (); ptrace_in.pid = inferior_pid; - ptrace_out.info.more_data = (caddr_t) &inferior_registers; + ptrace_out.info.more_data = (caddr_t) &out_data; + out_data.len = VX_NUM_REGS * REGISTER_RAW_SIZE (0); + out_data.bytes = (caddr_t) registers; + status = net_ptrace_clnt_call (PTRACE_GETREGS, &ptrace_in, &ptrace_out); if (status) error (rpcerr); if (ptrace_out.status == -1) { errno = ptrace_out.errno; - return -1; + perror_with_name ("net_ptrace_clnt_call(PTRACE_GETREGS)"); } -#ifdef I80960 - - bcopy ((char *) inferior_registers.r_lreg, - ®isters[REGISTER_BYTE (R0_REGNUM)], 16 * sizeof (int)); - bcopy ((char *) inferior_registers.r_greg, - ®isters[REGISTER_BYTE (G0_REGNUM)], 16 * sizeof (int)); - - /* Don't assume that a location in registers[] is properly aligned. */ - - bcopy ((char *) &inferior_registers.r_pcw, - ®isters[REGISTER_BYTE (PCW_REGNUM)], sizeof (int)); - bcopy ((char *) &inferior_registers.r_acw, - ®isters[REGISTER_BYTE (ACW_REGNUM)], sizeof (int)); - bcopy ((char *) &inferior_registers.r_lreg[2], /* r2 (RIP) -> IP */ - ®isters[REGISTER_BYTE (IP_REGNUM)], sizeof (int)); - bcopy ((char *) &inferior_registers.r_tcw, - ®isters[REGISTER_BYTE (TCW_REGNUM)], sizeof (int)); - - /* If the target has floating point registers, fetch them. - Otherwise, zero the floating point register values in - registers[] for good measure, even though we might not - need to. */ - - if (target_has_fp) - { - ptrace_in.pid = inferior_pid; - ptrace_out.info.more_data = (caddr_t) &inferior_fp_registers; - status = net_ptrace_clnt_call (PTRACE_GETFPREGS, &ptrace_in, &ptrace_out); - if (status) - error (rpcerr); - if (ptrace_out.status == -1) - { - errno = ptrace_out.errno; - return -1; - } - - bcopy (&inferior_fp_registers, ®isters[REGISTER_BYTE (FP0_REGNUM)], - REGISTER_RAW_SIZE (FP0_REGNUM) * 4); - } - else - { - bzero ((char *) ®isters[REGISTER_BYTE (FP0_REGNUM)], - REGISTER_RAW_SIZE (FP0_REGNUM) * 4); - } - -#else /* not 960, thus must be 68000: FIXME! */ - - bcopy (&inferior_registers, registers, 16 * 4); - *(int *)®isters[REGISTER_BYTE (PS_REGNUM)] = inferior_registers.r_ps; - *(int *)®isters[REGISTER_BYTE (PC_REGNUM)] = inferior_registers.r_pc; +#ifdef VX_SIZE_FPREGS + /* If the target has floating point registers, fetch them. + Otherwise, zero the floating point register values in + registers[] for good measure, even though we might not + need to. */ if (target_has_fp) { ptrace_in.pid = inferior_pid; - ptrace_out.info.more_data = (caddr_t) &inferior_fp_registers; + ptrace_out.info.more_data = (caddr_t) &out_data; + out_data.len = VX_SIZE_FPREGS; + out_data.bytes = (caddr_t) ®isters[REGISTER_BYTE (FP0_REGNUM)]; + status = net_ptrace_clnt_call (PTRACE_GETFPREGS, &ptrace_in, &ptrace_out); if (status) error (rpcerr); if (ptrace_out.status == -1) { errno = ptrace_out.errno; - return -1; + perror_with_name ("net_ptrace_clnt_call(PTRACE_GETFPREGS)"); } - - bcopy (&inferior_fp_registers, ®isters[REGISTER_BYTE (FP0_REGNUM)], - sizeof inferior_fp_registers.fps_regs); - bcopy (&inferior_fp_registers.fps_control, - ®isters[REGISTER_BYTE (FPC_REGNUM)], - sizeof inferior_fp_registers - sizeof inferior_fp_registers.fps_regs); } else { - bzero (®isters[REGISTER_BYTE (FP0_REGNUM)], - sizeof inferior_fp_registers.fps_regs); - bzero (®isters[REGISTER_BYTE (FPC_REGNUM)], - sizeof inferior_fp_registers - sizeof inferior_fp_registers.fps_regs); + bzero (®isters[REGISTER_BYTE (FP0_REGNUM)], VX_SIZE_FPREGS); } -#endif /* various architectures */ - - return 0; +#endif /* VX_SIZE_FPREGS */ } /* Prepare to store registers. Since we will store all of them, read out their current values now. */ -void +static void vx_prepare_to_store () { - vx_read_register (-1); + /* Fetch all registers, if any of them are not yet fetched. */ + read_register_bytes (0, NULL, REGISTER_BYTES); } @@ -803,11 +443,12 @@ vx_prepare_to_store () Otherwise, REGNO specifies which register (so we can save time). */ /* FIXME, look at REGNO to save time here */ +static void vx_write_register (regno) int regno; { - struct regs inferior_registers; - struct fp_status inferior_fp_registers; + C_bytes in_data; + C_bytes out_data; extern char registers[]; int status; Rptrace ptrace_in; @@ -816,33 +457,13 @@ vx_write_register (regno) bzero ((char *) &ptrace_in, sizeof (ptrace_in)); bzero ((char *) &ptrace_out, sizeof (ptrace_out)); -#ifdef I80960 - - bcopy (®isters[REGISTER_BYTE (R0_REGNUM)], - (char *) inferior_registers.r_lreg, 16 * sizeof (int)); - bcopy (®isters[REGISTER_BYTE (G0_REGNUM)], - (char *) inferior_registers.r_greg, 16 * sizeof (int)); - - /* Don't assume that a location in registers[] is properly aligned. */ - - bcopy (®isters[REGISTER_BYTE (PCW_REGNUM)], - (char *) &inferior_registers.r_pcw, sizeof (int)); - bcopy (®isters[REGISTER_BYTE (ACW_REGNUM)], - (char *) &inferior_registers.r_acw, sizeof (int)); - bcopy (®isters[REGISTER_BYTE (TCW_REGNUM)], - (char *) &inferior_registers.r_tcw, sizeof (int)); - -#else /* not 960 -- assume 68k -- FIXME */ + ptrace_in.pid = inferior_pid; + ptrace_in.info.ttype = DATA; + ptrace_in.info.more_data = (caddr_t) &in_data; - bcopy (registers, &inferior_registers, 16 * 4); - inferior_registers.r_ps = *(int *)®isters[REGISTER_BYTE (PS_REGNUM)]; - inferior_registers.r_pc = *(int *)®isters[REGISTER_BYTE (PC_REGNUM)]; + in_data.bytes = registers; -#endif /* Different register sets */ - - ptrace_in.pid = inferior_pid; - ptrace_in.info.ttype = REGS; - ptrace_in.info.more_data = (caddr_t) &inferior_registers; + in_data.len = VX_NUM_REGS * sizeof (REGISTER_TYPE); /* XXX change second param to be a proc number */ status = net_ptrace_clnt_call (PTRACE_SETREGS, &ptrace_in, &ptrace_out); @@ -851,31 +472,21 @@ vx_write_register (regno) if (ptrace_out.status == -1) { errno = ptrace_out.errno; - return -1; + perror_with_name ("net_ptrace_clnt_call(PTRACE_SETREGS)"); } +#ifdef VX_SIZE_FPREGS /* Store floating point registers if the target has them. */ if (target_has_fp) { -#ifdef I80960 - - bcopy (®isters[REGISTER_BYTE (FP0_REGNUM)], &inferior_fp_registers, - sizeof inferior_fp_registers.fps_regs); - -#else /* not 960 -- assume 68k -- FIXME */ - - bcopy (®isters[REGISTER_BYTE (FP0_REGNUM)], &inferior_fp_registers, - sizeof inferior_fp_registers.fps_regs); - bcopy (®isters[REGISTER_BYTE (FPC_REGNUM)], - &inferior_fp_registers.fps_control, - sizeof inferior_fp_registers - sizeof inferior_fp_registers.fps_regs); + ptrace_in.pid = inferior_pid; + ptrace_in.info.ttype = DATA; + ptrace_in.info.more_data = (caddr_t) &in_data; -#endif /* Different register sets */ - ptrace_in.pid = inferior_pid; - ptrace_in.info.ttype = FPREGS; - ptrace_in.info.more_data = (caddr_t) &inferior_fp_registers; + in_data.bytes = ®isters[REGISTER_BYTE (FP0_REGNUM)]; + in_data.len = VX_SIZE_FPREGS; status = net_ptrace_clnt_call (PTRACE_SETFPREGS, &ptrace_in, &ptrace_out); if (status) @@ -883,10 +494,10 @@ vx_write_register (regno) if (ptrace_out.status == -1) { errno = ptrace_out.errno; - return -1; + perror_with_name ("net_ptrace_clnt_call(PTRACE_SETFPREGS)"); } } - return 0; +#endif /* VX_SIZE_FPREGS */ } /* Copy LEN bytes to or from remote inferior's memory starting at MEMADDR @@ -897,7 +508,7 @@ vx_write_register (regno) handle the current address but can handle one N bytes further, but vxworks doesn't give us that information. */ -int +static int vx_xfer_memory (memaddr, myaddr, len, write, target) CORE_ADDR memaddr; char *myaddr; @@ -947,7 +558,7 @@ vx_xfer_memory (memaddr, myaddr, len, write, target) return len; /* Moved *all* the bytes */ } -void +static void vx_files_info () { printf ("\tAttached to host `%s'", vx_host); @@ -955,19 +566,20 @@ vx_files_info () printf (".\n"); } -void +static void vx_run_files_info () { - printf ("\tRunning %s VxWorks process 0x%x", + printf ("\tRunning %s VxWorks process %s", vx_running? "child": "attached", - inferior_pid); + local_hex_string(inferior_pid)); if (vx_running) printf (", function `%s'", vx_running); printf(".\n"); } -void -vx_resume (step, siggnal) +static void +vx_resume (pid, step, siggnal) + int pid; int step; int siggnal; { @@ -981,7 +593,7 @@ vx_resume (step, siggnal) bzero ((char *) &ptrace_in, sizeof (ptrace_in)); bzero ((char *) &ptrace_out, sizeof (ptrace_out)); - ptrace_in.pid = inferior_pid; + ptrace_in.pid = pid; ptrace_in.addr = 1; /* Target side insists on this, or it panics. */ /* XXX change second param to be a proc number */ @@ -996,7 +608,7 @@ vx_resume (step, siggnal) } } -void +static void vx_mourn_inferior () { pop_target (); /* Pop back to no-child state */ @@ -1006,7 +618,7 @@ vx_mourn_inferior () /* This function allows the addition of incrementally linked object files. */ -void +static void vx_load_command (arg_string, from_tty) char* arg_string; int from_tty; @@ -1030,7 +642,7 @@ vx_load_command (arg_string, from_tty) immediate_quit--; /* FIXME, for now we ignore data_addr and bss_addr. */ - symbol_file_add (arg_string, from_tty, text_addr, 0); + symbol_file_add (arg_string, from_tty, text_addr, 0, 0, 0); } #ifdef FIXME /* Not ready for prime time */ @@ -1094,7 +706,7 @@ net_ptrace_clnt_call (request, pPtraceIn, pPtraceOut) NULL, memory for the buffer will be allocated by XDR. Returns -1 if rpc failed, 0 otherwise. */ -int +static int net_get_boot_file (pBootFile) char **pBootFile; { @@ -1110,7 +722,7 @@ net_get_boot_file (pBootFile) There's no way to check if the returned loadTable is correct. VxWorks doesn't check it. */ -int +static int net_get_symbols (pLoadTable) ldtabl *pLoadTable; /* return pointer to ldtabl here */ { @@ -1129,7 +741,7 @@ net_get_symbols (pLoadTable) struct complaint cant_contact_target = {"Lost contact with VxWorks target", 0, 0}; -int +static int vx_lookup_symbol (name, pAddr) char *name; /* symbol name */ CORE_ADDR *pAddr; @@ -1143,7 +755,7 @@ vx_lookup_symbol (name, pAddr) status = net_clnt_call (VX_SYMBOL_INQ, xdr_wrapstring, &name, xdr_SYMBOL_ADDR, &symbolAddr); if (status != RPC_SUCCESS) { - complain (&cant_contact_target, 0); + complain (&cant_contact_target); return -1; } @@ -1155,7 +767,7 @@ vx_lookup_symbol (name, pAddr) Returns 1 if target has floating point processor, 0 otherwise. Calls error() if rpc fails. */ -int +static int net_check_for_fp () { enum clnt_stat status; @@ -1171,21 +783,29 @@ net_check_for_fp () /* Establish an RPC connection with the VxWorks target system. Calls error () if unable to establish connection. */ -void +static void net_connect (host) char *host; { struct sockaddr_in destAddr; struct hostent *destHost; + unsigned long addr; + + /* Get the internet address for the given host. Allow a numeric + IP address or a hostname. */ - /* get the internet address for the given host */ - - if ((destHost = (struct hostent *) gethostbyname (host)) == NULL) - error ("Invalid hostname. Couldn't find remote host address."); + addr = inet_addr (host); + if (addr == -1) + { + destHost = (struct hostent *) gethostbyname (host); + if (destHost == NULL) + error ("Invalid hostname. Couldn't find remote host address."); + addr = * (unsigned long *) destHost->h_addr; + } bzero (&destAddr, sizeof (destAddr)); - destAddr.sin_addr.s_addr = * (u_long *) destHost->h_addr; + destAddr.sin_addr.s_addr = addr; destAddr.sin_family = AF_INET; destAddr.sin_port = 0; /* set to actual port that remote ptrace is listening on. */ @@ -1288,7 +908,7 @@ vx_wait (status) sleep_ms (200); /* FIXME Don't kill the network too badly */ } else if (pid != inferior_pid) - fatal ("Bad pid for debugged task: 0x%x\n", pid); + fatal ("Bad pid for debugged task: %s\n", local_hex_string(pid)); } while (pid == 0); /* FIXME, eventually do more then SIGTRAP on everything... */ @@ -1323,6 +943,7 @@ vx_wait (status) case EVENT_ZERO_DIV: /* Division by zero */ WSETSTOP (w, SIGFPE); /* Like Unix, call it a float exception. */ + break; case EVENT_SIGNAL: /* The target is not running Unix, and its @@ -1340,21 +961,20 @@ vx_wait (status) static int symbol_stub (arg) - int arg; + char *arg; { - char *bootFile = (char *)arg; - symbol_file_command (bootFile, 0); + symbol_file_command (arg, 0); return 1; } static int add_symbol_stub (arg) - int arg; + char *arg; { struct ldfile *pLoadFile = (struct ldfile *)arg; printf("\t%s: ", pLoadFile->name); - symbol_file_add (pLoadFile->name, 0, pLoadFile->txt_addr, 0); + symbol_file_add (pLoadFile->name, 0, pLoadFile->txt_addr, 0, 0, 0); printf ("ok\n"); return 1; } @@ -1413,8 +1033,9 @@ vx_open (args, from_tty) { if (*bootFile) { printf_filtered ("\t%s: ", bootFile); - if (catch_errors (symbol_stub, (int)bootFile, - "Error reading symbols from boot file")) + if (catch_errors + (symbol_stub, bootFile, + "Error while reading symbols from boot file:\n", RETURN_MASK_ALL)) puts_filtered ("ok\n"); } else if (from_tty) printf ("VxWorks kernel symbols not loaded.\n"); @@ -1450,7 +1071,8 @@ vx_open (args, from_tty) /* Botches, FIXME: (1) Searches the PATH, not the source path. (2) data and bss are assumed to be at the usual offsets from text. */ - catch_errors (add_symbol_stub, (int)pLoadFile, (char *)0); + catch_errors (add_symbol_stub, (char *)pLoadFile, (char *)0, + RETURN_MASK_ALL); #endif } printf_filtered ("Done.\n"); @@ -1458,8 +1080,7 @@ vx_open (args, from_tty) clnt_freeres (pClient, xdr_ldtabl, &loadTable); } -/* attach_command -- - takes a task started up outside of gdb and ``attaches'' to it. +/* Takes a task started up outside of gdb and ``attaches'' to it. This stops it cold in its tracks and allows us to start tracing it. */ static void @@ -1473,8 +1094,6 @@ vx_attach (args, from_tty) Ptrace_return ptrace_out; int status; - dont_repeat(); - if (!args) error_no_arg ("process-id to attach"); @@ -1483,7 +1102,7 @@ vx_attach (args, from_tty) error ("Invalid process-id -- give a single number in decimal or 0xhex"); if (from_tty) - printf ("Attaching pid 0x%x.\n", pid); + printf ("Attaching pid %s.\n", local_hex_string(pid)); bzero ((char *)&ptrace_in, sizeof (ptrace_in)); bzero ((char *)&ptrace_out, sizeof (ptrace_out)); @@ -1502,27 +1121,6 @@ vx_attach (args, from_tty) push_target (&vx_run_ops); inferior_pid = pid; vx_running = 0; - -#if defined (START_INFERIOR_HOOK) - START_INFERIOR_HOOK (); -#endif - - mark_breakpoints_out (); - - /* Set up the "saved terminal modes" of the inferior - based on what modes we are starting it with. */ - target_terminal_init (); - - /* Install inferior's terminal modes. */ - target_terminal_inferior (); - - /* We will get a task spawn event immediately. */ - init_wait_for_inferior (); - clear_proceed_status (); - stop_soon_quietly = 1; - wait_for_inferior (); - stop_soon_quietly = 0; - normal_stop (); } @@ -1549,7 +1147,7 @@ vx_detach (args, from_tty) error ("Argument given to VxWorks \"detach\"."); if (from_tty) - printf ("Detaching pid 0x%x.\n", inferior_pid); + printf ("Detaching pid %s.\n", local_hex_string(inferior_pid)); if (args) /* FIXME, should be possible to leave suspended */ signal = atoi (args); @@ -1574,19 +1172,13 @@ vx_detach (args, from_tty) /* vx_kill -- takes a running task and wipes it out. */ static void -vx_kill (args, from_tty) - char *args; - int from_tty; +vx_kill () { Rptrace ptrace_in; Ptrace_return ptrace_out; int status; - if (args) - error ("Argument given to VxWorks \"kill\"."); - - if (from_tty) - printf ("Killing pid 0x%x.\n", inferior_pid); + printf ("Killing pid %s.\n", local_hex_string(inferior_pid)); bzero ((char *)&ptrace_in, sizeof (ptrace_in)); bzero ((char *)&ptrace_out, sizeof (ptrace_out)); @@ -1594,21 +1186,22 @@ vx_kill (args, from_tty) status = net_ptrace_clnt_call (PTRACE_KILL, &ptrace_in, &ptrace_out); if (status == -1) - error (rpcerr); - if (ptrace_out.status == -1) + warning (rpcerr); + else if (ptrace_out.status == -1) { errno = ptrace_out.errno; perror_with_name ("Killing VxWorks process"); } - /* If it gives good status, the process is *gone*, no events remain. */ + /* If it gives good status, the process is *gone*, no events remain. + If the kill failed, assume the process is gone anyhow. */ inferior_pid = 0; pop_target (); /* go back to non-executing VxWorks connection */ } /* Clean up from the VxWorks process target as it goes away. */ -void +static void vx_proc_close (quitting) int quitting; { @@ -1618,77 +1211,6 @@ vx_proc_close (quitting) vx_running = 0; } -/* Cross-net conversion of floats to and from extended form. - (This is needed because different target machines have different - extended floating point formats.) */ - -/* Convert from an extended float to a double. - - The extended float is stored as raw data pointed to by FROM. - Return the converted value as raw data in the double pointed to by TO. -*/ - -static void -vx_convert_to_virtual (regno, from, to) - int regno; - char *from; - char *to; -{ - enum clnt_stat status; - - if (REGISTER_CONVERTIBLE (regno)) - { - if (!target_has_fp) { - *(double *)to = 0.0; /* Skip the trouble if no float anyway */ - return; - } - - status = net_clnt_call (VX_CONV_FROM_68881, xdr_ext_fp, from, - xdr_double, to); - - if (status == RPC_SUCCESS) - return; - else - error (rpcerr); - } - else - bcopy (from, to, REGISTER_VIRTUAL_SIZE (regno)); -} - - -/* The converse: convert from a double to an extended float. - - The double is stored as raw data pointed to by FROM. - Return the converted value as raw data in the extended - float pointed to by TO. -*/ - -static void -vx_convert_from_virtual (regno, from, to) - int regno; - char *from; - char *to; -{ - enum clnt_stat status; - - if (REGISTER_CONVERTIBLE (regno)) - { - if (!target_has_fp) { - bzero (to, REGISTER_RAW_SIZE (FP0_REGNUM)); /* Shrug */ - return; - } - - status = net_clnt_call (VX_CONV_TO_68881, xdr_double, from, - xdr_ext_fp, to); - if (status == RPC_SUCCESS) - return; - else - error (rpcerr); - } - else - bcopy (from, to, REGISTER_VIRTUAL_SIZE (regno)); -} - /* Make an RPC call to the VxWorks target. Returns RPC status. */ @@ -1712,7 +1234,7 @@ net_clnt_call (procNum, inProc, in, outProc, out) /* Clean up before losing control. */ -void +static void vx_close (quitting) int quitting; { @@ -1744,15 +1266,16 @@ Specify the name of the machine to connect to.", vx_open, vx_close, vx_attach, 0, /* vx_detach, */ 0, 0, /* resume, wait */ 0, 0, /* read_reg, write_reg */ - 0, vx_convert_to_virtual, vx_convert_from_virtual, /* prep_to_store, */ + 0, /* prep_to_store, */ vx_xfer_memory, vx_files_info, 0, 0, /* insert_breakpoint, remove_breakpoint */ 0, 0, 0, 0, 0, /* terminal stuff */ 0, /* vx_kill, */ vx_load_command, - 0, /* call_function */ vx_lookup_symbol, vx_create_inferior, 0, /* mourn_inferior */ + 0, /* can_run */ + 0, /* notice_signals */ core_stratum, 0, /* next */ 1, 1, 0, 0, 0, /* all mem, mem, stack, regs, exec */ 0, 0, /* Section pointers */ @@ -1767,15 +1290,16 @@ struct target_ops vx_run_ops = { vx_proc_open, vx_proc_close, 0, vx_detach, /* vx_attach */ vx_resume, vx_wait, vx_read_register, vx_write_register, - vx_prepare_to_store, vx_convert_to_virtual, vx_convert_from_virtual, + vx_prepare_to_store, vx_xfer_memory, vx_run_files_info, vx_insert_breakpoint, vx_remove_breakpoint, 0, 0, 0, 0, 0, /* terminal stuff */ vx_kill, vx_load_command, - call_function_by_hand, /* FIXME, calling fns is maybe botched? */ vx_lookup_symbol, 0, vx_mourn_inferior, + 0, /* can_run */ + 0, /* notice_signals */ process_stratum, 0, /* next */ 0, 1, 1, 1, 1, /* all mem, mem, stack, regs, exec */ /* all_mem is off to avoid spurious msg in "i files" */ @@ -1787,6 +1311,14 @@ struct target_ops vx_run_ops = { void _initialize_vx () { - add_target (&vx_ops); + + add_show_from_set + (add_set_cmd ("vxworks-timeout", class_support, var_uinteger, + (char *) &rpcTimeout.tv_sec, + "Set seconds to wait for rpc calls to return.\n\ +Set the number of seconds to wait for rpc calls to return.", &setlist), + &showlist); + + add_target (&vx_ops); add_target (&vx_run_ops); }