/* Native debugging support for Intel x86 running DJGPP. Copyright 1997, 1999 Free Software Foundation, Inc. Written by Robert Hoehne. 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ #include #include "defs.h" #include "frame.h" /* required by inferior.h */ #include "inferior.h" #include "target.h" #include "wait.h" #include "gdbcore.h" #include "command.h" #include "floatformat.h" #include /* required for __DJGPP_MINOR__ */ #include #include #include #include #include #include #include #include #if __DJGPP_MINOR__ > 2 #include #endif #if __DJGPP_MINOR__ < 3 /* This code will be provided from DJGPP 2.03 on. Until then I code it here */ typedef struct { unsigned short sig0; unsigned short sig1; unsigned short sig2; unsigned short sig3; unsigned short exponent:15; unsigned short sign:1; } NPXREG; typedef struct { unsigned int control; unsigned int status; unsigned int tag; unsigned int eip; unsigned int cs; unsigned int dataptr; unsigned int datasel; NPXREG reg[8]; } NPX; static NPX npx; static void save_npx (void); /* Save the FPU of the debugged program */ static void load_npx (void); /* Restore the FPU of the debugged program */ /* ------------------------------------------------------------------------- */ /* Store the contents of the NPX in the global variable `npx'. */ /* *INDENT-OFF* */ static void save_npx (void) { asm ("inb $0xa0, %%al testb $0x20, %%al jz 1f xorb %% al, %%al outb %% al, $0xf0 movb $0x20, %%al outb %% al, $0xa0 outb %% al, $0x20 1: fnsave % 0 fwait " : "=m" (npx) : /* No input */ : "%eax"); } /* *INDENT-ON* */ /* ------------------------------------------------------------------------- */ /* Reload the contents of the NPX from the global variable `npx'. */ static void load_npx (void) { asm ("frstor %0":"=m" (npx)); } /* ------------------------------------------------------------------------- */ /* Stubs for the missing redirection functions. */ typedef struct { char *command; int redirected; } cmdline_t; void redir_cmdline_delete (cmdline_t *ptr) {ptr->redirected = 0;} int redir_cmdline_parse (const char *args, cmdline_t *ptr) { return -1; } int redir_to_child (cmdline_t *ptr) { return 1; } int redir_to_debugger (cmdline_t *ptr) { return 1; } int redir_debug_init (cmdline_t *ptr) { return 0; } #endif /* __DJGPP_MINOR < 3 */ extern void _initialize_go32_nat (void); struct env387 { unsigned short control; unsigned short r0; unsigned short status; unsigned short r1; unsigned short tag; unsigned short r2; unsigned long eip; unsigned short code_seg; unsigned short opcode; unsigned long operand; unsigned short operand_seg; unsigned short r3; unsigned char regs[8][10]; }; typedef enum { wp_insert, wp_remove, wp_count } wp_op; /* This holds the current reference counts for each debug register. */ static int dr_ref_count[4]; extern char **environ; #define SOME_PID 42 static int prog_has_started = 0; static void print_387_status (unsigned short status, struct env387 *ep); static void go32_open (char *name, int from_tty); static void go32_close (int quitting); static void go32_attach (char *args, int from_tty); static void go32_detach (char *args, int from_tty); static void go32_resume (int pid, int step, enum target_signal siggnal); static int go32_wait (int pid, struct target_waitstatus *status); static void go32_fetch_registers (int regno); static void store_register (int regno); static void go32_store_registers (int regno); static void go32_prepare_to_store (void); static int go32_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int write, struct target_ops *target); static void go32_files_info (struct target_ops *target); static void go32_stop (void); static void go32_kill_inferior (void); static void go32_create_inferior (char *exec_file, char *args, char **env); static void cleanup_dregs (void); static void go32_mourn_inferior (void); static int go32_can_run (void); static void ignore (void); static void ignore2 (char *a, int b); static int go32_insert_aligned_watchpoint (CORE_ADDR waddr, CORE_ADDR addr, int len, int rw); static int go32_remove_aligned_watchpoint (CORE_ADDR waddr, CORE_ADDR addr, int len, int rw); static int go32_handle_nonaligned_watchpoint (wp_op what, CORE_ADDR waddr, CORE_ADDR addr, int len, int rw); static struct target_ops go32_ops; static void go32_terminal_init (void); static void go32_terminal_inferior (void); static void go32_terminal_ours (void); static void print_387_status (unsigned short status, struct env387 *ep) { int i; int bothstatus; int top; int fpreg; bothstatus = ((status != 0) && (ep->status != 0)); if (status != 0) { if (bothstatus) printf_unfiltered ("u: "); print_387_status_word (status); } if (ep->status != 0) { if (bothstatus) printf_unfiltered ("e: "); print_387_status_word (ep->status); } print_387_control_word (ep->control & 0xffff); /* Other platforms say "last exception", but that's not true: the FPU stores the last non-control instruction there. */ printf_unfiltered ("last FP instruction: "); /* The ORing with D800h restores the upper 5 bits of the opcode that are not stored by the FPU (since these bits are the same for all floating-point instructions). */ printf_unfiltered ("opcode %s; ", local_hex_string (ep->opcode ? (ep->opcode|0xd800) : 0)); printf_unfiltered ("pc %s:", local_hex_string (ep->code_seg)); printf_unfiltered ("%s; ", local_hex_string (ep->eip)); printf_unfiltered ("operand %s", local_hex_string (ep->operand_seg)); printf_unfiltered (":%s\n", local_hex_string (ep->operand)); top = (ep->status >> 11) & 7; printf_unfiltered ("regno tag msb lsb value\n"); for (fpreg = 7; fpreg >= 0; fpreg--) { /* FNSAVE saves the FP registers in their logical TOP-relative order, beginning with ST(0). Since we need to print them in their physical order, we have to remap them. */ int regno = fpreg - top; long double val; if (regno < 0) regno += 8; printf_unfiltered ("%s %d: ", fpreg == top ? "=>" : " ", fpreg); switch ((ep->tag >> (fpreg * 2)) & 3) { case 0: printf_unfiltered ("valid "); break; case 1: printf_unfiltered ("zero "); break; case 2: /* All other versions of print_387_status use TRAP here, but I think this is misleading, since Intel manuals say SPECIAL. */ printf_unfiltered ("special "); break; case 3: printf_unfiltered ("empty "); break; } for (i = 9; i >= 0; i--) printf_unfiltered ("%02x", ep->regs[regno][i]); REGISTER_CONVERT_TO_VIRTUAL (FP0_REGNUM+regno, builtin_type_long_double, &ep->regs[regno], &val); printf_unfiltered (" %.19LG\n", val); } } void i386_go32_float_info (void) { print_387_status (0, (struct env387 *) &npx); } #define r_ofs(x) (offsetof(TSS,x)) static struct { size_t tss_ofs; size_t size; } regno_mapping[] = { r_ofs (tss_eax), 4, /* normal registers, from a_tss */ r_ofs (tss_ecx), 4, r_ofs (tss_edx), 4, r_ofs (tss_ebx), 4, r_ofs (tss_esp), 4, r_ofs (tss_ebp), 4, r_ofs (tss_esi), 4, r_ofs (tss_edi), 4, r_ofs (tss_eip), 4, r_ofs (tss_eflags), 4, r_ofs (tss_cs), 2, r_ofs (tss_ss), 2, r_ofs (tss_ds), 2, r_ofs (tss_es), 2, r_ofs (tss_fs), 2, r_ofs (tss_gs), 2, 0, 10, /* 8 FP registers, from npx.reg[] */ 1, 10, 2, 10, 3, 10, 4, 10, 5, 10, 6, 10, 7, 10, /* The order of the next 7 registers must be consistent with their numbering in config/i386/tm-go32.h, which see. */ 0, 2, /* control word, from npx */ 4, 2, /* status word, from npx */ 8, 2, /* tag word, from npx */ 16, 2, /* last FP exception CS from npx */ 24, 2, /* last FP exception operand selector from npx */ 12, 4, /* last FP exception EIP from npx */ 20, 4 /* last FP exception operand offset from npx */ }; static struct { int go32_sig; int gdb_sig; } sig_map[] = { 0, TARGET_SIGNAL_FPE, 1, TARGET_SIGNAL_TRAP, /* Exception 2 is triggered by the NMI. DJGPP handles it as SIGILL, but I think SIGBUS is better, since the NMI is usually activated as a result of a memory parity check failure. */ 2, TARGET_SIGNAL_BUS, 3, TARGET_SIGNAL_TRAP, 4, TARGET_SIGNAL_FPE, 5, TARGET_SIGNAL_SEGV, 6, TARGET_SIGNAL_ILL, 7, TARGET_SIGNAL_FPE, 8, TARGET_SIGNAL_SEGV, 9, TARGET_SIGNAL_SEGV, 10, TARGET_SIGNAL_BUS, 11, TARGET_SIGNAL_SEGV, 12, TARGET_SIGNAL_SEGV, 13, TARGET_SIGNAL_SEGV, 14, TARGET_SIGNAL_SEGV, 16, TARGET_SIGNAL_FPE, 17, TARGET_SIGNAL_BUS, 31, TARGET_SIGNAL_ILL, 0x1b, TARGET_SIGNAL_INT, 0x75, TARGET_SIGNAL_FPE, 0x78, TARGET_SIGNAL_ALRM, 0x79, TARGET_SIGNAL_INT, 0x7a, TARGET_SIGNAL_QUIT, -1, -1 }; static struct { enum target_signal gdb_sig; int djgpp_excepno; } excepn_map[] = { TARGET_SIGNAL_0, -1, TARGET_SIGNAL_ILL, 6, /* Invalid Opcode */ TARGET_SIGNAL_EMT, 7, /* triggers SIGNOFP */ TARGET_SIGNAL_SEGV, 13, /* GPF */ TARGET_SIGNAL_BUS, 17, /* Alignment Check */ /* The rest are fake exceptions, see dpmiexcp.c in djlsr*.zip for details. */ TARGET_SIGNAL_TERM, 0x1b, /* triggers Ctrl-Break type of SIGINT */ TARGET_SIGNAL_FPE, 0x75, TARGET_SIGNAL_INT, 0x79, TARGET_SIGNAL_QUIT, 0x7a, TARGET_SIGNAL_ALRM, 0x78, /* triggers SIGTIMR */ TARGET_SIGNAL_PROF, 0x78, -1, -1 }; static void go32_open (char *name, int from_tty) { printf_unfiltered ("Done. Use the \"run\" command to run the program.\n"); } static void go32_close (int quitting) { } static void go32_attach (char *args, int from_tty) { error ("\ You cannot attach to a running program on this platform.\n\ Use the `run' command to run DJGPP programs."); } static void go32_detach (char *args, int from_tty) { } static int resume_is_step; static int resume_signal = -1; static void go32_resume (int pid, int step, enum target_signal siggnal) { int i; resume_is_step = step; if (siggnal != TARGET_SIGNAL_0 && siggnal != TARGET_SIGNAL_TRAP) { for (i = 0, resume_signal = -1; excepn_map[i].gdb_sig != -1; i++) if (excepn_map[i].gdb_sig == siggnal) { resume_signal = excepn_map[i].djgpp_excepno; break; } if (resume_signal == -1) printf_unfiltered ("Cannot deliver signal %s on this platform.\n", target_signal_to_name (siggnal)); } } static char child_cwd[FILENAME_MAX]; static int go32_wait (int pid, struct target_waitstatus *status) { int i; unsigned char saved_opcode; unsigned long INT3_addr; int stepping_over_INT = 0; a_tss.tss_eflags &= 0xfeff; /* reset the single-step flag (TF) */ if (resume_is_step) { /* If the next instruction is INT xx or INTO, we need to handle them specially. Intel manuals say that these instructions reset the single-step flag (a.k.a. TF). However, it seems that, at least in the DPMI environment, and at least when stepping over the DPMI interrupt 31h, the problem is having TF set at all when INT 31h is executed: the debuggee either crashes (and takes the system with it) or is killed by a SIGTRAP. So we need to emulate single-step mode: we put an INT3 opcode right after the INT xx instruction, let the debuggee run until it hits INT3 and stops, then restore the original instruction which we overwrote with the INT3 opcode, and back up the debuggee's EIP to that instruction. */ read_child (a_tss.tss_eip, &saved_opcode, 1); if (saved_opcode == 0xCD || saved_opcode == 0xCE) { unsigned char INT3_opcode = 0xCC; INT3_addr = saved_opcode == 0xCD ? a_tss.tss_eip + 2 : a_tss.tss_eip + 1; stepping_over_INT = 1; read_child (INT3_addr, &saved_opcode, 1); write_child (INT3_addr, &INT3_opcode, 1); } else a_tss.tss_eflags |= 0x0100; /* normal instruction: set TF */ } /* The special value FFFFh in tss_trap indicates to run_child that tss_irqn holds a signal to be delivered to the debuggee. */ if (resume_signal <= -1) { a_tss.tss_trap = 0; a_tss.tss_irqn = 0xff; } else { a_tss.tss_trap = 0xffff; /* run_child looks for this */ a_tss.tss_irqn = resume_signal; } /* The child might change working directory behind our back. The GDB users won't like the side effects of that when they work with relative file names, and GDB might be confused by its current directory not being in sync with the truth. So we always make a point of changing back to where GDB thinks is its cwd, when we return control to the debugger, but restore child's cwd before we run it. */ chdir (child_cwd); #if __DJGPP_MINOR__ < 3 load_npx (); #endif run_child (); #if __DJGPP_MINOR__ < 3 save_npx (); #endif /* Did we step over an INT xx instruction? */ if (stepping_over_INT && a_tss.tss_eip == INT3_addr + 1) { /* Restore the original opcode. */ a_tss.tss_eip--; /* EIP points *after* the INT3 instruction */ write_child (a_tss.tss_eip, &saved_opcode, 1); /* Simulate a TRAP exception. */ a_tss.tss_irqn = 1; a_tss.tss_eflags |= 0x0100; } getcwd (child_cwd, sizeof (child_cwd)); /* in case it has changed */ chdir (current_directory); if (a_tss.tss_irqn == 0x21) { status->kind = TARGET_WAITKIND_EXITED; status->value.integer = a_tss.tss_eax & 0xff; } else { status->value.sig = TARGET_SIGNAL_UNKNOWN; status->kind = TARGET_WAITKIND_STOPPED; for (i = 0; sig_map[i].go32_sig != -1; i++) { if (a_tss.tss_irqn == sig_map[i].go32_sig) { #if __DJGPP_MINOR__ < 3 if ((status->value.sig = sig_map[i].gdb_sig) != TARGET_SIGNAL_TRAP) status->kind = TARGET_WAITKIND_SIGNALLED; #else status->value.sig = sig_map[i].gdb_sig; #endif break; } } } return SOME_PID; } static void go32_fetch_registers (int regno) { /*JHW */ int end_reg = regno + 1; /* just one reg initially */ if (regno < 0) /* do the all registers */ { regno = 0; /* start at first register */ /* # regs in table */ end_reg = sizeof (regno_mapping) / sizeof (regno_mapping[0]); } for (; regno < end_reg; regno++) { if (regno < 16) supply_register (regno, (char *) &a_tss + regno_mapping[regno].tss_ofs); else if (regno < 24) supply_register (regno, (char *) &npx.reg[regno_mapping[regno].tss_ofs]); else if (regno < 31) supply_register (regno, (char *) &npx + regno_mapping[regno].tss_ofs); else fatal ("Invalid register no. %d in go32_fetch_register.", regno); } } static void store_register (int regno) { void *rp; void *v = (void *) ®isters[REGISTER_BYTE (regno)]; if (regno < 16) rp = (char *) &a_tss + regno_mapping[regno].tss_ofs; else if (regno < 24) rp = (char *) &npx.reg[regno_mapping[regno].tss_ofs]; else if (regno < 31) rp = (char *) &npx + regno_mapping[regno].tss_ofs; else fatal ("Invalid register no. %d in store_register.", regno); memcpy (rp, v, regno_mapping[regno].size); } static void go32_store_registers (int regno) { int r; if (regno >= 0) store_register (regno); else { for (r = 0; r < sizeof (regno_mapping) / sizeof (regno_mapping[0]); r++) store_register (r); } } static void go32_prepare_to_store (void) { } static int go32_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int write, struct target_ops *target) { if (write) { if (write_child (memaddr, myaddr, len)) { return 0; } else { return len; } } else { if (read_child (memaddr, myaddr, len)) { return 0; } else { return len; } } } static cmdline_t child_cmd; /* parsed child's command line kept here */ static void go32_files_info (struct target_ops *target) { printf_unfiltered ("You are running a DJGPP V2 program.\n"); } static void go32_stop (void) { normal_stop (); cleanup_client (); inferior_pid = 0; prog_has_started = 0; } static void go32_kill_inferior (void) { redir_cmdline_delete (&child_cmd); resume_signal = -1; resume_is_step = 0; unpush_target (&go32_ops); } static void go32_create_inferior (char *exec_file, char *args, char **env) { jmp_buf start_state; char *cmdline; char **env_save = environ; if (prog_has_started) { go32_stop (); go32_kill_inferior (); } resume_signal = -1; resume_is_step = 0; /* Init command line storage. */ if (redir_debug_init (&child_cmd) == -1) fatal ("Cannot allocate redirection storage: not enough memory.\n"); /* Parse the command line and create redirections. */ if (strpbrk (args, "<>")) { if (redir_cmdline_parse (args, &child_cmd) == 0) args = child_cmd.command; else error ("Syntax error in command line."); } else child_cmd.command = strdup (args); cmdline = (char *) alloca (strlen (args) + 4); cmdline[0] = strlen (args); strcpy (cmdline + 1, args); cmdline[strlen (args) + 1] = 13; environ = env; if (v2loadimage (exec_file, cmdline, start_state)) { environ = env_save; printf_unfiltered ("Load failed for image %s\n", exec_file); exit (1); } environ = env_save; edi_init (start_state); #if __DJGPP_MINOR__ < 3 save_npx (); #endif inferior_pid = SOME_PID; push_target (&go32_ops); clear_proceed_status (); insert_breakpoints (); proceed ((CORE_ADDR) -1, TARGET_SIGNAL_0, 0); prog_has_started = 1; } static void go32_mourn_inferior (void) { /* We need to make sure all the breakpoint enable bits in the DR7 register are reset when the inferior exits. Otherwise, if they rerun the inferior, the uncleared bits may cause random SIGTRAPs, failure to set more watchpoints, and other calamities. It would be nice if GDB itself would take care to remove all breakpoints at all times, but it doesn't, probably under an assumption that the OS cleans up when the debuggee exits. */ cleanup_dregs (); go32_kill_inferior (); generic_mourn_inferior (); } static int go32_can_run (void) { return 1; } static void ignore (void) { } /* Hardware watchpoint support. */ #define DR_STATUS 6 #define DR_CONTROL 7 #define DR_ENABLE_SIZE 2 #define DR_LOCAL_ENABLE_SHIFT 0 #define DR_GLOBAL_ENABLE_SHIFT 1 #define DR_LOCAL_SLOWDOWN 0x100 #define DR_GLOBAL_SLOWDOWN 0x200 #define DR_CONTROL_SHIFT 16 #define DR_CONTROL_SIZE 4 #define DR_RW_READWRITE 0x3 #define DR_RW_WRITE 0x1 #define DR_CONTROL_MASK 0xf #define DR_ENABLE_MASK 0x3 #define DR_LEN_1 0x0 #define DR_LEN_2 0x4 #define DR_LEN_4 0xc #define D_REGS edi.dr #define CONTROL D_REGS[DR_CONTROL] #define STATUS D_REGS[DR_STATUS] #define IS_REG_FREE(index) \ (!(CONTROL & (3 << (DR_ENABLE_SIZE * (index))))) #define LOCAL_ENABLE_REG(index) \ (CONTROL |= (1 << (DR_LOCAL_ENABLE_SHIFT + DR_ENABLE_SIZE * (index)))) #define GLOBAL_ENABLE_REG(index) \ (CONTROL |= (1 << (DR_GLOBAL_ENABLE_SHIFT + DR_ENABLE_SIZE * (index)))) #define DISABLE_REG(index) \ (CONTROL &= ~(3 << (DR_ENABLE_SIZE * (index)))) #define SET_LOCAL_EXACT() \ (CONTROL |= DR_LOCAL_SLOWDOWN) #define SET_GLOBAL_EXACT() \ (CONTROL |= DR_GLOBAL_SLOWDOWN) #define RESET_LOCAL_EXACT() \ (CONTROL &= ~(DR_LOCAL_SLOWDOWN)) #define RESET_GLOBAL_EXACT() \ (CONTROL &= ~(DR_GLOBAL_SLOWDOWN)) #define SET_BREAK(index,address) \ do {\ CONTROL &= ~(DR_CONTROL_MASK << (DR_CONTROL_SHIFT + DR_CONTROL_SIZE * (index)));\ D_REGS[index] = address;\ dr_ref_count[index]++;\ } while(0) #define SET_WATCH(index,address,rw,len) \ do {\ SET_BREAK(index,address);\ CONTROL |= ((len)|(rw)) << (DR_CONTROL_SHIFT + DR_CONTROL_SIZE * (index));\ } while (0) #define IS_WATCH(index) \ (CONTROL & (DR_CONTROL_MASK << (DR_CONTROL_SHIFT + DR_CONTROL_SIZE*(index)))) #define WATCH_HIT(index) ((STATUS & (1 << (index))) && IS_WATCH(index)) #define DR_DEF(index) \ ((CONTROL >> (DR_CONTROL_SHIFT + DR_CONTROL_SIZE * (index))) & 0x0f) #if 0 /* use debugging macro */ #define SHOW_DR(text,len) \ do { \ if (!getenv ("GDB_SHOW_DR")) break; \ fprintf(stderr,"%08x %08x ",edi.dr[7],edi.dr[6]); \ fprintf(stderr,"%08x %d %08x %d ", \ edi.dr[0],dr_ref_count[0],edi.dr[1],dr_ref_count[1]); \ fprintf(stderr,"%08x %d %08x %d ", \ edi.dr[2],dr_ref_count[2],edi.dr[3],dr_ref_count[3]); \ fprintf(stderr,(len)?"(%s:%d)\n":"(%s)\n",#text,len); \ } while (0) #else #define SHOW_DR(text,len) do {} while (0) #endif static void cleanup_dregs (void) { int i; CONTROL = 0; STATUS = 0; for (i = 0; i < 4; i++) { D_REGS[i] = 0; dr_ref_count[i] = 0; } } /* Insert a watchpoint. */ int go32_insert_watchpoint (int pid, CORE_ADDR addr, int len, int rw) { int ret = go32_insert_aligned_watchpoint (addr, addr, len, rw); SHOW_DR (insert_watch, len); return ret; } static int go32_insert_aligned_watchpoint (CORE_ADDR waddr, CORE_ADDR addr, int len, int rw) { int i; int read_write_bits, len_bits; /* Values of rw: 0 - write, 1 - read, 2 - access (read and write). However, x86 doesn't support read-only data breakpoints. */ read_write_bits = rw ? DR_RW_READWRITE : DR_RW_WRITE; switch (len) { case 4: len_bits = DR_LEN_4; break; case 2: len_bits = DR_LEN_2; break; case 1: len_bits = DR_LEN_1; break; default: /* The debug registers only have 2 bits for the length, so so this value will always fail the loop below. */ len_bits = 0x10; } /* Look for an occupied debug register with the same address and the same RW and LEN definitions. If we find one, we can use it for this watchpoint as well (and save a register). */ for (i = 0; i < 4; i++) { if (!IS_REG_FREE (i) && D_REGS[i] == addr && DR_DEF (i) == (len_bits | read_write_bits)) { dr_ref_count[i]++; return 0; } } /* Look for a free debug register. */ for (i = 0; i <= 3; i++) { if (IS_REG_FREE (i)) break; } /* No more debug registers! */ if (i > 3) return -1; if (len == 2) { if (addr % 2) return go32_handle_nonaligned_watchpoint (wp_insert, waddr, addr, len, rw); } else if (len == 4) { if (addr % 4) return go32_handle_nonaligned_watchpoint (wp_insert, waddr, addr, len, rw); } else if (len != 1) return go32_handle_nonaligned_watchpoint (wp_insert, waddr, addr, len, rw); SET_WATCH (i, addr, read_write_bits, len_bits); LOCAL_ENABLE_REG (i); SET_LOCAL_EXACT (); SET_GLOBAL_EXACT (); return 0; } static int go32_handle_nonaligned_watchpoint (wp_op what, CORE_ADDR waddr, CORE_ADDR addr, int len, int rw) { int align; int size; int rv = 0, status = 0; static int size_try_array[16] = { 1, 1, 1, 1, /* trying size one */ 2, 1, 2, 1, /* trying size two */ 2, 1, 2, 1, /* trying size three */ 4, 1, 2, 1 /* trying size four */ }; while (len > 0) { align = addr % 4; /* Four is the maximum length for 386. */ size = (len > 4) ? 3 : len - 1; size = size_try_array[size * 4 + align]; if (what == wp_insert) status = go32_insert_aligned_watchpoint (waddr, addr, size, rw); else if (what == wp_remove) status = go32_remove_aligned_watchpoint (waddr, addr, size, rw); else if (what == wp_count) rv++; else status = -1; /* We keep the loop going even after a failure, because some of the other aligned watchpoints might still succeed, e.g. if they watch addresses that are already watched, and thus just increment the reference counts of occupied debug registers. If we break out of the loop too early, we could cause those addresses watched by other watchpoints to be disabled when GDB reacts to our failure to insert this watchpoint and tries to remove it. */ if (status) rv = status; addr += size; len -= size; } return rv; } /* Remove a watchpoint. */ int go32_remove_watchpoint (int pid, CORE_ADDR addr, int len, int rw) { int ret = go32_remove_aligned_watchpoint (addr, addr, len, rw); SHOW_DR (remove_watch, len); return ret; } static int go32_remove_aligned_watchpoint (CORE_ADDR waddr, CORE_ADDR addr, int len, int rw) { int i; int read_write_bits, len_bits; /* Values of rw: 0 - write, 1 - read, 2 - access (read and write). However, x86 doesn't support read-only data breakpoints. */ read_write_bits = rw ? DR_RW_READWRITE : DR_RW_WRITE; switch (len) { case 4: len_bits = DR_LEN_4; break; case 2: len_bits = DR_LEN_2; break; case 1: len_bits = DR_LEN_1; break; default: /* The debug registers only have 2 bits for the length, so so this value will always fail the loop below. */ len_bits = 0x10; } if (len == 2) { if (addr % 2) return go32_handle_nonaligned_watchpoint (wp_remove, waddr, addr, len, rw); } else if (len == 4) { if (addr % 4) return go32_handle_nonaligned_watchpoint (wp_remove, waddr, addr, len, rw); } else if (len != 1) return go32_handle_nonaligned_watchpoint (wp_remove, waddr, addr, len, rw); for (i = 0; i <= 3; i++) { if (!IS_REG_FREE (i) && D_REGS[i] == addr && DR_DEF (i) == (len_bits | read_write_bits)) { dr_ref_count[i]--; if (dr_ref_count[i] == 0) DISABLE_REG (i); } } RESET_LOCAL_EXACT (); RESET_GLOBAL_EXACT (); return 0; } /* Can we use debug registers to watch a region whose address is ADDR and whose length is LEN bytes? */ int go32_region_ok_for_watchpoint (CORE_ADDR addr, int len) { /* Compute how many aligned watchpoints we would need to cover this region. */ int nregs = go32_handle_nonaligned_watchpoint (wp_count, addr, addr, len, 0); return nregs <= 4 ? 1 : 0; } /* Check if stopped by a data watchpoint. If so, return the address whose access triggered the watchpoint. */ CORE_ADDR go32_stopped_by_watchpoint (int pid, int data_watchpoint) { int i, ret = 0; int status; status = edi.dr[DR_STATUS]; SHOW_DR (stopped_by, 0); for (i = 0; i <= 3; i++) { if (WATCH_HIT (i) && data_watchpoint) { SHOW_DR (WP_HIT, 0); ret = D_REGS[i]; } } return ret; } /* Remove a breakpoint. */ int go32_remove_hw_breakpoint (CORE_ADDR addr, CORE_ADDR shadow) { int i; for (i = 0; i <= 3; i++) { if (!IS_REG_FREE (i) && D_REGS[i] == addr && DR_DEF (i) == 0) { dr_ref_count[i]--; if (dr_ref_count[i] == 0) DISABLE_REG (i); } } SHOW_DR (remove_hw, 0); return 0; } int go32_insert_hw_breakpoint (CORE_ADDR addr, CORE_ADDR shadow) { int i; int read_write_bits, len_bits; int free_debug_register; int register_number; /* Look for an occupied debug register with the same address and the same RW and LEN definitions. If we find one, we can use it for this breakpoint as well (and save a register). */ for (i = 0; i < 4; i++) { if (!IS_REG_FREE (i) && D_REGS[i] == addr && DR_DEF (i) == 0) { dr_ref_count[i]++; SHOW_DR (insert_hw, 0); return 0; } } /* Look for a free debug register. */ for (i = 0; i <= 3; i++) { if (IS_REG_FREE (i)) break; } /* No more debug registers? */ if (i < 4) { SET_BREAK (i, addr); LOCAL_ENABLE_REG (i); } SHOW_DR (insert_hw, 0); return i < 4 ? 0 : -1; } /* Put the device open on handle FD into either raw or cooked mode, return 1 if it was in raw mode, zero otherwise. */ static int device_mode (int fd, int raw_p) { int oldmode, newmode; __dpmi_regs regs; regs.x.ax = 0x4400; regs.x.bx = fd; __dpmi_int (0x21, ®s); if (regs.x.flags & 1) return -1; newmode = oldmode = regs.x.dx; if (raw_p) newmode |= 0x20; else newmode &= ~0x20; if (oldmode & 0x80) /* Only for character dev */ { regs.x.ax = 0x4401; regs.x.bx = fd; regs.x.dx = newmode & 0xff; /* Force upper byte zero, else it fails */ __dpmi_int (0x21, ®s); if (regs.x.flags & 1) return -1; } return (oldmode & 0x20) == 0x20; } static int inf_mode_valid = 0; static int inf_terminal_mode; /* This semaphore is needed because, amazingly enough, GDB calls target.to_terminal_ours more than once after the inferior stops. But we need the information from the first call only, since the second call will always see GDB's own cooked terminal. */ static int terminal_is_ours = 1; static void go32_terminal_init (void) { inf_mode_valid = 0; /* reinitialize, in case they are restarting child */ terminal_is_ours = 1; } static void go32_terminal_info (char *args, int from_tty) { printf_unfiltered ("Inferior's terminal is in %s mode.\n", !inf_mode_valid ? "default" : inf_terminal_mode ? "raw" : "cooked"); #if __DJGPP_MINOR__ > 2 if (child_cmd.redirection) { int i; for (i = 0; i < DBG_HANDLES; i++) { if (child_cmd.redirection[i]->file_name) printf_unfiltered ("\tFile handle %d is redirected to `%s'.\n", i, child_cmd.redirection[i]->file_name); else if (_get_dev_info (child_cmd.redirection[i]->inf_handle) == -1) printf_unfiltered ("\tFile handle %d appears to be closed by inferior.\n", i); /* Mask off the raw/cooked bit when comparing device info words. */ else if ((_get_dev_info (child_cmd.redirection[i]->inf_handle) & 0xdf) != (_get_dev_info (i) & 0xdf)) printf_unfiltered ("\tFile handle %d appears to be redirected by inferior.\n", i); } } #endif } static void go32_terminal_inferior (void) { /* Redirect standard handles as child wants them. */ errno = 0; if (redir_to_child (&child_cmd) == -1) { redir_to_debugger (&child_cmd); error ("Cannot redirect standard handles for program: %s.", strerror (errno)); } /* set the console device of the inferior to whatever mode (raw or cooked) we found it last time */ if (terminal_is_ours) { if (inf_mode_valid) device_mode (0, inf_terminal_mode); terminal_is_ours = 0; } } static void go32_terminal_ours (void) { /* Switch to cooked mode on the gdb terminal and save the inferior terminal mode to be restored when it is resumed */ if (!terminal_is_ours) { inf_terminal_mode = device_mode (0, 0); if (inf_terminal_mode != -1) inf_mode_valid = 1; else /* If device_mode returned -1, we don't know what happens with handle 0 anymore, so make the info invalid. */ inf_mode_valid = 0; terminal_is_ours = 1; /* Restore debugger's standard handles. */ errno = 0; if (redir_to_debugger (&child_cmd) == -1) { redir_to_child (&child_cmd); error ("Cannot redirect standard handles for debugger: %s.", strerror (errno)); } } } static void init_go32_ops (void) { go32_ops.to_shortname = "djgpp"; go32_ops.to_longname = "djgpp target process"; go32_ops.to_doc = "Program loaded by djgpp, when gdb is used as an external debugger"; go32_ops.to_open = go32_open; go32_ops.to_close = go32_close; go32_ops.to_attach = go32_attach; go32_ops.to_detach = go32_detach; go32_ops.to_resume = go32_resume; go32_ops.to_wait = go32_wait; go32_ops.to_fetch_registers = go32_fetch_registers; go32_ops.to_store_registers = go32_store_registers; go32_ops.to_prepare_to_store = go32_prepare_to_store; go32_ops.to_xfer_memory = go32_xfer_memory; go32_ops.to_files_info = go32_files_info; go32_ops.to_insert_breakpoint = memory_insert_breakpoint; go32_ops.to_remove_breakpoint = memory_remove_breakpoint; go32_ops.to_terminal_init = go32_terminal_init; go32_ops.to_terminal_inferior = go32_terminal_inferior; go32_ops.to_terminal_ours_for_output = go32_terminal_ours; go32_ops.to_terminal_ours = go32_terminal_ours; go32_ops.to_terminal_info = go32_terminal_info; go32_ops.to_kill = go32_kill_inferior; go32_ops.to_create_inferior = go32_create_inferior; go32_ops.to_mourn_inferior = go32_mourn_inferior; go32_ops.to_can_run = go32_can_run; go32_ops.to_stop = go32_stop; go32_ops.to_stratum = process_stratum; go32_ops.to_has_all_memory = 1; go32_ops.to_has_memory = 1; go32_ops.to_has_stack = 1; go32_ops.to_has_registers = 1; go32_ops.to_has_execution = 1; go32_ops.to_magic = OPS_MAGIC; /* Initialize child's cwd with the current one. */ getcwd (child_cwd, sizeof (child_cwd)); /* Initialize child's command line storage. */ if (redir_debug_init (&child_cmd) == -1) fatal ("Cannot allocate redirection storage: not enough memory.\n"); } void _initialize_go32_nat (void) { init_go32_ops (); add_target (&go32_ops); } pid_t tcgetpgrp (int fd) { if (isatty (fd)) return SOME_PID; errno = ENOTTY; return -1; } int tcsetpgrp (int fd, pid_t pgid) { if (isatty (fd) && pgid == SOME_PID) return 0; errno = pgid == SOME_PID ? ENOTTY : ENOSYS; return -1; }