import gdb-1999-08-23 snapshot
This commit is contained in:
Jason Molenda
parent
093505ad61
commit
53a5351d90
289
gdb/ChangeLog
289
gdb/ChangeLog
|
|
@ -1,3 +1,292 @@
|
|||
Mon Aug 23 10:16:32 1999 Jeffrey A Law (law@cygnus.com)
|
||||
|
||||
* pa64solib.c: Fix some minor whitespace problems.
|
||||
(bfd_lookup_symbol): New function.
|
||||
(pa64_solib_create_inferior_hook): Find the address __dld_break
|
||||
in the dynamic linker. Try to set a shlib event breakpoint in
|
||||
that function.
|
||||
(add_to_solist): Do not add the same shared library to the shlib
|
||||
list more than once.
|
||||
|
||||
Sun Aug 22 14:49:40 1999 Andrew Cagney <cagney@b1.cygnus.com>
|
||||
|
||||
* value.h (enum lval_type): Move declaration from here.
|
||||
* defs.h (enum lval_type): To here.
|
||||
* frame.h, gdbarch.h: Delete incomplete declaration of ``enum
|
||||
lval_type''.
|
||||
|
||||
1999-08-20 Michael Snyder <msnyder@cleaver.cygnus.com>
|
||||
|
||||
* breakpoint.c (can_use_hardware_watchpoint): reject expressions
|
||||
that refer to registers or register variables.
|
||||
|
||||
Fri Aug 20 10:53:38 1999 Jeffrey A Law (law@cygnus.com)
|
||||
|
||||
* hppa-tdep.c (hppa_fix_call_dummy): Provide PA2.0W aware code.
|
||||
|
||||
* pa64solib.c pa64solib.h: New files.
|
||||
|
||||
* config/pa/hppa64.mt: Delete commented out code that is and
|
||||
never will be appropriate for this target.
|
||||
* config/pa/hpux11w.mt (TDEPFILES): Remove SOM references. Also
|
||||
remove pa64solib.o.
|
||||
* config/pa/hpux11w.mh (NATDEPFILES): Remove SOM references.
|
||||
|
||||
* configure.host; Use "hpux11w" and "hpux11" instead of
|
||||
"hpux1100w" and "hpux1100" respectively
|
||||
* config/pa/hpux11w.mh: Renamed from hpux1100w.mh.
|
||||
* config/pa/hpux11w.mt, config/pa/hpux11.mh: Likewise.
|
||||
* config/pa/hpux11.mt: Likewise.
|
||||
|
||||
1999-08-19 Michael Snyder <msnyder@cleaver.cygnus.com>
|
||||
|
||||
* breakpoint.h (target_hw_bp_type): new enum.
|
||||
* breakpoint.c (insert_breakpoints): use enum instead of consts.
|
||||
(remove_breakpoint): use enum instead of consts.
|
||||
[Also clean up a bunch of excessively long lines.]
|
||||
|
||||
1999-08-19 J.T. Conklin <jtc@redback.com>
|
||||
|
||||
* i386-stub.c (waitabit): Removed.
|
||||
(breakpoint): Update.
|
||||
|
||||
* i386-stub.c, m32r-stub.c, sparc-stub.c, sparcl-stub.c,
|
||||
sparclet-stub.c (set_debug_traps): Don't send gratuitous ACK.
|
||||
|
||||
* m68k-stub.c (putpacket): Restore code so that packets are sent
|
||||
until an ACK is received.
|
||||
|
||||
1999-08-19 Eli Zaretskii <eliz@is.elta.co.il>
|
||||
|
||||
* breakpoint.c (bpstat_stop_status): Accept triggered addresses
|
||||
anywhere inside the region occupied by a watched variable as a
|
||||
sign that the watchpoint fired. Don't stop if some watchpoint
|
||||
was triggered, but its address doesn't match the address of this
|
||||
watchpoint.
|
||||
(TARGET_REGION_OK_FOR_HW_WATCHPOINT): New macro.
|
||||
Default definition is to call TARGET_REGION_SIZE_OK_FOR_HW_WATCHPOINT.
|
||||
(can_use_hardware_watchpoint): Call TARGET_REGION_OK_FOR_HW_WATCHPOINT;
|
||||
if it returns zero, return zero immediately.
|
||||
(insert_breakpoints): Try to insert watchpoints for all the values
|
||||
on the value chain, even if some of them fail to insert. Remove
|
||||
the breakpoint if parts of its value chain couldn't be inserted.
|
||||
|
||||
1999-08-19 Eli Zaretskii <eliz@is.elta.co.il>
|
||||
|
||||
* go32-nat.c (go32_stopped_by_watchpoint): Remove unused code.
|
||||
|
||||
1999-08-19 Eli Zaretskii <eliz@is.elta.co.il>
|
||||
|
||||
* go32-nat.c (tcgetpgrp, tcsetpgrp): New functions.
|
||||
|
||||
1999-08-19 Eli Zaretskii <eliz@is.elta.co.il>
|
||||
|
||||
* go32-nat.c (go32_wait): If we are in a single-step mode, and the
|
||||
next instruction is INT nn or INTO, use a temporary breakpoint to
|
||||
simulate single-step mode, and reset the trace flag.
|
||||
|
||||
1999-08-19 Eli Zaretskii <eliz@is.elta.co.il>
|
||||
|
||||
* go32-nat.c (wp_op): New typedef.
|
||||
(SHOW_DR): Print the length of watched region as well.
|
||||
(go32_insert_aligned_watchpoint): Remove unused argument PID. All
|
||||
callers and the prototype changed.
|
||||
(go32_handle_nonaligned_watchpoint): Renamed from
|
||||
go32_insert_nonaligned_watchpoint. Now handles all operations on
|
||||
non-aligned watchpoints: insertion, deletion, and counting. If
|
||||
called with wp_count as the first argument, return the count of
|
||||
debug registers needed to watch the region. Don't break out of
|
||||
the loop before all the addresses in the region are processed.
|
||||
(go32_remove_watchpoint): Call go32_remove_aligned_watchpoint to
|
||||
do the actual work.
|
||||
(go32_remove_aligned_watchpoint): New function, modeled after
|
||||
go32_insert_aligned_watchpoint. Removes watchpoints that watch
|
||||
regions of arbitrary length by calling
|
||||
go32_handle_nonaligned_watchpoint as needed.
|
||||
(go32_region_ok_for_watchpoint): New function, called from
|
||||
can_use_hardware_watchpoint via the new macro
|
||||
TARGET_REGION_OK_FOR_HW_WATCHPOINT.
|
||||
|
||||
* config/i386/nm-go32.h (TARGET_REGION_OK_FOR_HW_WATCHPOINT):
|
||||
Define to call go32_region_ok_for_watchpoint.
|
||||
(DECR_PC_AFTER_HW_BREAK): Define back to zero (previous redefinition
|
||||
to 1 was due to a bug in go32-nat.c).
|
||||
|
||||
1999-08-19 Eli Zaretskii <eliz@is.elta.co.il>
|
||||
|
||||
* go32-nat.c (cleanup_dregs): New function.
|
||||
(go32_mourn_inferior): Call it.
|
||||
(IS_REG_FREE, LOCAL_ENABLE_REG, GLOBAL_ENABLE_REG, DISABLE_REG,
|
||||
SET_BREAK, SET_WATCH, IS_WATCH, WATCH_HIT): Protect arguments with
|
||||
parentheses.
|
||||
(SET_BREAK): Increment the debug register's reference count.
|
||||
(DR_DEF): New macro, returns the access and length bits of the
|
||||
breakpoint.
|
||||
(SHOW_DR): Print the reference count of each register. Disable or
|
||||
enable print-out depending on an environment variable GDB_SHOW_DR.
|
||||
(go32_insert_aligned_watchpoint): Look for an occupied debug
|
||||
register with the same address and access/length bits, and reuse
|
||||
it by incrementing reference the count, before occupying another
|
||||
register. Return zero upon success.
|
||||
(go32_insert_nonaligned_watchpoint): Pass the read/write bits to
|
||||
go32_remove_watchpoint.
|
||||
(go32_remove_watchpoint): Accept an additional parameter: the
|
||||
read/write bits of the watchpoint to remove, and only remove a
|
||||
watchpoint if it's occupied and its address and read/write bits
|
||||
match. Only disable the register if its reference count is zero;
|
||||
otherwise just decrease the reference count.
|
||||
(go32_remove_hw_breakpoint): Only decrease reference count and
|
||||
disable the debug register if it is occupied and its access bits
|
||||
match those of an instruction breakpoint.
|
||||
(go32_insert_hw_breakpoint): Before occupying another debug
|
||||
register, look for an already occupied register that defines an
|
||||
instruction breakpoint with the same address. If found, increment
|
||||
its reference count. Call SHOW_DR even if failed to insert a
|
||||
breakpoint.
|
||||
|
||||
* config/i386/nm-go32.h (target_remove_watchpoint): Accept the
|
||||
TYPE argument as well.
|
||||
|
||||
Wed Aug 18 17:47:25 1999 Andrew Cagney <cagney@b1.cygnus.com>
|
||||
|
||||
* mips-tdep.c: Add more comments.
|
||||
|
||||
1999-08-17 Stan Shebs <shebs@andros.cygnus.com>
|
||||
|
||||
* blockframe.c: Don't use PARAMS anymore, remove obsolete comment
|
||||
about frameless functions.
|
||||
|
||||
1999-08-16 Michael Snyder <msnyder@cleaver.cygnus.com>
|
||||
|
||||
* thread.c (delete_thread): delete any step_resume breakpoint
|
||||
held by the thread. (prune_threads): call delete_thread.
|
||||
* breakpoint.c (breakpoint_init_inferior): if startup, then
|
||||
delete any remaining step_resume breakpoints.
|
||||
* infrun.c (handle_inferior_event): add cautionary comment.
|
||||
|
||||
1999-08-16 Fernando Nasser <fnasser@totem.to.cygnus.com>
|
||||
|
||||
* remote.c (remote_async_mourn): New function. Async version of
|
||||
remote_mourn().
|
||||
|
||||
1999-08-16 Eli Zaretskii <eliz@is.elta.co.il>
|
||||
|
||||
* terminal.h [__GO32__]: Remove conditional; DJGPP now supports
|
||||
termios.
|
||||
|
||||
1999-08-16 Eli Zaretskii <eliz@is.elta.co.il>
|
||||
|
||||
* command.c (CANT_FORK) [__MSDOS__]: Define.
|
||||
(shell_escape) [CANT_FORK]: If ARG is NULL, pass an empty string
|
||||
to `system'.
|
||||
[__DJGPP__]: Return to the original directory after the shell
|
||||
exits.
|
||||
|
||||
1999-08-16 Eli Zaretskii <eliz@is.elta.co.il>
|
||||
|
||||
* config/i386/xm-go32.h (ROOTED_P): Don't reference X[1] if X[0]
|
||||
is a null character.
|
||||
|
||||
* config/i386/nm-go32.h (DECR_PC_AFTER_HW_BREAK): Define to 1.
|
||||
|
||||
1999-08-16 Eli Zaretskii <eliz@is.elta.co.il>
|
||||
|
||||
* go32-nat.c (redir_cmdline_parse, redir_cmdline_delete,
|
||||
redir_to_child, redir_to_debugger, redir_debug_init)
|
||||
[__DJGPP_MINOR__ < 3]: Dummy stubs for redirecting debuggee's
|
||||
standard handles.
|
||||
(print_387_status): Print "last FP instruction", not "last
|
||||
exception". Restore the upper 5 bits of the opcode that aren't
|
||||
stored in the FPU state. Print the FPU stack in its physical
|
||||
order, not relative to ST(0). Print "special", not "trap" for
|
||||
unnormals and infinities. Print all 10 bytes of each FP register,
|
||||
and print them with 19 significant digits.
|
||||
(regno_mapping): Make the mapping consistent with tm-go32.h.
|
||||
(sig_map): Add mappings for SIGQUIT, SIGFPE, SIGALRM. Map NMI to
|
||||
SIGBUS.
|
||||
(excep_map): New variable, maps GDB signals to DJGPP exceptions.
|
||||
(go32_attach): Signal an error: we cannot attach to other
|
||||
processes.
|
||||
(go32_resume): Record the signal with which the inferior should be
|
||||
resumed, mapped to the DJGPP exception number.
|
||||
(go32_wait): Pass the signal recorded in go32_resume to the
|
||||
debuggee. Save and restore debugger's and debuggee's current
|
||||
working directory.
|
||||
[__DJGPP_MINOR__ < 3]: Save and restore inferior's FPU state.
|
||||
(store_register): FPU regsiters have numbers less than 31.
|
||||
(go32_kill_inferior): Delete the parsed command-line storage.
|
||||
(go32_create_inferior): Initialize the parsed command-line
|
||||
storage. Parse the command line and create the redirections for
|
||||
inferior's standard handles.
|
||||
[__DJGPP_MINOR__ < 3]: Init the inferior's FPU state.
|
||||
(ignore2): Function deleted.
|
||||
(device_mode): New function, switches a character device between
|
||||
raw and cooked mode.
|
||||
(go32_terminal_init): Invalidate the raw/cooked mode information.
|
||||
(go32_terminal_info): Print whether the inferior's terminal is in
|
||||
raw or cooked mode.
|
||||
[__DJGPP_MINOR__ > 2]: Say if standard handles are redirected or
|
||||
closed by the inferior.
|
||||
(go32_terminal_inferior): Switch standard handles to the
|
||||
inferior's files/devices. Put the inferior's input device to
|
||||
raw/cooked mode, exactly like we found it last time.
|
||||
(go32_terminal_ours): Restore debugger's standard handles and put
|
||||
the terminal into cooked mode. Save the mode of inferior's input
|
||||
device.
|
||||
(init_go32_ops): Assign go32_ops.to_attach,
|
||||
go32_ops.to_terminal_info, go32_ops.to_terminal_ours_for_output.
|
||||
Initialize inferior's cwd and the command-line storage.
|
||||
|
||||
Mon Aug 16 14:29:30 1999 Jeffrey A Law (law@cygnus.com)
|
||||
|
||||
* config/pa/tm-hppa.h (ARGS_GROW_DOWNWARD): Define.
|
||||
* config/pa/tm-hppa64.h (ARGS_GROW_DOWNWARD): Undefine.
|
||||
* hppa-tdep.c (hppa_push_arguments): Handle arguments growing in
|
||||
both directions depending ARGS_GROW_DOWNWARD.
|
||||
(hppa_find_saved_regs): Update for 64bit wide registers & pointers
|
||||
and PA64 ABI.
|
||||
|
||||
* hppa-tdep.c (hppa_pop_frame): Various fixes for 64bit wide
|
||||
registers and pointers.
|
||||
(hppa_fix_call_dummy, skip_trampoline_code): Likewise.
|
||||
(restore_pc_queue): Update tests for width of memory loads.
|
||||
(hppa_push_arguments): Delete version that was #if 0'd out.
|
||||
|
||||
* hppa-tdep.c (push_dummy_frame): Handle the new 64it ABI.
|
||||
(find_dummy_frame_regs): Corresponding changes.
|
||||
|
||||
* hppa-tdep.c (read_unwind_info): Initialize obj_private->dp.
|
||||
(internalize_unwinds): Improve test for when to use segment
|
||||
relative code for unwinder bounds.
|
||||
(rp_saved): Fix offset of saved return pointer for the 64bit ABI.
|
||||
(hppa_frame_saved_pc): Various updates to handle 64bit registers
|
||||
and pointers.
|
||||
(frame_chain, restore_pc_queue): Likewise.
|
||||
|
||||
* hppa-tdep.c (rp_saved): RP is saved at frame-16 when
|
||||
pointers are 64bits wide.
|
||||
|
||||
* hppa-tdep.c (record_text_segment_lowaddr): New function.
|
||||
(internalize_unwinds): Use it if addressess are 8 bytes wide.
|
||||
|
||||
* symfile.c (syms_from_objfile): No longer warn if the lowest
|
||||
section does not have SEC_CODE set.
|
||||
|
||||
* Makefile.in (pa64solib.o): Add dependencies.
|
||||
|
||||
* hppah-nat.c (store_inferior_registers): Do not try to write a
|
||||
nonzero value to the high part of IPSW. Fix typo in unable to store
|
||||
warning.
|
||||
|
||||
* config/pa/tm-hppa.h (opd_data structure): Delete. Not actually
|
||||
needed.
|
||||
(struct obj_private_struct): Add new entry for the objfile's DP
|
||||
value.
|
||||
* config/pa/tm-hppa64.h (CALL_DUMMY): Add a nop to make it an even
|
||||
number of instructions. Pack the dummy into word sized hunks.
|
||||
(CALL_DUMMY_LENGTH): Update appropriately.
|
||||
(PC_IN_CALL_DUMMY, CALL_DUMMY_LOCATION_AFTER_TEXT_END): Delete.
|
||||
|
||||
Mon Aug 16 19:08:19 1999 Andrew Cagney <cagney@b1.cygnus.com>
|
||||
|
||||
* configure.in: Try -lsocket when looking for socketpair.
|
||||
|
|
|
|||
|
|
@ -224,7 +224,7 @@ CDEPS = $(XM_CDEPS) $(TM_CDEPS) $(NAT_CDEPS) $(SIM) $(BFD) $(READLINE) \
|
|||
ADD_FILES = $(REGEX) $(XM_ADD_FILES) $(TM_ADD_FILES) $(NAT_ADD_FILES)
|
||||
ADD_DEPS = $(REGEX1) $(XM_ADD_FILES) $(TM_ADD_FILES) $(NAT_ADD_FILES)
|
||||
|
||||
VERSION = 19990816
|
||||
VERSION = 19990823
|
||||
DIST=gdb
|
||||
|
||||
LINT=/usr/5bin/lint
|
||||
|
|
@ -1346,6 +1346,9 @@ somread.o: somread.c $(bfd_h) buildsym.h complaints.h $(defs_h) \
|
|||
|
||||
somsolib.o: somsolib.c $(defs_h)
|
||||
|
||||
pa64solib.o: pa64solib.c $(defs_h)
|
||||
|
||||
hpux-thread.o: hpux-thread.c $(defs_h) gdbthread.h target.h inferior.h
|
||||
hpux-thread.o: hpux-thread.c $(defs_h) gdbthread.h target.h inferior.h
|
||||
$(CC) -c $(INTERNAL_CFLAGS) -I$(srcdir)/osf-share \
|
||||
-I$(srcdir)/osf-share/HP800 -I/usr/include/dce $(srcdir)/hpux-thread.c
|
||||
|
|
|
|||
|
|
@ -34,7 +34,7 @@
|
|||
|
||||
/* Prototypes for exported functions. */
|
||||
|
||||
void _initialize_blockframe PARAMS ((void));
|
||||
void _initialize_blockframe (void);
|
||||
|
||||
/* A default FRAME_CHAIN_VALID, in the form that is suitable for most
|
||||
targets. If FRAME_CHAIN_VALID returns zero it means that the given
|
||||
|
|
@ -286,11 +286,6 @@ reinit_frame_cache ()
|
|||
}
|
||||
}
|
||||
|
||||
/* If a machine allows frameless functions, it should define a macro
|
||||
FRAMELESS_FUNCTION_INVOCATION(FI, FRAMELESS) in param.h. FI is the struct
|
||||
frame_info for the frame, and FRAMELESS should be set to nonzero
|
||||
if it represents a frameless function invocation. */
|
||||
|
||||
/* Return nonzero if the function for this frame lacks a prologue. Many
|
||||
machines can define FRAMELESS_FUNCTION_INVOCATION to just call this
|
||||
function. */
|
||||
|
|
@ -300,14 +295,15 @@ frameless_look_for_prologue (frame)
|
|||
struct frame_info *frame;
|
||||
{
|
||||
CORE_ADDR func_start, after_prologue;
|
||||
|
||||
func_start = get_pc_function_start (frame->pc);
|
||||
if (func_start)
|
||||
{
|
||||
func_start += FUNCTION_START_OFFSET;
|
||||
after_prologue = func_start;
|
||||
#ifdef SKIP_PROLOGUE_FRAMELESS_P
|
||||
/* This is faster, since only care whether there *is* a prologue,
|
||||
not how long it is. */
|
||||
/* This is faster, since only care whether there *is* a
|
||||
prologue, not how long it is. */
|
||||
after_prologue = SKIP_PROLOGUE_FRAMELESS_P (after_prologue);
|
||||
#else
|
||||
after_prologue = SKIP_PROLOGUE (after_prologue);
|
||||
|
|
@ -315,10 +311,10 @@ frameless_look_for_prologue (frame)
|
|||
return after_prologue == func_start;
|
||||
}
|
||||
else if (frame->pc == 0)
|
||||
/* A frame with a zero PC is usually created by dereferencing a NULL
|
||||
function pointer, normally causing an immediate core dump of the
|
||||
inferior. Mark function as frameless, as the inferior has no chance
|
||||
of setting up a stack frame. */
|
||||
/* A frame with a zero PC is usually created by dereferencing a
|
||||
NULL function pointer, normally causing an immediate core dump
|
||||
of the inferior. Mark function as frameless, as the inferior
|
||||
has no chance of setting up a stack frame. */
|
||||
return 1;
|
||||
else
|
||||
/* If we can't find the start of the function, we don't really
|
||||
|
|
@ -1239,7 +1235,7 @@ generic_save_dummy_frame_tos (sp)
|
|||
|
||||
void
|
||||
generic_pop_current_frame (pop)
|
||||
void (*pop) PARAMS ((struct frame_info * frame));
|
||||
void (*pop) (struct frame_info * frame);
|
||||
{
|
||||
struct frame_info *frame = get_current_frame ();
|
||||
if (PC_IN_CALL_DUMMY (frame->pc, frame->frame, frame->frame))
|
||||
|
|
@ -1401,7 +1397,7 @@ generic_get_saved_register (raw_buffer, optimized, addrp, frame, regnum, lval)
|
|||
}
|
||||
|
||||
void
|
||||
_initialize_blockframe ()
|
||||
_initialize_blockframe (void)
|
||||
{
|
||||
obstack_init (&frame_cache_obstack);
|
||||
}
|
||||
|
|
|
|||
532
gdb/breakpoint.c
532
gdb/breakpoint.c
File diff suppressed because it is too large
Load Diff
|
|
@ -122,17 +122,18 @@ enum bptype
|
|||
|
||||
enum enable
|
||||
{
|
||||
disabled, /* The eventpoint is inactive, and cannot trigger. */
|
||||
enabled, /* The eventpoint is active, and can trigger. */
|
||||
shlib_disabled, /* The eventpoint's address is within an unloaded solib.
|
||||
The eventpoint will be automatically enabled & reset
|
||||
when that solib is loaded. */
|
||||
call_disabled /* The eventpoint has been disabled while a call into
|
||||
the inferior is "in flight", because some eventpoints
|
||||
interfere with the implementation of a call on some
|
||||
targets. The eventpoint will be automatically enabled
|
||||
& reset when the call "lands" (either completes, or
|
||||
stops at another eventpoint). */
|
||||
disabled, /* The eventpoint is inactive, and cannot trigger. */
|
||||
enabled, /* The eventpoint is active, and can trigger. */
|
||||
shlib_disabled, /* The eventpoint's address is in an unloaded solib.
|
||||
The eventpoint will be automatically enabled
|
||||
and reset when that solib is loaded. */
|
||||
call_disabled /* The eventpoint has been disabled while a call
|
||||
into the inferior is "in flight", because some
|
||||
eventpoints interfere with the implementation of
|
||||
a call on some targets. The eventpoint will be
|
||||
automatically enabled and reset when the call
|
||||
"lands" (either completes, or stops at another
|
||||
eventpoint). */
|
||||
};
|
||||
|
||||
|
||||
|
|
@ -146,6 +147,14 @@ enum bpdisp
|
|||
donttouch /* Leave it alone */
|
||||
};
|
||||
|
||||
enum target_hw_bp_type
|
||||
{
|
||||
hw_write = 0, /* Common HW watchpoint */
|
||||
hw_read = 1, /* Read HW watchpoint */
|
||||
hw_access = 2, /* Access HW watchpoint */
|
||||
hw_execute = 3 /* Execute HW breakpoint */
|
||||
};
|
||||
|
||||
/* Note that the ->silent field is not currently used by any commands
|
||||
(though the code is in there if it was to be, and set_raw_breakpoint
|
||||
does set it to 0). I implemented it because I thought it would be
|
||||
|
|
@ -248,8 +257,9 @@ struct breakpoint
|
|||
aborting, so you can back up to just before the abort. */
|
||||
int hit_count;
|
||||
|
||||
/* Filename of a dynamically-linked library (dll), used for bp_catch_load
|
||||
and bp_catch_unload (malloc'd), or NULL if any library is significant. */
|
||||
/* Filename of a dynamically-linked library (dll), used for
|
||||
bp_catch_load and bp_catch_unload (malloc'd), or NULL if any
|
||||
library is significant. */
|
||||
char *dll_pathname;
|
||||
|
||||
/* Filename of a dll whose state change (e.g., load or unload)
|
||||
|
|
@ -257,20 +267,22 @@ struct breakpoint
|
|||
after this catchpoint has triggered. */
|
||||
char *triggered_dll_pathname;
|
||||
|
||||
/* Process id of a child process whose forking triggered this catchpoint.
|
||||
This field is only vaid immediately after this catchpoint has triggered. */
|
||||
/* Process id of a child process whose forking triggered this
|
||||
catchpoint. This field is only vaid immediately after this
|
||||
catchpoint has triggered. */
|
||||
int forked_inferior_pid;
|
||||
|
||||
/* Filename of a program whose exec triggered this catchpoint. This
|
||||
field is only vaid immediately after this catchpoint has triggered. */
|
||||
/* Filename of a program whose exec triggered this catchpoint.
|
||||
This field is only vaid immediately after this catchpoint has
|
||||
triggered. */
|
||||
char *exec_pathname;
|
||||
|
||||
asection *section;
|
||||
};
|
||||
|
||||
/* The following stuff is an abstract data type "bpstat" ("breakpoint status").
|
||||
This provides the ability to determine whether we have stopped at a
|
||||
breakpoint, and what we should do about it. */
|
||||
/* The following stuff is an abstract data type "bpstat" ("breakpoint
|
||||
status"). This provides the ability to determine whether we have
|
||||
stopped at a breakpoint, and what we should do about it. */
|
||||
|
||||
typedef struct bpstats *bpstat;
|
||||
|
||||
|
|
@ -417,8 +429,8 @@ extern void bpstat_get_triggered_catchpoints PARAMS ((bpstat, bpstat *));
|
|||
/* Implementation: */
|
||||
struct bpstats
|
||||
{
|
||||
/* Linked list because there can be two breakpoints at the
|
||||
same place, and a bpstat reflects the fact that both have been hit. */
|
||||
/* Linked list because there can be two breakpoints at the same
|
||||
place, and a bpstat reflects the fact that both have been hit. */
|
||||
bpstat next;
|
||||
/* Breakpoint that we are at. */
|
||||
struct breakpoint *breakpoint_at;
|
||||
|
|
@ -474,7 +486,8 @@ extern struct breakpoint *set_momentary_breakpoint
|
|||
|
||||
extern void set_ignore_count PARAMS ((int, int, int));
|
||||
|
||||
extern void set_default_breakpoint PARAMS ((int, CORE_ADDR, struct symtab *, int));
|
||||
extern void set_default_breakpoint PARAMS ((int, CORE_ADDR,
|
||||
struct symtab *, int));
|
||||
|
||||
extern void mark_breakpoints_out PARAMS ((void));
|
||||
|
||||
|
|
@ -588,9 +601,11 @@ extern void disable_breakpoints_in_shlibs PARAMS ((int silent));
|
|||
|
||||
extern void re_enable_breakpoints_in_shlibs PARAMS ((void));
|
||||
|
||||
extern void create_solib_load_event_breakpoint PARAMS ((char *, int, char *, char *));
|
||||
extern void create_solib_load_event_breakpoint PARAMS ((char *, int,
|
||||
char *, char *));
|
||||
|
||||
extern void create_solib_unload_event_breakpoint PARAMS ((char *, int, char *, char *));
|
||||
extern void create_solib_unload_event_breakpoint PARAMS ((char *, int,
|
||||
char *, char *));
|
||||
|
||||
extern void create_fork_event_catchpoint PARAMS ((int, char *));
|
||||
|
||||
|
|
|
|||
|
|
@ -36,6 +36,11 @@
|
|||
|
||||
#include "wait.h"
|
||||
|
||||
/* FIXME: this should be auto-configured! */
|
||||
#ifdef __MSDOS__
|
||||
# define CANT_FORK
|
||||
#endif
|
||||
|
||||
/* Prototypes for local functions */
|
||||
|
||||
static void undef_cmd_error PARAMS ((char *, char *));
|
||||
|
|
@ -1453,9 +1458,29 @@ shell_escape (arg, from_tty)
|
|||
int from_tty;
|
||||
{
|
||||
#ifdef CANT_FORK
|
||||
/* FIXME: what about errors (I don't know how GO32 system() handles
|
||||
them)? */
|
||||
system (arg);
|
||||
/* If ARG is NULL, they want an inferior shell, but `system' just
|
||||
reports if the shell is available when passed a NULL arg. */
|
||||
int rc = system (arg ? arg : "");
|
||||
|
||||
if (!arg)
|
||||
arg = "inferior shell";
|
||||
|
||||
if (rc == -1)
|
||||
{
|
||||
fprintf_unfiltered (gdb_stderr, "Cannot execute %s: %s\n", arg,
|
||||
safe_strerror (errno));
|
||||
gdb_flush (gdb_stderr);
|
||||
}
|
||||
else if (rc)
|
||||
{
|
||||
fprintf_unfiltered (gdb_stderr, "%s exited with status %d\n", arg, rc);
|
||||
gdb_flush (gdb_stderr);
|
||||
}
|
||||
#ifdef __DJGPP__
|
||||
/* Make sure to return to the directory GDB thinks it is, in case the
|
||||
shell command we just ran changed it. */
|
||||
chdir (current_directory);
|
||||
#endif
|
||||
#else /* Can fork. */
|
||||
int rc, status, pid;
|
||||
char *p, *user_shell;
|
||||
|
|
|
|||
|
|
@ -24,8 +24,31 @@
|
|||
|
||||
#define TARGET_HAS_HARDWARE_WATCHPOINTS
|
||||
|
||||
/* Returns the number of hardware watchpoints of type TYPE that we can
|
||||
set. Value is positive if we can set CNT watchpoints, zero if
|
||||
setting watchpoints of type TYPE is not supported, and negative if
|
||||
CNT is more than the maximum number of watchpoints of type TYPE
|
||||
that we can support. TYPE is one of bp_hardware_watchpoint,
|
||||
bp_read_watchpoint, bp_write_watchpoint, or bp_hardware_breakpoint.
|
||||
CNT is the number of such watchpoints used so far (including this
|
||||
one). OTHERTYPE is non-zero if other types of watchpoints are
|
||||
currently enabled.
|
||||
|
||||
We always return 1 here because we don't have enough information
|
||||
about possible overlap of addresses that they want to watch. As
|
||||
an extreme example, consider the case where all the watchpoints
|
||||
watch the same address and the same region length: then we can
|
||||
handle a virtually unlimited number of watchpoints, due to debug
|
||||
register sharing implemented via reference counts in go32-nat.c. */
|
||||
|
||||
#define TARGET_CAN_USE_HARDWARE_WATCHPOINT(type, cnt, ot) 1
|
||||
|
||||
/* Returns non-zero if we can use hardware watchpoints to watch a region
|
||||
whose address is ADDR and whose length is LEN. */
|
||||
|
||||
#define TARGET_REGION_OK_FOR_HW_WATCHPOINT(addr,len) \
|
||||
go32_region_ok_for_watchpoint(addr,len)
|
||||
|
||||
/* After a watchpoint trap, the PC points to the instruction after the
|
||||
one that caused the trap. Therefore we don't need to step over it.
|
||||
But we do need to reset the status register to avoid another trap. */
|
||||
|
|
@ -33,15 +56,18 @@
|
|||
#define HAVE_CONTINUABLE_WATCHPOINT
|
||||
|
||||
#define STOPPED_BY_WATCHPOINT(W) \
|
||||
go32_stopped_by_watchpoint (inferior_pid)
|
||||
go32_stopped_by_watchpoint (inferior_pid, 0)
|
||||
|
||||
#define target_stopped_data_address() \
|
||||
go32_stopped_by_watchpoint (inferior_pid, 1)
|
||||
|
||||
/* Use these macros for watchpoint insertion/removal. */
|
||||
|
||||
#define target_insert_watchpoint(addr, len, type) \
|
||||
go32_insert_watchpoint (inferior_pid, addr, len, 2)
|
||||
go32_insert_watchpoint (inferior_pid, addr, len, type)
|
||||
|
||||
#define target_remove_watchpoint(addr, len, type) \
|
||||
go32_remove_watchpoint (inferior_pid, addr, len)
|
||||
go32_remove_watchpoint (inferior_pid, addr, len, type)
|
||||
|
||||
#define target_insert_hw_breakpoint(addr, shadow) \
|
||||
go32_insert_hw_breakpoint(addr, shadow)
|
||||
|
|
|
|||
|
|
@ -26,7 +26,7 @@
|
|||
|
||||
#define SLASH_P(X) ((X)=='\\' || (X) == '/')
|
||||
|
||||
#define ROOTED_P(X) ((SLASH_P((X)[0]))|| ((X)[1] ==':'))
|
||||
#define ROOTED_P(X) ((SLASH_P((X)[0])) || ((X)[0] && (X)[1] ==':'))
|
||||
|
||||
#define SLASH_CHAR '/'
|
||||
#define SLASH_STRING "/"
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
# Target: HP PA-RISC 2.0 running HPUX 11.00 in wide mode
|
||||
TDEPFILES= hppa-tdep.o # pa64-solib.o
|
||||
TDEPFILES= hppa-tdep.o
|
||||
TM_FILE= tm-hppa64.h
|
||||
TM_CLIBS= # $(srcdir)/libxpdl.a
|
||||
TM_CLIBS=
|
||||
|
|
|
|||
|
|
@ -0,0 +1,11 @@
|
|||
# Host: Hewlett-Packard PA-RISC machine, running HPUX 11.00
|
||||
|
||||
MH_CFLAGS = -D__HP_CURSES
|
||||
|
||||
XM_FILE= xm-hppah.h
|
||||
XDEPFILES= ser-tcp.o
|
||||
|
||||
NAT_FILE= nm-hppah11.h
|
||||
NATDEPFILES= hppah-nat.o corelow.o core-aout.o inftarg.o fork-child.o infttrace.o somread.o hp-psymtab-read.o hp-symtab-read.o somsolib.o
|
||||
|
||||
HOST_IPC=-DBSD_IPC -DPOSIX_WAIT
|
||||
|
|
@ -0,0 +1,3 @@
|
|||
# Target: HP PA-RISC running HPUX 11.00
|
||||
TDEPFILES= hppa-tdep.o remote-pa.o somsolib.o
|
||||
TM_FILE= tm-hppah.h
|
||||
|
|
@ -0,0 +1,11 @@
|
|||
# Host: Hewlett-Packard PA-RISC machine, running HPUX 11.00
|
||||
|
||||
MH_CFLAGS = -D__HP_CURSES
|
||||
|
||||
XM_FILE= xm-hppah.h
|
||||
XDEPFILES= ser-tcp.o
|
||||
|
||||
NAT_FILE= nm-hppah11.h
|
||||
NATDEPFILES= hppah-nat.o corelow.o core-aout.o inftarg.o fork-child.o infttrace.o hp-psymtab-read.o hp-symtab-read.o pa64solib.o
|
||||
|
||||
HOST_IPC=-DBSD_IPC -DPOSIX_WAIT
|
||||
|
|
@ -0,0 +1,3 @@
|
|||
# Target: HP PA-RISC running HPUX 11.00
|
||||
TDEPFILES= hppa-tdep.o remote-pa.o
|
||||
TM_FILE= tm-hppah.h
|
||||
|
|
@ -565,6 +565,7 @@ extern void hppa_pop_frame PARAMS ((void));
|
|||
|
||||
#define CALL_DUMMY_LENGTH (INSTRUCTION_SIZE * 28)
|
||||
#define REG_PARM_STACK_SPACE 16
|
||||
#define ARGS_GROW_DOWNWARD
|
||||
|
||||
#else /* defined PA_LEVEL_0 */
|
||||
|
||||
|
|
@ -754,18 +755,11 @@ struct obj_unwind_info
|
|||
int last; /* Index of last entry */
|
||||
};
|
||||
|
||||
typedef struct data {
|
||||
CORE_ADDR dummy[2];
|
||||
CORE_ADDR func_addr;
|
||||
CORE_ADDR dp;
|
||||
} opd_data;
|
||||
|
||||
typedef struct obj_private_struct
|
||||
{
|
||||
struct obj_unwind_info *unwind_info; /* a pointer */
|
||||
struct so_list *so_info; /* a pointer */
|
||||
opd_data *opd;
|
||||
int n_opd_entries;
|
||||
CORE_ADDR dp;
|
||||
}
|
||||
obj_private_data_t;
|
||||
|
||||
|
|
|
|||
|
|
@ -152,6 +152,7 @@ extern int hpread_adjust_stack_address PARAMS ((CORE_ADDR));
|
|||
; the right place, we load the first 8 word of arguments into both the general
|
||||
; and fp registers.
|
||||
call_dummy
|
||||
nop
|
||||
copy %r4,%r29
|
||||
copy %r5,%r22
|
||||
copy %r6,%r27
|
||||
|
|
@ -179,17 +180,23 @@ call_dummy
|
|||
nop
|
||||
*/
|
||||
|
||||
/* Call dummys are sized and written out in word sized hunks. So we have
|
||||
to pack the instructions into words. Ugh. */
|
||||
#undef CALL_DUMMY
|
||||
#define CALL_DUMMY {0x349d0000, 0x34b60000, 0x34db0000, \
|
||||
0x53a43f83, 0x53a53f93, 0x53a63fa3, 0x53a73fb3,\
|
||||
0x53a83fc3, 0x53a93fd3, 0x2fa1100a, 0x2fb1100b,\
|
||||
0x36c10000, 0x53ba3f81, 0x53b93f91, 0x53b83fa1,\
|
||||
0x53b73fb1, 0x53b63fc1, 0x53b53fd1, 0x0fa110d4,\
|
||||
0xe820f000, 0x0fb110d3, 0x00010004, 0x00151820,\
|
||||
0xe6c00000, 0x08000240}
|
||||
#define CALL_DUMMY {0x08000240349d0000LL, 0x34b6000034db0000LL, \
|
||||
0x53a43f8353a53f93LL, 0x53a63fa353a73fb3LL,\
|
||||
0x53a83fc353a93fd3LL, 0x2fa1100a2fb1100bLL,\
|
||||
0x36c1000053ba3f81LL, 0x53b93f9153b83fa1LL,\
|
||||
0x53b73fb153b63fc1LL, 0x53b53fd10fa110d4LL,\
|
||||
0xe820f0000fb110d3LL, 0x0001000400151820LL,\
|
||||
0xe6c0000008000240LL}
|
||||
|
||||
/* CALL_DUMMY_LENGTH is computed based on the size of a word on the target
|
||||
machine, not the size of an instruction. Since a word on this target
|
||||
holds two instructions we have to divide the instruction size by two to
|
||||
get the word size of the dummy. */
|
||||
#undef CALL_DUMMY_LENGTH
|
||||
#define CALL_DUMMY_LENGTH (INSTRUCTION_SIZE * 25)
|
||||
#define CALL_DUMMY_LENGTH (INSTRUCTION_SIZE * 26 / 2)
|
||||
|
||||
/* The PA64 ABI mandates a 16 byte stack alignment. */
|
||||
#undef STACK_ALIGN
|
||||
|
|
@ -200,23 +207,15 @@ call_dummy
|
|||
#undef REG_PARM_STACK_SPACE
|
||||
#define REG_PARM_STACK_SPACE 64
|
||||
|
||||
/* Arguments grow in the normal direction for the PA64 port. */
|
||||
#undef ARGS_GROW_DOWNWARD
|
||||
|
||||
#undef FUNC_LDIL_OFFSET
|
||||
#undef FUNC_LDO_OFFSET
|
||||
#undef SR4EXPORT_LDIL_OFFSET
|
||||
#undef SR4EXPORT_LDO_OFFSET
|
||||
#undef CALL_DUMMY_LOCATION
|
||||
|
||||
#define PC_IN_CALL_DUMMY(pc, sp, frame_address) hppa64_pc_in_call_dummy (pc)
|
||||
/* jimb: need to find out what AT_WDB_CALL_DUMMY is about */
|
||||
#if 0
|
||||
#define CALL_DUMMY_LOCATION AFTER_TEXT_END
|
||||
extern CORE_ADDR wdb_call_dummy_addr;
|
||||
#undef PC_IN_CALL_DUMMY
|
||||
#define PC_IN_CALL_DUMMY(pc, sp, frame_address) \
|
||||
((pc) >= wdb_call_dummy_addr && \
|
||||
(pc) <= wdb_call_dummy_addr + CALL_DUMMY_LENGTH)
|
||||
#endif
|
||||
|
||||
#undef REG_STRUCT_HAS_ADDR
|
||||
|
||||
#undef EXTRACT_RETURN_VALUE
|
||||
|
|
|
|||
|
|
@ -42,8 +42,8 @@ arm-*-*) gdb_host=arm ;;
|
|||
hppa*-*-bsd*) gdb_host=hppabsd ;;
|
||||
hppa*-*-hiux*) gdb_host=hppahpux ;;
|
||||
hppa*-*-hpux10.20) gdb_host=hpux1020 ;;
|
||||
hppa2.0w-*-hpux11*) gdb_host=hpux1100w ;;
|
||||
hppa*-*-hpux11*) gdb_host=hpux1100 ;;
|
||||
hppa2.0w-*-hpux11*) gdb_host=hpux11w ;;
|
||||
hppa*-*-hpux11*) gdb_host=hpux11 ;;
|
||||
hppa*-*-hpux*) gdb_host=hppahpux ;;
|
||||
hppa*-*-osf*) gdb_host=hppaosf ;;
|
||||
|
||||
|
|
|
|||
25
gdb/defs.h
25
gdb/defs.h
|
|
@ -574,10 +574,29 @@ extern char *symtab_to_filename PARAMS ((struct symtab *));
|
|||
|
||||
extern int read_relative_register_raw_bytes PARAMS ((int, char *));
|
||||
|
||||
#if __STDC__
|
||||
enum lval_type;
|
||||
/* Possible lvalue types. Like enum language, this should be in
|
||||
value.h, but needs to be here for the same reason. */
|
||||
|
||||
enum lval_type
|
||||
{
|
||||
/* Not an lval. */
|
||||
not_lval,
|
||||
/* In memory. Could be a saved register. */
|
||||
lval_memory,
|
||||
/* In a register. */
|
||||
lval_register,
|
||||
/* In a gdb internal variable. */
|
||||
lval_internalvar,
|
||||
/* Part of a gdb internal variable (structure field). */
|
||||
lval_internalvar_component,
|
||||
/* In a register series in a frame not the current one, which may have been
|
||||
partially saved or saved in different places (otherwise would be
|
||||
lval_register or lval_memory). */
|
||||
lval_reg_frame_relative
|
||||
};
|
||||
|
||||
struct frame_info;
|
||||
#endif
|
||||
|
||||
void default_get_saved_register PARAMS ((char *raw_buffer, int *optimized,
|
||||
CORE_ADDR *addrp,
|
||||
struct frame_info *frame, int regnum,
|
||||
|
|
|
|||
|
|
@ -1,3 +1,21 @@
|
|||
1999-08-20 Stan Shebs <shebs@andros.cygnus.com>
|
||||
|
||||
* gdb.texinfo: Remove remaining "HPPA" conditionals, rewrite
|
||||
surrounding text to fit HP-UX bits into general info.
|
||||
(HPPA-cfg.texi): Remove, no longer useful.
|
||||
|
||||
* gdb.texinfo: Remove explicit links from @node lines, remove
|
||||
HP-added "Detailed Node Listing" from main menu which confuses
|
||||
things.
|
||||
|
||||
From Dmitry Sivachenko <dima@Chg.RU>:
|
||||
* gdb.texinfo: Use @value{GDBN} instead of plain GDB, fix grouping
|
||||
in description of `set environment'.
|
||||
|
||||
1999-08-17 Stan Shebs <shebs@andros.cygnus.com>
|
||||
|
||||
* gdbint.texinfo: Update coding standard to allow pure ANSI/ISO C.
|
||||
|
||||
1999-08-12 Ben Elliston <bje@cygnus.com>
|
||||
|
||||
* gdbint.texinfo (Breakpoint Handling): Add missing words.
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load Diff
|
|
@ -2365,35 +2365,15 @@ are just as hard to understand as a single thousand-line function.
|
|||
|
||||
@subsection Function Prototypes
|
||||
|
||||
Prototypes must be used to @emph{declare} functions but never to
|
||||
Prototypes must be used to @emph{declare} functions, and may be used to
|
||||
@emph{define} them. Prototypes for GDB functions must include both the
|
||||
argument type and name, with the name matching that used in the actual
|
||||
function definition.
|
||||
|
||||
For the sake of compatibility with pre-ANSI compilers, define prototypes
|
||||
with the @code{PARAMS} macro:
|
||||
|
||||
@example @code
|
||||
extern int memory_remove_breakpoint PARAMS ((CORE_ADDR addr,
|
||||
char *contents_cache));
|
||||
@end example
|
||||
|
||||
Note the double parentheses around the parameter types. This allows an
|
||||
arbitrary number of parameters to be described, without freaking out the
|
||||
C preprocessor. When the function has no parameters, it should be
|
||||
described like:
|
||||
|
||||
@example @code
|
||||
extern void noprocess PARAMS ((void));
|
||||
@end example
|
||||
|
||||
The @code{PARAMS} macro expands to its argument in ANSI C, or to a
|
||||
simple @code{()} in traditional C.
|
||||
|
||||
All external functions should have a @code{PARAMS} declaration in a
|
||||
header file that callers include, except for @code{_initialize_*}
|
||||
functions, which must be external so that @file{init.c} construction
|
||||
works, but shouldn't be visible to random source files.
|
||||
All external functions should have a declaration in a header file that
|
||||
callers include, except for @code{_initialize_*} functions, which must
|
||||
be external so that @file{init.c} construction works, but shouldn't be
|
||||
visible to random source files.
|
||||
|
||||
All static functions must be declared in a block near the top of the
|
||||
source file.
|
||||
|
|
|
|||
|
|
@ -247,11 +247,6 @@ extern void generic_fix_call_dummy PARAMS ((char *dummy, CORE_ADDR pc, CORE_ADDR
|
|||
int nargs, struct value ** args,
|
||||
struct type * type, int gcc_p));
|
||||
|
||||
#ifdef __STDC__
|
||||
/* Some native compilers, even ones that are supposed to be ANSI and for which __STDC__
|
||||
is true, complain about forward decls of enums. */
|
||||
enum lval_type;
|
||||
extern void generic_get_saved_register PARAMS ((char *, int *, CORE_ADDR *, struct frame_info *, int, enum lval_type *));
|
||||
#endif
|
||||
|
||||
#endif /* !defined (FRAME_H) */
|
||||
|
|
|
|||
|
|
@ -26,7 +26,6 @@
|
|||
#ifdef __STDC__
|
||||
struct frame_info;
|
||||
struct value;
|
||||
enum lval_type;
|
||||
#endif
|
||||
|
||||
|
||||
|
|
|
|||
756
gdb/go32-nat.c
756
gdb/go32-nat.c
File diff suppressed because it is too large
Load Diff
502
gdb/hppa-tdep.c
502
gdb/hppa-tdep.c
|
|
@ -129,6 +129,7 @@ static void pa_strcat_registers PARAMS ((char *, int, int, GDB_FILE *));
|
|||
static void pa_register_look_aside PARAMS ((char *, int, long *));
|
||||
static void pa_print_fp_reg PARAMS ((int));
|
||||
static void pa_strcat_fp_reg PARAMS ((int, GDB_FILE *, enum precision_type));
|
||||
static void record_text_segment_lowaddr PARAMS ((bfd *, asection *, void *));
|
||||
|
||||
typedef struct
|
||||
{
|
||||
|
|
@ -310,6 +311,20 @@ compare_unwind_entries (arg1, arg2)
|
|||
return 0;
|
||||
}
|
||||
|
||||
static CORE_ADDR low_text_segment_address;
|
||||
|
||||
static void
|
||||
record_text_segment_lowaddr (abfd, section, ignored)
|
||||
bfd *abfd ATTRIBUTE_UNUSED;
|
||||
asection *section;
|
||||
PTR ignored ATTRIBUTE_UNUSED;
|
||||
{
|
||||
if ((section->flags & (SEC_ALLOC | SEC_LOAD | SEC_READONLY)
|
||||
== (SEC_ALLOC | SEC_LOAD | SEC_READONLY))
|
||||
&& section->vma < low_text_segment_address)
|
||||
low_text_segment_address = section->vma;
|
||||
}
|
||||
|
||||
static void
|
||||
internalize_unwinds (objfile, table, section, entries, size, text_offset)
|
||||
struct objfile *objfile;
|
||||
|
|
@ -326,6 +341,22 @@ internalize_unwinds (objfile, table, section, entries, size, text_offset)
|
|||
unsigned i;
|
||||
char *buf = alloca (size);
|
||||
|
||||
low_text_segment_address = -1;
|
||||
|
||||
/* If addresses are 64 bits wide, then unwinds are supposed to
|
||||
be segment relative offsets instead of absolute addresses. */
|
||||
if (TARGET_PTR_BIT == 64)
|
||||
{
|
||||
bfd_map_over_sections (objfile->obfd,
|
||||
record_text_segment_lowaddr, (PTR) NULL);
|
||||
|
||||
/* ?!? Mask off some low bits. Should this instead subtract
|
||||
out the lowest section's filepos or something like that?
|
||||
This looks very hokey to me. */
|
||||
low_text_segment_address &= ~0xfff;
|
||||
text_offset += low_text_segment_address;
|
||||
}
|
||||
|
||||
bfd_get_section_contents (objfile->obfd, section, buf, 0, size);
|
||||
|
||||
/* Now internalize the information being careful to handle host/target
|
||||
|
|
@ -510,6 +541,7 @@ read_unwind_info (objfile)
|
|||
sizeof (obj_private_data_t));
|
||||
obj_private->unwind_info = NULL;
|
||||
obj_private->so_info = NULL;
|
||||
obj_private->dp = 0;
|
||||
|
||||
objfile->obj_private = (PTR) obj_private;
|
||||
}
|
||||
|
|
@ -764,7 +796,7 @@ rp_saved (pc)
|
|||
}
|
||||
|
||||
if (u->Save_RP)
|
||||
return -20;
|
||||
return (TARGET_PTR_BIT == 64 ? -16 : -20);
|
||||
else if (u->stub_unwind.stub_type != 0)
|
||||
{
|
||||
switch (u->stub_unwind.stub_type)
|
||||
|
|
@ -831,7 +863,8 @@ hppa_frame_saved_pc (frame)
|
|||
are saved in the exact same order as GDB numbers registers. How
|
||||
convienent. */
|
||||
if (pc_in_interrupt_handler (pc))
|
||||
return read_memory_integer (frame->frame + PC_REGNUM * 4, 4) & ~0x3;
|
||||
return read_memory_integer (frame->frame + PC_REGNUM * 4,
|
||||
TARGET_PTR_BIT / 8) & ~0x3;
|
||||
|
||||
#ifdef FRAME_SAVED_PC_IN_SIGTRAMP
|
||||
/* Deal with signal handler caller frames too. */
|
||||
|
|
@ -860,19 +893,23 @@ hppa_frame_saved_pc (frame)
|
|||
struct frame_saved_regs saved_regs;
|
||||
|
||||
get_frame_saved_regs (frame->next, &saved_regs);
|
||||
if (read_memory_integer (saved_regs.regs[FLAGS_REGNUM], 4) & 0x2)
|
||||
if (read_memory_integer (saved_regs.regs[FLAGS_REGNUM],
|
||||
TARGET_PTR_BIT / 8) & 0x2)
|
||||
{
|
||||
pc = read_memory_integer (saved_regs.regs[31], 4) & ~0x3;
|
||||
pc = read_memory_integer (saved_regs.regs[31],
|
||||
TARGET_PTR_BIT / 8) & ~0x3;
|
||||
|
||||
/* Syscalls are really two frames. The syscall stub itself
|
||||
with a return pointer in %rp and the kernel call with
|
||||
a return pointer in %r31. We return the %rp variant
|
||||
if %r31 is the same as frame->pc. */
|
||||
if (pc == frame->pc)
|
||||
pc = read_memory_integer (saved_regs.regs[RP_REGNUM], 4) & ~0x3;
|
||||
pc = read_memory_integer (saved_regs.regs[RP_REGNUM],
|
||||
TARGET_PTR_BIT / 8) & ~0x3;
|
||||
}
|
||||
else
|
||||
pc = read_memory_integer (saved_regs.regs[RP_REGNUM], 4) & ~0x3;
|
||||
pc = read_memory_integer (saved_regs.regs[RP_REGNUM],
|
||||
TARGET_PTR_BIT / 8) & ~0x3;
|
||||
}
|
||||
else
|
||||
pc = read_register (ret_regnum) & ~0x3;
|
||||
|
|
@ -896,19 +933,23 @@ hppa_frame_saved_pc (frame)
|
|||
struct frame_saved_regs saved_regs;
|
||||
|
||||
get_frame_saved_regs (frame->next, &saved_regs);
|
||||
if (read_memory_integer (saved_regs.regs[FLAGS_REGNUM], 4) & 0x2)
|
||||
if (read_memory_integer (saved_regs.regs[FLAGS_REGNUM],
|
||||
TARGET_PTR_BIT / 8) & 0x2)
|
||||
{
|
||||
pc = read_memory_integer (saved_regs.regs[31], 4) & ~0x3;
|
||||
pc = read_memory_integer (saved_regs.regs[31],
|
||||
TARGET_PTR_BIT / 8) & ~0x3;
|
||||
|
||||
/* Syscalls are really two frames. The syscall stub itself
|
||||
with a return pointer in %rp and the kernel call with
|
||||
a return pointer in %r31. We return the %rp variant
|
||||
if %r31 is the same as frame->pc. */
|
||||
if (pc == frame->pc)
|
||||
pc = read_memory_integer (saved_regs.regs[RP_REGNUM], 4) & ~0x3;
|
||||
pc = read_memory_integer (saved_regs.regs[RP_REGNUM],
|
||||
TARGET_PTR_BIT / 8) & ~0x3;
|
||||
}
|
||||
else
|
||||
pc = read_memory_integer (saved_regs.regs[RP_REGNUM], 4) & ~0x3;
|
||||
pc = read_memory_integer (saved_regs.regs[RP_REGNUM],
|
||||
TARGET_PTR_BIT / 8) & ~0x3;
|
||||
}
|
||||
else if (rp_offset == 0)
|
||||
{
|
||||
|
|
@ -918,7 +959,8 @@ hppa_frame_saved_pc (frame)
|
|||
else
|
||||
{
|
||||
old_pc = pc;
|
||||
pc = read_memory_integer (frame->frame + rp_offset, 4) & ~0x3;
|
||||
pc = read_memory_integer (frame->frame + rp_offset,
|
||||
TARGET_PTR_BIT / 8) & ~0x3;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -1073,7 +1115,8 @@ frame_chain (frame)
|
|||
pull the old stack pointer from. Also see frame_saved_pc for
|
||||
code to dig a saved PC out of the save state structure. */
|
||||
if (pc_in_interrupt_handler (frame->pc))
|
||||
frame_base = read_memory_integer (frame->frame + SP_REGNUM * 4, 4);
|
||||
frame_base = read_memory_integer (frame->frame + SP_REGNUM * 4,
|
||||
TARGET_PTR_BIT / 8);
|
||||
#ifdef FRAME_BASE_BEFORE_SIGTRAMP
|
||||
else if (frame->signal_handler_caller)
|
||||
{
|
||||
|
|
@ -1107,7 +1150,7 @@ frame_chain (frame)
|
|||
The previous frame pointer is found at the top of the current frame. */
|
||||
if (caller_framesize == -1 && my_framesize == -1)
|
||||
{
|
||||
return read_memory_integer (frame_base, 4);
|
||||
return read_memory_integer (frame_base, TARGET_PTR_BIT / 8);
|
||||
}
|
||||
/* Caller has a frame pointer, but callee does not. This is a little
|
||||
more difficult as GCC and HP C lay out locals and callee register save
|
||||
|
|
@ -1164,7 +1207,7 @@ frame_chain (frame)
|
|||
&& !tmp_frame->signal_handler_caller
|
||||
&& !pc_in_interrupt_handler (tmp_frame->pc))
|
||||
{
|
||||
return read_memory_integer (tmp_frame->frame, 4);
|
||||
return read_memory_integer (tmp_frame->frame, TARGET_PTR_BIT / 8);
|
||||
}
|
||||
/* %r3 was saved somewhere in the stack. Dig it out. */
|
||||
else
|
||||
|
|
@ -1202,7 +1245,8 @@ frame_chain (frame)
|
|||
/* Abominable hack. */
|
||||
if (current_target.to_has_execution == 0
|
||||
&& ((saved_regs.regs[FLAGS_REGNUM]
|
||||
&& (read_memory_integer (saved_regs.regs[FLAGS_REGNUM], 4)
|
||||
&& (read_memory_integer (saved_regs.regs[FLAGS_REGNUM],
|
||||
TARGET_PTR_BIT / 8)
|
||||
& 0x2))
|
||||
|| (saved_regs.regs[FLAGS_REGNUM] == 0
|
||||
&& read_register (FLAGS_REGNUM) & 0x2)))
|
||||
|
|
@ -1210,7 +1254,8 @@ frame_chain (frame)
|
|||
u = find_unwind_entry (FRAME_SAVED_PC (frame));
|
||||
if (!u)
|
||||
{
|
||||
return read_memory_integer (saved_regs.regs[FP_REGNUM], 4);
|
||||
return read_memory_integer (saved_regs.regs[FP_REGNUM],
|
||||
TARGET_PTR_BIT / 8);
|
||||
}
|
||||
else
|
||||
{
|
||||
|
|
@ -1218,7 +1263,8 @@ frame_chain (frame)
|
|||
}
|
||||
}
|
||||
|
||||
return read_memory_integer (saved_regs.regs[FP_REGNUM], 4);
|
||||
return read_memory_integer (saved_regs.regs[FP_REGNUM],
|
||||
TARGET_PTR_BIT / 8);
|
||||
}
|
||||
}
|
||||
else
|
||||
|
|
@ -1234,7 +1280,8 @@ frame_chain (frame)
|
|||
/* Abominable hack. See above. */
|
||||
if (current_target.to_has_execution == 0
|
||||
&& ((saved_regs.regs[FLAGS_REGNUM]
|
||||
&& (read_memory_integer (saved_regs.regs[FLAGS_REGNUM], 4)
|
||||
&& (read_memory_integer (saved_regs.regs[FLAGS_REGNUM],
|
||||
TARGET_PTR_BIT / 8)
|
||||
& 0x2))
|
||||
|| (saved_regs.regs[FLAGS_REGNUM] == 0
|
||||
&& read_register (FLAGS_REGNUM) & 0x2)))
|
||||
|
|
@ -1242,7 +1289,8 @@ frame_chain (frame)
|
|||
u = find_unwind_entry (FRAME_SAVED_PC (frame));
|
||||
if (!u)
|
||||
{
|
||||
return read_memory_integer (saved_regs.regs[FP_REGNUM], 4);
|
||||
return read_memory_integer (saved_regs.regs[FP_REGNUM],
|
||||
TARGET_PTR_BIT / 8);
|
||||
}
|
||||
else
|
||||
{
|
||||
|
|
@ -1329,7 +1377,7 @@ push_dummy_frame (inf_status)
|
|||
{
|
||||
CORE_ADDR sp, pc, pcspace;
|
||||
register int regnum;
|
||||
int int_buffer;
|
||||
CORE_ADDR int_buffer;
|
||||
double freg_buffer;
|
||||
|
||||
/* Oh, what a hack. If we're trying to perform an inferior call
|
||||
|
|
@ -1364,20 +1412,28 @@ push_dummy_frame (inf_status)
|
|||
/* Space for "arguments"; the RP goes in here. */
|
||||
sp = read_register (SP_REGNUM) + 48;
|
||||
int_buffer = read_register (RP_REGNUM) | 0x3;
|
||||
write_memory (sp - 20, (char *) &int_buffer, 4);
|
||||
|
||||
/* The 32bit and 64bit ABIs save the return pointer into different
|
||||
stack slots. */
|
||||
if (REGISTER_SIZE == 8)
|
||||
write_memory (sp - 16, (char *) &int_buffer, REGISTER_SIZE);
|
||||
else
|
||||
write_memory (sp - 20, (char *) &int_buffer, REGISTER_SIZE);
|
||||
|
||||
int_buffer = TARGET_READ_FP ();
|
||||
write_memory (sp, (char *) &int_buffer, 4);
|
||||
write_memory (sp, (char *) &int_buffer, REGISTER_SIZE);
|
||||
|
||||
write_register (FP_REGNUM, sp);
|
||||
|
||||
sp += 8;
|
||||
sp += 2 * REGISTER_SIZE;
|
||||
|
||||
for (regnum = 1; regnum < 32; regnum++)
|
||||
if (regnum != RP_REGNUM && regnum != FP_REGNUM)
|
||||
sp = push_word (sp, read_register (regnum));
|
||||
|
||||
sp += 4;
|
||||
/* This is not necessary for the 64bit ABI. In fact it is dangerous. */
|
||||
if (REGISTER_SIZE != 8)
|
||||
sp += 4;
|
||||
|
||||
for (regnum = FP0_REGNUM; regnum < NUM_REGS; regnum++)
|
||||
{
|
||||
|
|
@ -1401,29 +1457,38 @@ find_dummy_frame_regs (frame, frame_saved_regs)
|
|||
CORE_ADDR fp = frame->frame;
|
||||
int i;
|
||||
|
||||
frame_saved_regs->regs[RP_REGNUM] = (fp - 20) & ~0x3;
|
||||
frame_saved_regs->regs[FP_REGNUM] = fp;
|
||||
frame_saved_regs->regs[1] = fp + 8;
|
||||
/* The 32bit and 64bit ABIs save RP into different locations. */
|
||||
if (REGISTER_SIZE == 8)
|
||||
frame_saved_regs->regs[RP_REGNUM] = (fp - 16) & ~0x3;
|
||||
else
|
||||
frame_saved_regs->regs[RP_REGNUM] = (fp - 20) & ~0x3;
|
||||
|
||||
for (fp += 12, i = 3; i < 32; i++)
|
||||
frame_saved_regs->regs[FP_REGNUM] = fp;
|
||||
|
||||
frame_saved_regs->regs[1] = fp + (2 * REGISTER_SIZE);
|
||||
|
||||
for (fp += 3 * REGISTER_SIZE, i = 3; i < 32; i++)
|
||||
{
|
||||
if (i != FP_REGNUM)
|
||||
{
|
||||
frame_saved_regs->regs[i] = fp;
|
||||
fp += 4;
|
||||
fp += REGISTER_SIZE;
|
||||
}
|
||||
}
|
||||
|
||||
fp += 4;
|
||||
/* This is not necessary or desirable for the 64bit ABI. */
|
||||
if (REGISTER_SIZE != 8)
|
||||
fp += 4;
|
||||
|
||||
for (i = FP0_REGNUM; i < NUM_REGS; i++, fp += 8)
|
||||
frame_saved_regs->regs[i] = fp;
|
||||
|
||||
frame_saved_regs->regs[IPSW_REGNUM] = fp;
|
||||
frame_saved_regs->regs[SAR_REGNUM] = fp + 4;
|
||||
frame_saved_regs->regs[PCOQ_HEAD_REGNUM] = fp + 8;
|
||||
frame_saved_regs->regs[PCSQ_HEAD_REGNUM] = fp + 12;
|
||||
frame_saved_regs->regs[PCOQ_TAIL_REGNUM] = fp + 16;
|
||||
frame_saved_regs->regs[PCSQ_TAIL_REGNUM] = fp + 20;
|
||||
frame_saved_regs->regs[SAR_REGNUM] = fp + REGISTER_SIZE;
|
||||
frame_saved_regs->regs[PCOQ_HEAD_REGNUM] = fp + 2 * REGISTER_SIZE;
|
||||
frame_saved_regs->regs[PCSQ_HEAD_REGNUM] = fp + 3 * REGISTER_SIZE;
|
||||
frame_saved_regs->regs[PCOQ_TAIL_REGNUM] = fp + 4 * REGISTER_SIZE;
|
||||
frame_saved_regs->regs[PCSQ_TAIL_REGNUM] = fp + 5 * REGISTER_SIZE;
|
||||
}
|
||||
|
||||
void
|
||||
|
|
@ -1445,7 +1510,8 @@ hppa_pop_frame ()
|
|||
|
||||
for (regnum = 31; regnum > 0; regnum--)
|
||||
if (fsr.regs[regnum])
|
||||
write_register (regnum, read_memory_integer (fsr.regs[regnum], 4));
|
||||
write_register (regnum, read_memory_integer (fsr.regs[regnum],
|
||||
REGISTER_SIZE));
|
||||
|
||||
for (regnum = NUM_REGS - 1; regnum >= FP0_REGNUM; regnum--)
|
||||
if (fsr.regs[regnum])
|
||||
|
|
@ -1456,16 +1522,19 @@ hppa_pop_frame ()
|
|||
|
||||
if (fsr.regs[IPSW_REGNUM])
|
||||
write_register (IPSW_REGNUM,
|
||||
read_memory_integer (fsr.regs[IPSW_REGNUM], 4));
|
||||
read_memory_integer (fsr.regs[IPSW_REGNUM],
|
||||
REGISTER_SIZE));
|
||||
|
||||
if (fsr.regs[SAR_REGNUM])
|
||||
write_register (SAR_REGNUM,
|
||||
read_memory_integer (fsr.regs[SAR_REGNUM], 4));
|
||||
read_memory_integer (fsr.regs[SAR_REGNUM],
|
||||
REGISTER_SIZE));
|
||||
|
||||
/* If the PC was explicitly saved, then just restore it. */
|
||||
if (fsr.regs[PCOQ_TAIL_REGNUM])
|
||||
{
|
||||
npc = read_memory_integer (fsr.regs[PCOQ_TAIL_REGNUM], 4);
|
||||
npc = read_memory_integer (fsr.regs[PCOQ_TAIL_REGNUM],
|
||||
REGISTER_SIZE);
|
||||
write_register (PCOQ_TAIL_REGNUM, npc);
|
||||
}
|
||||
/* Else use the value in %rp to set the new PC. */
|
||||
|
|
@ -1475,7 +1544,7 @@ hppa_pop_frame ()
|
|||
write_pc (npc);
|
||||
}
|
||||
|
||||
write_register (FP_REGNUM, read_memory_integer (fp, 4));
|
||||
write_register (FP_REGNUM, read_memory_integer (fp, REGISTER_SIZE));
|
||||
|
||||
if (fsr.regs[IPSW_REGNUM]) /* call dummy */
|
||||
write_register (SP_REGNUM, fp - 48);
|
||||
|
|
@ -1525,7 +1594,8 @@ restore_pc_queue (fsr)
|
|||
struct frame_saved_regs *fsr;
|
||||
{
|
||||
CORE_ADDR pc = read_pc ();
|
||||
CORE_ADDR new_pc = read_memory_integer (fsr->regs[PCOQ_HEAD_REGNUM], 4);
|
||||
CORE_ADDR new_pc = read_memory_integer (fsr->regs[PCOQ_HEAD_REGNUM],
|
||||
TARGET_PTR_BIT / 8);
|
||||
struct target_waitstatus w;
|
||||
int insn_count;
|
||||
|
||||
|
|
@ -1543,7 +1613,8 @@ restore_pc_queue (fsr)
|
|||
So, load up the registers and single step until we are in the
|
||||
right place. */
|
||||
|
||||
write_register (21, read_memory_integer (fsr->regs[PCSQ_HEAD_REGNUM], 4));
|
||||
write_register (21, read_memory_integer (fsr->regs[PCSQ_HEAD_REGNUM],
|
||||
REGISTER_SIZE));
|
||||
write_register (22, new_pc);
|
||||
|
||||
for (insn_count = 0; insn_count < 3; insn_count++)
|
||||
|
|
@ -1572,7 +1643,20 @@ restore_pc_queue (fsr)
|
|||
return 1;
|
||||
}
|
||||
|
||||
#if 0
|
||||
/* This function pushes a stack frame with arguments as part of the
|
||||
inferior function calling mechanism.
|
||||
|
||||
For PAs the stack always grows to higher addresses. However the arguments
|
||||
may grow to either higher or lower addresses depending on which ABI is
|
||||
currently in use.
|
||||
|
||||
We simply allocate the appropriate amount of stack space and put
|
||||
arguments into their proper slots. The call dummy code will copy
|
||||
arguments into registers as needed by the ABI.
|
||||
|
||||
Note for the PA64 ABI we load up the argument pointer since the caller
|
||||
must provide the argument pointer to the callee. */
|
||||
|
||||
CORE_ADDR
|
||||
hppa_push_arguments (nargs, args, sp, struct_return, struct_addr)
|
||||
int nargs;
|
||||
|
|
@ -1583,115 +1667,66 @@ hppa_push_arguments (nargs, args, sp, struct_return, struct_addr)
|
|||
{
|
||||
/* array of arguments' offsets */
|
||||
int *offset = (int *) alloca (nargs * sizeof (int));
|
||||
int cum = 0;
|
||||
int i, alignment;
|
||||
|
||||
for (i = 0; i < nargs; i++)
|
||||
{
|
||||
int x = 0;
|
||||
/* cum is the sum of the lengths in bytes of
|
||||
the arguments seen so far */
|
||||
cum += TYPE_LENGTH (VALUE_TYPE (args[i]));
|
||||
|
||||
/* value must go at proper alignment. Assume alignment is a
|
||||
power of two. */
|
||||
alignment = hppa_alignof (VALUE_TYPE (args[i]));
|
||||
|
||||
if (cum % alignment)
|
||||
cum = (cum + alignment) & -alignment;
|
||||
offset[i] = -cum;
|
||||
|
||||
}
|
||||
sp += max ((cum + 7) & -8, 16);
|
||||
|
||||
for (i = 0; i < nargs; i++)
|
||||
write_memory (sp + offset[i], VALUE_CONTENTS (args[i]),
|
||||
TYPE_LENGTH (VALUE_TYPE (args[i])));
|
||||
|
||||
if (struct_return)
|
||||
write_register (28, struct_addr);
|
||||
return sp + 32;
|
||||
}
|
||||
#endif
|
||||
|
||||
/* elz: I am rewriting this function, because the one above is a very
|
||||
obscure piece of code.
|
||||
This function pushes the arguments on the stack. The stack grows up
|
||||
on the PA.
|
||||
Each argument goes in one (or more) word (4 bytes) on the stack.
|
||||
The first four words for the args must be allocated, even if they
|
||||
are not used.
|
||||
The 'topmost' arg is arg0, the 'bottom-most' is arg3. (if you think of
|
||||
them as 1 word long).
|
||||
Below these there can be any number of arguments, as needed by the function.
|
||||
If an arg is bigger than one word, it will be written on the stack
|
||||
occupying as many words as needed. Args that are bigger than 64bits
|
||||
are not copied on the stack, a pointer is passed instead.
|
||||
|
||||
On top of the arg0 word there are other 8 words (32bytes) which are used
|
||||
for other purposes */
|
||||
|
||||
CORE_ADDR
|
||||
hppa_push_arguments (nargs, args, sp, struct_return, struct_addr)
|
||||
int nargs;
|
||||
value_ptr *args;
|
||||
CORE_ADDR sp;
|
||||
int struct_return;
|
||||
CORE_ADDR struct_addr;
|
||||
{
|
||||
/* array of arguments' offsets */
|
||||
int *offset = (int *) alloca (nargs * sizeof (int));
|
||||
/* array of arguments' lengths: real lengths in bytes, not aligned to word size */
|
||||
/* array of arguments' lengths: real lengths in bytes, not aligned to
|
||||
word size */
|
||||
int *lengths = (int *) alloca (nargs * sizeof (int));
|
||||
|
||||
int bytes_reserved; /* this is the number of bytes on the stack occupied by an
|
||||
argument. This will be always a multiple of 4 */
|
||||
/* The value of SP as it was passed into this function after
|
||||
aligning. */
|
||||
CORE_ADDR orig_sp = STACK_ALIGN (sp);
|
||||
|
||||
int cum_bytes_reserved = 0; /* this is the total number of bytes reserved by the args
|
||||
seen so far. It is a multiple of 4 always */
|
||||
int cum_bytes_aligned = 0; /* same as above, but aligned on 8 bytes */
|
||||
/* The number of stack bytes occupied by the current argument. */
|
||||
int bytes_reserved;
|
||||
|
||||
/* The total number of bytes reserved for the arguments. */
|
||||
int cum_bytes_reserved = 0;
|
||||
|
||||
/* Similarly, but aligned. */
|
||||
int cum_bytes_aligned = 0;
|
||||
int i;
|
||||
|
||||
/* When an arg does not occupy a whole word, for instance in bitfields:
|
||||
if the arg is x bits (0<x<32), it must be written
|
||||
starting from the (x-1)-th position down until the 0-th position.
|
||||
It is enough to align it to the word. */
|
||||
/* if an arg occupies 8 bytes, it must be aligned on the 64-bits
|
||||
high order word in odd arg word. */
|
||||
/* if an arg is larger than 64 bits, we need to pass a pointer to it, and
|
||||
copy the actual value on the stack, so that the callee can play with it.
|
||||
This is taken care of in valops.c in the call_function_by_hand function.
|
||||
The argument that is received in this function here has already be converted
|
||||
to a pointer to whatever is needed, so that it just can be pushed
|
||||
as a word argument */
|
||||
|
||||
/* Iterate over each argument provided by the user. */
|
||||
for (i = 0; i < nargs; i++)
|
||||
{
|
||||
|
||||
lengths[i] = TYPE_LENGTH (VALUE_TYPE (args[i]));
|
||||
|
||||
if (lengths[i] % 4)
|
||||
bytes_reserved = (lengths[i] / 4) * 4 + 4;
|
||||
else
|
||||
bytes_reserved = lengths[i];
|
||||
/* Align the size of the argument to the word size for this
|
||||
target. */
|
||||
bytes_reserved = (lengths[i] + REGISTER_SIZE - 1) & -REGISTER_SIZE;
|
||||
|
||||
#ifdef ARGS_GROW_DOWNWARD
|
||||
offset[i] = cum_bytes_reserved + lengths[i];
|
||||
#else
|
||||
/* If the arguments grow towards lower addresses, then we want
|
||||
offset[i] to point to the start of the argument rather than
|
||||
the end of the argument. */
|
||||
offset[i] = cum_bytes_reserved;
|
||||
|
||||
if ((bytes_reserved == 8) && (offset[i] % 8)) /* if 64-bit arg is not 64 bit aligned */
|
||||
offset[i] += (lengths[i] < REGISTER_SIZE
|
||||
? REGISTER_SIZE - lengths[i] : 0);
|
||||
#endif
|
||||
|
||||
/* If the argument is a double word argument, then it needs to be
|
||||
double word aligned.
|
||||
|
||||
?!? I do not think this code is correct when !ARGS_GROW_DOWNWAR. */
|
||||
if ((bytes_reserved == 2 * REGISTER_SIZE)
|
||||
&& (offset[i] % 2 * REGISTER_SIZE))
|
||||
{
|
||||
int new_offset = 0;
|
||||
/* bytes_reserved is already aligned to the word, so we put it at one word
|
||||
more down the stack. This will leave one empty word on the
|
||||
stack, and one unused register. This is OK, see the calling
|
||||
convention doc */
|
||||
/* the offset may have to be moved to the corresponding position
|
||||
one word down the stack, to maintain
|
||||
alignment. */
|
||||
new_offset = (offset[i] / 8) * 8 + 8;
|
||||
if ((new_offset - offset[i]) >= 4)
|
||||
/* BYTES_RESERVED is already aligned to the word, so we put
|
||||
the argument at one word more down the stack.
|
||||
|
||||
This will leave one empty word on the stack, and one unused
|
||||
register as mandated by the ABI. */
|
||||
new_offset = ((offset[i] + 2 * REGISTER_SIZE - 1)
|
||||
& -(2 * REGISTER_SIZE));
|
||||
|
||||
if ((new_offset - offset[i]) >= 2 * REGISTER_SIZE)
|
||||
{
|
||||
bytes_reserved += 4;
|
||||
offset[i] += 4;
|
||||
bytes_reserved += REGISTER_SIZE;
|
||||
offset[i] += REGISTER_SIZE;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -1699,22 +1734,52 @@ hppa_push_arguments (nargs, args, sp, struct_return, struct_addr)
|
|||
|
||||
}
|
||||
|
||||
/* now move up the sp to reserve at least 4 words required for the args,
|
||||
or more than this if needed */
|
||||
/* wee also need to keep the sp aligned to 8 bytes */
|
||||
cum_bytes_aligned = STACK_ALIGN (cum_bytes_reserved);
|
||||
sp += max (cum_bytes_aligned, 16);
|
||||
/* CUM_BYTES_RESERVED already accounts for all the arguments
|
||||
passed by the user. However, the ABIs mandate minimum stack space
|
||||
allocations for outgoing arguments.
|
||||
|
||||
/* now write each of the args at the proper offset down the stack */
|
||||
The ABIs also mandate minimum stack alignments which we must
|
||||
preserve. */
|
||||
cum_bytes_aligned = STACK_ALIGN (cum_bytes_reserved);
|
||||
sp += max (cum_bytes_aligned, REG_PARM_STACK_SPACE);
|
||||
|
||||
/* Now write each of the args at the proper offset down the stack.
|
||||
|
||||
The two ABIs write arguments in different directions using different
|
||||
starting points. What fun.
|
||||
|
||||
?!? We need to promote values to a full register instead of skipping
|
||||
words in the stack. */
|
||||
#ifndef ARGS_GROW_DOWNWARD
|
||||
for (i = 0; i < nargs; i++)
|
||||
write_memory (orig_sp + offset[i], VALUE_CONTENTS (args[i]), lengths[i]);
|
||||
#else
|
||||
for (i = 0; i < nargs; i++)
|
||||
write_memory (sp - offset[i], VALUE_CONTENTS (args[i]), lengths[i]);
|
||||
#endif
|
||||
|
||||
|
||||
/* if a structure has to be returned, set up register 28 to hold its address */
|
||||
/* If a structure has to be returned, set up register 28 to hold its
|
||||
address */
|
||||
if (struct_return)
|
||||
write_register (28, struct_addr);
|
||||
|
||||
/* the stack will have other 8 words on top of the args */
|
||||
#ifndef ARGS_GROW_DOWNWARD
|
||||
/* For the PA64 we must pass a pointer to the outgoing argument list.
|
||||
The ABI mandates that the pointer should point to the first byte of
|
||||
storage beyond the register flushback area.
|
||||
|
||||
However, the call dummy expects the outgoing argument pointer to
|
||||
be passed in register %r4. */
|
||||
write_register (4, orig_sp + REG_PARM_STACK_SPACE);
|
||||
|
||||
/* ?!? This needs further work. We need to set up the global data
|
||||
pointer for this procedure. This assumes the same global pointer
|
||||
for every procedure. The call dummy expects the dp value to
|
||||
be passed in register %r6. */
|
||||
write_register (6, read_register (27));
|
||||
#endif
|
||||
|
||||
/* The stack will have 32 bytes of additional space for a frame marker. */
|
||||
return sp + 32;
|
||||
}
|
||||
|
||||
|
|
@ -1889,6 +1954,103 @@ hppa_fix_call_dummy (dummy, pc, fun, nargs, args, type, gcc_p)
|
|||
use a PLABEL instead of an import stub. */
|
||||
int using_gcc_plt_call = 1;
|
||||
|
||||
#ifdef GDB_TARGET_IS_HPPA_20W
|
||||
/* We currently use completely different code for the PA2.0W inferior
|
||||
function call sequences. This needs to be cleaned up. */
|
||||
{
|
||||
CORE_ADDR pcsqh, pcsqt, pcoqh, pcoqt, sr5;
|
||||
struct target_waitstatus w;
|
||||
int inst1, inst2;
|
||||
char buf[4];
|
||||
int status;
|
||||
struct objfile *objfile;
|
||||
|
||||
/* We can not modify the PC space queues directly, so we start
|
||||
up the inferior and execute a couple instructions to set the
|
||||
space queues so that they point to the call dummy in the stack. */
|
||||
pcsqh = read_register (PCSQ_HEAD_REGNUM);
|
||||
sr5 = read_register (SR5_REGNUM);
|
||||
if (1)
|
||||
{
|
||||
pcoqh = read_register (PCOQ_HEAD_REGNUM);
|
||||
pcoqt = read_register (PCOQ_TAIL_REGNUM);
|
||||
if (target_read_memory (pcoqh, buf, 4) != 0)
|
||||
error ("Couldn't modify space queue\n");
|
||||
inst1 = extract_unsigned_integer (buf, 4);
|
||||
|
||||
if (target_read_memory (pcoqt, buf, 4) != 0)
|
||||
error ("Couldn't modify space queue\n");
|
||||
inst2 = extract_unsigned_integer (buf, 4);
|
||||
|
||||
/* BVE (r1) */
|
||||
*((int *) buf) = 0xe820d000;
|
||||
if (target_write_memory (pcoqh, buf, 4) != 0)
|
||||
error ("Couldn't modify space queue\n");
|
||||
|
||||
/* NOP */
|
||||
*((int *) buf) = 0x08000240;
|
||||
if (target_write_memory (pcoqt, buf, 4) != 0)
|
||||
{
|
||||
*((int *) buf) = inst1;
|
||||
target_write_memory (pcoqh, buf, 4);
|
||||
error ("Couldn't modify space queue\n");
|
||||
}
|
||||
|
||||
write_register (1, pc);
|
||||
|
||||
/* Single step twice, the BVE instruction will set the space queue
|
||||
such that it points to the PC value written immediately above
|
||||
(ie the call dummy). */
|
||||
resume (1, 0);
|
||||
target_wait (inferior_pid, &w);
|
||||
resume (1, 0);
|
||||
target_wait (inferior_pid, &w);
|
||||
|
||||
/* Restore the two instructions at the old PC locations. */
|
||||
*((int *) buf) = inst1;
|
||||
target_write_memory (pcoqh, buf, 4);
|
||||
*((int *) buf) = inst2;
|
||||
target_write_memory (pcoqt, buf, 4);
|
||||
}
|
||||
|
||||
/* The call dummy wants the ultimate destination address initially
|
||||
in register %r5. */
|
||||
write_register (5, fun);
|
||||
|
||||
/* We need to see if this objfile has a different DP value than our
|
||||
own (it could be a shared library for example. */
|
||||
ALL_OBJFILES (objfile)
|
||||
{
|
||||
struct obj_section *s;
|
||||
obj_private_data_t *obj_private;
|
||||
|
||||
/* See if FUN is in any section within this shared library. */
|
||||
for (s = objfile->sections; s < objfile->sections_end; s++)
|
||||
if (s->addr <= fun && fun < s->endaddr)
|
||||
break;
|
||||
|
||||
if (s >= objfile->sections_end)
|
||||
continue;
|
||||
|
||||
obj_private = (obj_private_data_t *) objfile->obj_private;
|
||||
|
||||
/* The DP value may be different for each objfile. But within an
|
||||
objfile each function uses the same dp value. Thus we do not need
|
||||
to grope around the opd section looking for dp values.
|
||||
|
||||
?!? This is not strictly correct since we may be in a shared library
|
||||
and want to call back into the main program. To make that case
|
||||
work correctly we need to set obj_private->dp for the main program's
|
||||
objfile, then remove this conditional. */
|
||||
if (obj_private->dp)
|
||||
write_register (27, obj_private->dp);
|
||||
break;
|
||||
}
|
||||
return pc;
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifndef GDB_TARGET_IS_HPPA_20W
|
||||
/* Prefer __gcc_plt_call over the HP supplied routine because
|
||||
__gcc_plt_call works for any number of arguments. */
|
||||
trampoline = NULL;
|
||||
|
|
@ -1909,11 +2071,13 @@ hppa_fix_call_dummy (dummy, pc, fun, nargs, args, type, gcc_p)
|
|||
/* Get the GOT/DP value for the target function. It's
|
||||
at *(fun+4). Note the call dummy is *NOT* allowed to
|
||||
trash %r19 before calling the target function. */
|
||||
write_register (19, read_memory_integer ((fun & ~0x3) + 4, 4));
|
||||
write_register (19, read_memory_integer ((fun & ~0x3) + 4,
|
||||
REGISTER_SIZE));
|
||||
|
||||
/* Now get the real address for the function we are calling, it's
|
||||
at *fun. */
|
||||
fun = (CORE_ADDR) read_memory_integer (fun & ~0x3, 4);
|
||||
fun = (CORE_ADDR) read_memory_integer (fun & ~0x3,
|
||||
TARGET_PTR_BIT / 8);
|
||||
}
|
||||
else
|
||||
{
|
||||
|
|
@ -2044,7 +2208,6 @@ hppa_fix_call_dummy (dummy, pc, fun, nargs, args, type, gcc_p)
|
|||
}
|
||||
}
|
||||
|
||||
#ifndef GDB_TARGET_IS_HPPA_20W
|
||||
/* Store upper 21 bits of function address into ldil. fun will either be
|
||||
the final target (most cases) or __d_plt_call when calling into a shared
|
||||
library and __gcc_plt_call is not available. */
|
||||
|
|
@ -2062,7 +2225,6 @@ hppa_fix_call_dummy (dummy, pc, fun, nargs, args, type, gcc_p)
|
|||
deposit_14 (fun & MASK_11,
|
||||
extract_unsigned_integer (&dummy[FUNC_LDO_OFFSET],
|
||||
INSTRUCTION_SIZE)));
|
||||
#endif /* GDB_TARGET_IS_HPPA_20W */
|
||||
#ifdef SR4EXPORT_LDIL_OFFSET
|
||||
|
||||
{
|
||||
|
|
@ -2119,6 +2281,7 @@ hppa_fix_call_dummy (dummy, pc, fun, nargs, args, type, gcc_p)
|
|||
#endif
|
||||
else
|
||||
return dyncall_addr;
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -2790,17 +2953,6 @@ in_solib_return_trampoline (pc, name)
|
|||
calling an argument relocation stub. It even handles some stubs
|
||||
used in dynamic executables. */
|
||||
|
||||
#if 0
|
||||
CORE_ADDR
|
||||
skip_trampoline_code (pc, name)
|
||||
CORE_ADDR pc;
|
||||
char *name;
|
||||
{
|
||||
return find_solib_trampoline_target (pc);
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
CORE_ADDR
|
||||
skip_trampoline_code (pc, name)
|
||||
CORE_ADDR pc;
|
||||
|
|
@ -2855,12 +3007,12 @@ skip_trampoline_code (pc, name)
|
|||
the PLT entry for this function, not the address of the function
|
||||
itself. Bit 31 has meaning too, but only for MPE. */
|
||||
if (pc & 0x2)
|
||||
pc = (CORE_ADDR) read_memory_integer (pc & ~0x3, 4);
|
||||
pc = (CORE_ADDR) read_memory_integer (pc & ~0x3, TARGET_PTR_BIT / 8);
|
||||
}
|
||||
if (pc == dyncall_external)
|
||||
{
|
||||
pc = (CORE_ADDR) read_register (22);
|
||||
pc = (CORE_ADDR) read_memory_integer (pc & ~0x3, 4);
|
||||
pc = (CORE_ADDR) read_memory_integer (pc & ~0x3, TARGET_PTR_BIT / 8);
|
||||
}
|
||||
else if (pc == sr4export)
|
||||
pc = (CORE_ADDR) (read_register (22));
|
||||
|
|
@ -3052,7 +3204,7 @@ skip_trampoline_code (pc, name)
|
|||
else if ((curr_inst & 0xffe0f000) == 0xe840d000)
|
||||
{
|
||||
return (read_memory_integer
|
||||
(read_register (SP_REGNUM) - 24, 4)) & ~0x3;
|
||||
(read_register (SP_REGNUM) - 24, TARGET_PTR_BIT / 8)) & ~0x3;
|
||||
}
|
||||
|
||||
/* What about be,n 0(sr0,%rp)? It's just another way we return to
|
||||
|
|
@ -3064,7 +3216,7 @@ skip_trampoline_code (pc, name)
|
|||
I guess we could check for the previous instruction being
|
||||
mtsp %r1,%sr0 if we want to do sanity checking. */
|
||||
return (read_memory_integer
|
||||
(read_register (SP_REGNUM) - 24, 4)) & ~0x3;
|
||||
(read_register (SP_REGNUM) - 24, TARGET_PTR_BIT / 8)) & ~0x3;
|
||||
}
|
||||
|
||||
/* Haven't found the branch yet, but we're still in the stub.
|
||||
|
|
@ -3531,9 +3683,20 @@ hppa_frame_find_saved_regs (frame_info, frame_saved_regs)
|
|||
instead, let find_dummy_frame_regs fill in the correct offsets
|
||||
for the saved registers. */
|
||||
if ((frame_info->pc >= frame_info->frame
|
||||
&& frame_info->pc <= (frame_info->frame + CALL_DUMMY_LENGTH
|
||||
+ 32 * 4 + (NUM_REGS - FP0_REGNUM) * 8
|
||||
+ 6 * 4)))
|
||||
&& frame_info->pc <= (frame_info->frame
|
||||
/* A call dummy is sized in words, but it is
|
||||
actually a series of instructions. Account
|
||||
for that scaling factor. */
|
||||
+ ((REGISTER_SIZE / INSTRUCTION_SIZE)
|
||||
* CALL_DUMMY_LENGTH)
|
||||
/* Similarly we have to account for 64bit
|
||||
wide register saves. */
|
||||
+ (32 * REGISTER_SIZE)
|
||||
/* We always consider FP regs 8 bytes long. */
|
||||
+ (NUM_REGS - FP0_REGNUM) * 8
|
||||
/* Similarly we have to account for 64bit
|
||||
wide register saves. */
|
||||
+ (6 * REGISTER_SIZE))))
|
||||
find_dummy_frame_regs (frame_info, frame_saved_regs);
|
||||
|
||||
/* Interrupt handlers are special too. They lay out the register
|
||||
|
|
@ -3545,7 +3708,8 @@ hppa_frame_find_saved_regs (frame_info, frame_saved_regs)
|
|||
/* SP is a little special. */
|
||||
if (i == SP_REGNUM)
|
||||
frame_saved_regs->regs[SP_REGNUM]
|
||||
= read_memory_integer (frame_info->frame + SP_REGNUM * 4, 4);
|
||||
= read_memory_integer (frame_info->frame + SP_REGNUM * 4,
|
||||
TARGET_PTR_BIT / 8);
|
||||
else
|
||||
frame_saved_regs->regs[i] = frame_info->frame + i * 4;
|
||||
}
|
||||
|
|
@ -3882,6 +4046,7 @@ initialize_hp_cxx_exception_support ()
|
|||
return 0;
|
||||
}
|
||||
|
||||
#ifndef GDB_TARGET_IS_HPPA_20W
|
||||
/* Check whether the executable is dynamically linked or archive bound */
|
||||
/* With an archive-bound executable we can use the raw addresses we find
|
||||
for the callback function, etc. without modification. For an executable
|
||||
|
|
@ -3925,6 +4090,7 @@ initialize_hp_cxx_exception_support ()
|
|||
}
|
||||
else
|
||||
exception_catchpoints_are_fragile = 0;
|
||||
#endif
|
||||
|
||||
/* Now, look for the breakpointable routine in end.o */
|
||||
/* This should also be available in the SOM symbol dict. if end.o linked in */
|
||||
|
|
|
|||
|
|
@ -139,6 +139,12 @@ store_inferior_registers (regno)
|
|||
}
|
||||
return;
|
||||
}
|
||||
|
||||
/* Another crock. HPUX complains if you write a nonzero value to
|
||||
the high part of IPSW. What will it take for HP to catch a
|
||||
clue about building sensible interfaces? */
|
||||
if (regno == IPSW_REGNUM && len == 8)
|
||||
*(int *)®isters[REGISTER_BYTE (regno)] = 0;
|
||||
#endif
|
||||
|
||||
for (i = 0; i < len; i += sizeof (int))
|
||||
|
|
@ -152,7 +158,7 @@ store_inferior_registers (regno)
|
|||
the kernel doesn't let us at the registers. */
|
||||
char *err = safe_strerror (errno);
|
||||
char *msg = alloca (strlen (err) + 128);
|
||||
sprintf (msg, "reading `%s' register: %s",
|
||||
sprintf (msg, "writing `%s' register: %s",
|
||||
REGISTER_NAME (regno), err);
|
||||
/* If we fail to write the PC, give a true error instead of
|
||||
just a warning. */
|
||||
|
|
|
|||
|
|
@ -116,8 +116,6 @@ static char initialized; /* boolean flag. != 0 means we've been initialized */
|
|||
int remote_debug;
|
||||
/* debug > 0 prints ill-formed commands in valid packets & checksum errors */
|
||||
|
||||
void waitabit();
|
||||
|
||||
static const char hexchars[]="0123456789abcdef";
|
||||
|
||||
/* Number of registers. */
|
||||
|
|
@ -893,12 +891,7 @@ int exception;
|
|||
exceptionHook = remcomHandler;
|
||||
}
|
||||
|
||||
/* In case GDB is started before us, ack any packets (presumably
|
||||
"$?#xx") sitting there. */
|
||||
putDebugChar ('+');
|
||||
|
||||
initialized = 1;
|
||||
|
||||
}
|
||||
|
||||
/* This function will generate a breakpoint exception. It is used at the
|
||||
|
|
@ -909,19 +902,5 @@ int exception;
|
|||
void breakpoint()
|
||||
{
|
||||
if (initialized)
|
||||
#if 0
|
||||
handle_exception(3);
|
||||
#else
|
||||
BREAKPOINT();
|
||||
#endif
|
||||
waitabit();
|
||||
}
|
||||
|
||||
int waitlimit = 1000000;
|
||||
|
||||
void
|
||||
waitabit()
|
||||
{
|
||||
int i;
|
||||
for (i = 0; i < waitlimit; i++) ;
|
||||
}
|
||||
|
|
|
|||
12
gdb/infrun.c
12
gdb/infrun.c
|
|
@ -1285,8 +1285,9 @@ init_execution_control_state (struct execution_control_state *ecs)
|
|||
}
|
||||
|
||||
/* Call this function before setting step_resume_breakpoint, as a
|
||||
sanity check. We should never be setting a new
|
||||
step_resume_breakpoint when we have an old one active. */
|
||||
sanity check. There should never be more than one step-resume
|
||||
breakpoint per thread, so we should never be setting a new
|
||||
step_resume_breakpoint when one is already active. */
|
||||
static void
|
||||
check_for_old_step_resume_breakpoint (void)
|
||||
{
|
||||
|
|
@ -2289,7 +2290,12 @@ handle_inferior_event (struct execution_control_state *ecs)
|
|||
If we reach here and step_resume_breakpoint is already
|
||||
NULL, then apparently we have multiple active
|
||||
step-resume bp's. We'll just delete the breakpoint we
|
||||
stopped at, and carry on. */
|
||||
stopped at, and carry on.
|
||||
|
||||
Correction: what the code currently does is delete a
|
||||
step-resume bp, but it makes no effort to ensure that
|
||||
the one deleted is the one currently stopped at. MVS */
|
||||
|
||||
if (step_resume_breakpoint == NULL)
|
||||
{
|
||||
step_resume_breakpoint =
|
||||
|
|
|
|||
|
|
@ -1576,10 +1576,6 @@ set_debug_traps()
|
|||
exceptionHandler (16, _catchException16);
|
||||
/* exceptionHandler (17, _catchException17); */
|
||||
|
||||
/* In case GDB is started before us, ack any packets (presumably
|
||||
"$?#xx") sitting there. */
|
||||
putDebugChar ('+');
|
||||
|
||||
initialized = 1;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -576,8 +576,7 @@ char * buffer;
|
|||
|
||||
}
|
||||
|
||||
/* send the packet in buffer. The host get's one chance to read it.
|
||||
This routine does not wait for a positive acknowledge. */
|
||||
/* send the packet in buffer. */
|
||||
|
||||
|
||||
void putpacket(buffer)
|
||||
|
|
@ -603,7 +602,7 @@ char * buffer;
|
|||
putDebugChar(hexchars[checksum >> 4]);
|
||||
putDebugChar(hexchars[checksum % 16]);
|
||||
|
||||
} while (1 == 0); /* (getDebugChar() != '+'); */
|
||||
} while (getDebugChar() != '+');
|
||||
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -1,6 +1,5 @@
|
|||
/* Target-dependent code for the MIPS architecture, for GDB, the GNU Debugger.
|
||||
Copyright 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998
|
||||
Free Software Foundation, Inc.
|
||||
Copyright 1988-1999, Free Software Foundation, Inc.
|
||||
Contributed by Alessandro Forin(af@cs.cmu.edu) at CMU
|
||||
and by Per Bothner(bothner@cs.wisc.edu) at U.Wisconsin.
|
||||
|
||||
|
|
@ -2032,10 +2031,16 @@ mips_push_arguments (nargs, args, sp, struct_return, struct_addr)
|
|||
{
|
||||
/* This is a floating point value that fits entirely
|
||||
in a single register. */
|
||||
/* On 32 bit ABI's the float_argreg is further adjusted
|
||||
above to ensure that it is even register aligned. */
|
||||
CORE_ADDR regval = extract_address (val, len);
|
||||
write_register (float_argreg++, regval);
|
||||
if (!MIPS_EABI)
|
||||
{
|
||||
/* CAGNEY: 32 bit MIPS ABI's always reserve two FP
|
||||
registers for each argument. The below is (my
|
||||
guess) to ensure that the corresponding integer
|
||||
register has reserved the same space. */
|
||||
write_register (argreg, regval);
|
||||
argreg += FP_REGISTER_DOUBLE ? 1 : 2;
|
||||
}
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load Diff
|
|
@ -0,0 +1,164 @@
|
|||
/* HP PA64 ELF Shared library declarations for GDB, the GNU Debugger.
|
||||
Copyright (C) 1999 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., 59 Temple Place - Suite 330,
|
||||
Boston, MA 02111-1307, USA. */
|
||||
|
||||
/* Forward decl's for prototypes */
|
||||
#ifdef __STDC__
|
||||
struct target_ops;
|
||||
struct objfile;
|
||||
struct section_offsets;
|
||||
#endif
|
||||
|
||||
/* Called to add symbols from a shared library to gdb's symbol table. */
|
||||
|
||||
#define SOLIB_ADD(filename, from_tty, targ) \
|
||||
pa64_solib_add (filename, from_tty, targ)
|
||||
|
||||
extern void
|
||||
pa64_solib_add PARAMS ((char *, int, struct target_ops *));
|
||||
|
||||
extern CORE_ADDR
|
||||
pa64_solib_get_got_by_pc PARAMS ((CORE_ADDR));
|
||||
|
||||
/* Function to be called when the inferior starts up, to discover the names
|
||||
of shared libraries that are dynamically linked, the base addresses to
|
||||
which they are linked, and sufficient information to read in their symbols
|
||||
at a later time. */
|
||||
|
||||
#define SOLIB_CREATE_INFERIOR_HOOK(PID) pa64_solib_create_inferior_hook()
|
||||
|
||||
extern void
|
||||
pa64_solib_create_inferior_hook PARAMS ((void));
|
||||
|
||||
/* Function to be called to remove the connection between debugger and
|
||||
dynamic linker that was established by SOLIB_CREATE_INFERIOR_HOOK.
|
||||
(This operation does not remove shared library information from
|
||||
the debugger, as CLEAR_SOLIB does.) */
|
||||
#define SOLIB_REMOVE_INFERIOR_HOOK(PID) pa64_solib_remove_inferior_hook(PID)
|
||||
|
||||
extern void
|
||||
pa64_solib_remove_inferior_hook PARAMS ((int));
|
||||
|
||||
/* This function is called by the "catch load" command. It allows
|
||||
the debugger to be notified by the dynamic linker when a specified
|
||||
library file (or any library file, if filename is NULL) is loaded. */
|
||||
#define SOLIB_CREATE_CATCH_LOAD_HOOK(pid,tempflag, filename,cond_string) \
|
||||
pa64_solib_create_catch_load_hook (pid, tempflag, filename, cond_string)
|
||||
|
||||
extern void
|
||||
pa64_solib_create_catch_load_hook PARAMS ((int, int, char *, char *));
|
||||
|
||||
/* This function is called by the "catch unload" command. It allows
|
||||
the debugger to be notified by the dynamic linker when a specified
|
||||
library file (or any library file, if filename is NULL) is unloaded. */
|
||||
#define SOLIB_CREATE_CATCH_UNLOAD_HOOK(pid,tempflag,filename, cond_string) \
|
||||
pa64_solib_create_catch_unload_hook (pid, tempflag, filename, cond_string)
|
||||
|
||||
extern void
|
||||
pa64_solib_create_catch_unload_hook PARAMS ((int, int, char *, char *));
|
||||
|
||||
/* This function returns TRUE if the dynamic linker has just reported
|
||||
a load of a library.
|
||||
|
||||
This function must be used only when the inferior has stopped in
|
||||
the dynamic linker hook, or undefined results are guaranteed. */
|
||||
#define SOLIB_HAVE_LOAD_EVENT(pid) \
|
||||
pa64_solib_have_load_event (pid)
|
||||
|
||||
extern int
|
||||
pa64_solib_have_load_event PARAMS ((int));
|
||||
|
||||
/* This function returns a pointer to the string representation of the
|
||||
pathname of the dynamically-linked library that has just been loaded.
|
||||
|
||||
This function must be used only when SOLIB_HAVE_LOAD_EVENT is TRUE,
|
||||
or undefined results are guaranteed.
|
||||
|
||||
This string's contents are only valid immediately after the inferior
|
||||
has stopped in the dynamic linker hook, and becomes invalid as soon
|
||||
as the inferior is continued. Clients should make a copy of this
|
||||
string if they wish to continue the inferior and then access the string. */
|
||||
#define SOLIB_LOADED_LIBRARY_PATHNAME(pid) \
|
||||
pa64_solib_loaded_library_pathname (pid)
|
||||
|
||||
extern char *
|
||||
pa64_solib_loaded_library_pathname PARAMS ((int));
|
||||
|
||||
/* This function returns TRUE if the dynamic linker has just reported
|
||||
an unload of a library.
|
||||
|
||||
This function must be used only when the inferior has stopped in
|
||||
the dynamic linker hook, or undefined results are guaranteed. */
|
||||
#define SOLIB_HAVE_UNLOAD_EVENT(pid) \
|
||||
pa64_solib_have_unload_event (pid)
|
||||
|
||||
extern int
|
||||
pa64_solib_have_unload_event PARAMS ((int));
|
||||
|
||||
/* This function returns a pointer to the string representation of the
|
||||
pathname of the dynamically-linked library that has just been unloaded.
|
||||
|
||||
This function must be used only when SOLIB_HAVE_UNLOAD_EVENT is TRUE,
|
||||
or undefined results are guaranteed.
|
||||
|
||||
This string's contents are only valid immediately after the inferior
|
||||
has stopped in the dynamic linker hook, and becomes invalid as soon
|
||||
as the inferior is continued. Clients should make a copy of this
|
||||
string if they wish to continue the inferior and then access the string. */
|
||||
#define SOLIB_UNLOADED_LIBRARY_PATHNAME(pid) \
|
||||
pa64_solib_unloaded_library_pathname (pid)
|
||||
|
||||
extern char *
|
||||
pa64_solib_unloaded_library_pathname PARAMS ((int));
|
||||
|
||||
/* This function returns TRUE if pc is the address of an instruction that
|
||||
lies within the dynamic linker (such as the event hook, or the dld
|
||||
itself).
|
||||
|
||||
This function must be used only when a dynamic linker event has been
|
||||
caught, and the inferior is being stepped out of the hook, or undefined
|
||||
results are guaranteed. */
|
||||
#define SOLIB_IN_DYNAMIC_LINKER(pid,pc) \
|
||||
pa64_solib_in_dynamic_linker (pid, pc)
|
||||
|
||||
extern int
|
||||
pa64_solib_in_dynamic_linker PARAMS ((int, CORE_ADDR));
|
||||
|
||||
/* This function must be called when the inferior is killed, and the program
|
||||
restarted. This is not the same as CLEAR_SOLIB, in that it doesn't discard
|
||||
any symbol tables.
|
||||
|
||||
Presently, this functionality is not implemented. */
|
||||
#define SOLIB_RESTART() \
|
||||
pa64_solib_restart ()
|
||||
|
||||
extern void
|
||||
pa64_solib_restart PARAMS ((void));
|
||||
|
||||
/* If we can't set a breakpoint, and it's in a shared library, just
|
||||
disable it. */
|
||||
|
||||
#define DISABLE_UNSETTABLE_BREAK(addr) (pa64_solib_address(addr) != NULL)
|
||||
|
||||
extern char *
|
||||
pa64_solib_address PARAMS ((CORE_ADDR)); /* somsolib.c */
|
||||
|
||||
/* If ADDR lies in a shared library, return its name. */
|
||||
|
||||
#define PC_SOLIB(addr) pa64_solib_address (addr)
|
||||
|
|
@ -100,6 +100,7 @@ static void remote_close PARAMS ((int quitting));
|
|||
static void remote_store_registers PARAMS ((int regno));
|
||||
|
||||
static void remote_mourn PARAMS ((void));
|
||||
static void remote_async_mourn PARAMS ((void));
|
||||
|
||||
static void extended_remote_restart PARAMS ((void));
|
||||
|
||||
|
|
@ -3793,6 +3794,12 @@ remote_mourn ()
|
|||
remote_mourn_1 (&remote_ops);
|
||||
}
|
||||
|
||||
static void
|
||||
remote_async_mourn ()
|
||||
{
|
||||
remote_mourn_1 (&remote_async_ops);
|
||||
}
|
||||
|
||||
static void
|
||||
extended_remote_mourn ()
|
||||
{
|
||||
|
|
@ -5068,7 +5075,7 @@ Specify the serial device it is connected to (e.g. /dev/ttya).";
|
|||
remote_async_ops.to_remove_breakpoint = remote_remove_breakpoint;
|
||||
remote_async_ops.to_kill = remote_async_kill;
|
||||
remote_async_ops.to_load = generic_load;
|
||||
remote_async_ops.to_mourn_inferior = remote_mourn;
|
||||
remote_async_ops.to_mourn_inferior = remote_async_mourn;
|
||||
remote_async_ops.to_thread_alive = remote_thread_alive;
|
||||
remote_async_ops.to_find_new_threads = remote_threads_info;
|
||||
remote_async_ops.to_stop = remote_stop;
|
||||
|
|
|
|||
|
|
@ -439,8 +439,7 @@ getpacket (char *buffer)
|
|||
}
|
||||
|
||||
|
||||
/* send the packet in buffer. The host get's one chance to read it.
|
||||
This routine does not wait for a positive acknowledge. */
|
||||
/* send the packet in buffer. */
|
||||
|
||||
static void
|
||||
putpacket (register char *buffer)
|
||||
|
|
|
|||
|
|
@ -485,11 +485,6 @@ set_debug_traps()
|
|||
for (ht = hard_trap_info; ht->tt && ht->signo; ht++)
|
||||
exceptionHandler(ht->tt, trap_low);
|
||||
|
||||
/* In case GDB is started before us, ack any packets (presumably
|
||||
"$?#xx") sitting there. */
|
||||
|
||||
putDebugChar ('+');
|
||||
|
||||
initialized = 1;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -602,11 +602,6 @@ set_debug_traps()
|
|||
if (ht->tt != 4 || ! (read_psr () & 0x1000))
|
||||
exceptionHandler(ht->tt, trap_low);
|
||||
|
||||
/* In case GDB is started before us, ack any packets (presumably
|
||||
"$?#xx") sitting there. */
|
||||
|
||||
putDebugChar ('+');
|
||||
|
||||
initialized = 1;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -649,10 +649,6 @@ set_debug_traps()
|
|||
for (ht = hard_trap_info; ht->tt && ht->signo; ht++)
|
||||
exceptionHandler(ht->tt, trap_low);
|
||||
|
||||
/* In case GDB is started before us, ack any packets (presumably
|
||||
"$?#xx") sitting there. */
|
||||
putDebugChar ('+');
|
||||
|
||||
initialized = 1;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -3724,7 +3724,8 @@ read_baseclasses (fip, pp, type, objfile)
|
|||
{
|
||||
static struct complaint msg =
|
||||
{
|
||||
"Unknown visibility `%c' for baseclass", 0, 0};
|
||||
"Unknown visibility `%c' for baseclass", 0, 0
|
||||
};
|
||||
complain (&msg, new->visibility);
|
||||
new->visibility = VISIBILITY_PUBLIC;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -536,9 +536,10 @@ syms_from_objfile (objfile, addr, mainline, verbo)
|
|||
|
||||
/* Convert addr into an offset rather than an absolute address.
|
||||
We find the lowest address of a loaded segment in the objfile,
|
||||
and assume that <addr> is where that got loaded. Due to historical
|
||||
precedent, we warn if that doesn't happen to be a text segment. */
|
||||
and assume that <addr> is where that got loaded.
|
||||
|
||||
We no longer warn if the lowest section is not a text segment (as
|
||||
happens for the PA64 port. */
|
||||
if (mainline)
|
||||
{
|
||||
addr = 0; /* No offset from objfile addresses. */
|
||||
|
|
@ -553,13 +554,6 @@ syms_from_objfile (objfile, addr, mainline, verbo)
|
|||
if (lowest_sect == NULL)
|
||||
warning ("no loadable sections found in added symbol-file %s",
|
||||
objfile->name);
|
||||
else if ((bfd_get_section_flags (objfile->obfd, lowest_sect) & SEC_CODE)
|
||||
== 0)
|
||||
/* FIXME-32x64--assumes bfd_vma fits in long. */
|
||||
warning ("Lowest section in %s is %s at 0x%lx",
|
||||
objfile->name,
|
||||
bfd_section_name (objfile->obfd, lowest_sect),
|
||||
(unsigned long) bfd_section_vma (objfile->obfd, lowest_sect));
|
||||
|
||||
if (lowest_sect)
|
||||
addr -= bfd_section_vma (objfile->obfd, lowest_sect);
|
||||
|
|
|
|||
|
|
@ -30,8 +30,6 @@
|
|||
nothing has already defined the one of the names, and do the right
|
||||
thing. */
|
||||
|
||||
/* nothing works with go32, and the headers aren't complete */
|
||||
#if !defined (__GO32__)
|
||||
#if !defined (HAVE_TERMIOS) && !defined(HAVE_TERMIO) && !defined(HAVE_SGTTY)
|
||||
#if defined(HAVE_TERMIOS_H)
|
||||
#define HAVE_TERMIOS
|
||||
|
|
@ -45,13 +43,12 @@
|
|||
#endif /* ! defined (HAVE_TERMIO_H) */
|
||||
#endif /* ! defined (HAVE_TERMIOS_H) */
|
||||
#endif /* !defined (HAVE_TERMIOS) && !defined(HAVE_TERMIO) && !defined(HAVE_SGTTY) */
|
||||
#endif /* ! defined (__GO32__) */
|
||||
|
||||
#if defined(HAVE_TERMIOS)
|
||||
#include <termios.h>
|
||||
#endif
|
||||
|
||||
#if !defined(__GO32__) && !defined(_WIN32) && !defined (HAVE_TERMIOS)
|
||||
#if !defined(_WIN32) && !defined (HAVE_TERMIOS)
|
||||
|
||||
/* Define a common set of macros -- BSD based -- and redefine whatever
|
||||
the system offers to make it look like that. FIXME: serial.h and
|
||||
|
|
|
|||
|
|
@ -1,3 +1,24 @@
|
|||
Mon Aug 23 10:25:20 1999 Jeffrey A Law (law@cygnus.com)
|
||||
|
||||
* gdb.base/dollar.exp: Do not run for PA processors in wide mode
|
||||
on hpux11.
|
||||
|
||||
* gdb.base/attach.exp: Handle another hpux11 error message variant
|
||||
when attaching to a process that does not exist.
|
||||
|
||||
1999-08-19 J.T. Conklin <jtc@redback.com>
|
||||
|
||||
* gdb.base/call-ar-exp.exp: Fix pattern matching whitespace
|
||||
characters in 'continue to 1241' test.
|
||||
|
||||
1999-08-17 Stan Shebs <shebs@andros.cygnus.com>
|
||||
|
||||
* gdb.base/call-ar-st.exp: Add a shorter match case for the
|
||||
stop in print_long_arg_list, define and use a whitespace
|
||||
variable in print_small_structs test, add an XFAIL for Solaris.
|
||||
* gdb.base/dbx.exp: XFAIL func commands until somebody is
|
||||
interested enough to fix.
|
||||
|
||||
1999-08-13 Keith Seitz <keiths@cygnus.com>
|
||||
|
||||
* gdb.base/dbx.exp (dbx_gdb_file_cmd): Rename to gdb_file_cmd.
|
||||
|
|
|
|||
|
|
@ -131,6 +131,8 @@ proc do_attach_tests {} {
|
|||
# This response is expected on HP-UX 11.0 (i.e., ttrace-based).
|
||||
-re "Attaching to.*, process 0 failed.*Hint.*$gdb_prompt $"\
|
||||
{pass "attach to nonexistent process is prohibited"}
|
||||
-re "Attaching to.*, process 0.*denied.*$gdb_prompt $"\
|
||||
{pass "attach to nonexistent process is prohibited"}
|
||||
-re "$gdb_prompt $" {fail "attach to nonexistent process is prohibited"}
|
||||
timeout {fail "(timeout) attach to nonexistent process is prohibited"}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -311,7 +311,7 @@ gdb_test "tbreak 1241" \
|
|||
|
||||
send_gdb "continue\n"
|
||||
gdb_expect {
|
||||
-re ".*main \\(\\) at .*call-ar-st.c:1241\r\n1241\t\[ \]+sum_array_print\\(10, \\*list1, \\*list2, \\*list3, \\*list4\\);.*$gdb_prompt $" {
|
||||
-re ".*main \\(\\) at .*call-ar-st.c:1241\r\n1241\[\t \]+sum_array_print\\(10, \\*list1, \\*list2, \\*list3, \\*list4\\);.*$gdb_prompt $" {
|
||||
pass "continue to 1241"}
|
||||
-re ".*$gdb_prompt $" { fail "continue to 1241"}
|
||||
timeout { fail "(timeout) continue to 1241"}
|
||||
|
|
@ -424,18 +424,24 @@ if { [istarget "hppa*-*-hpux*"] } {
|
|||
}
|
||||
} else {
|
||||
|
||||
# We can't just assume that a "step" will get us into print_long_arg_list here,either.
|
||||
# We can't just assume that a "step" will get us into
|
||||
# print_long_arg_list here,either.
|
||||
gdb_test "tbreak print_long_arg_list" \
|
||||
"Breakpoint .* file .*call-ar-st.c, line .*" \
|
||||
"tbreak in print_long_arg_list after stepping into memcpy"
|
||||
# The short match case below handles cases where a buffer
|
||||
# overflows or something, and expect can't deal with the full
|
||||
# line. Perhaps a more elegant solution exists... -sts 1999-08-17
|
||||
send_gdb "continue\n"
|
||||
if {![target_info exists gdb,skip_float_tests]} {
|
||||
gdb_expect {
|
||||
-re ".*print_long_arg_list \\(a=22.219999999999999, b=33.332999999999998, c=0, d=-25, e=100, f=2345, struct1=\{value = 6, head = 0\}, struct2=\{value = 10, head = 0\}, struct3=\{value = 12, head = 0\}, struct4=\{value = 14, head = 0\}, flags=\{alpha = 1, beta = 0, gamma = 1, delta = 0, epsilon = 1, omega = 0\}, flags_combo=\{alpha = 1, beta = 0, ch1 = 121 \'y\', gamma = 1, delta = 0, ch2 = 110 \'n\', epsilon = 1, omega = 0\}, three_char=\{ch1 = 97 \'a\', ch2 = 98 \'b\', ch3 = 99 \'c\'\}, five_char=\{ch1 = 108 \'l\', ch2 = 109 \'m\', ch3 = 110 \'n\', ch4 = 111 \'o\', ch5 = 112 \'p\'\}, int_char_combo=\{int1 = 123, ch1 = 122 \'z\'\}, d1=\{double1 = 10.5\}, d2=\{double1 = -3.3399999999999999\}, d3=\{double1 = 675.09123\}, f1=\{float1 = 45.2340012, float2 = 43.5999985\}, f2=\{float1 = 78.0100021, float2 = 122.099998\}, f3=\{float1 = -1232.34497, float2 = -199.210007\}\\) at ${srcdir}/${subdir}/${srcfile}:992\[\r\n\]+992\[ \t\]+printf\\(\"double :.*\", a\\);.*$gdb_prompt $" {pass "step into print_long_arg_list"}
|
||||
-re ".*print_long_arg_list \\(a=22.219999999999999, b=33.332999999999998, c=0, d=-25, e=100, f=2345, struct1=\{value = 6, head = 0\}, struct2=\{value = 10, head = 0\}, struct3=\{value = 12, head = 0\}, struct4=\{value = 14, head = 0\}, flags=\{alpha = 1, beta = 0, gamma = 1, delta = 0, epsilon = 1, omega = 0\}, flags_combo=\{alpha = 1, beta = 0, ch1 = 121 \'y\', gamma = 1, delta = 0, ch2 = 110 \'n\', epsilon = 1, omega = 0\}, three_char=\{ch1 = 97 \'a\', ch2 = 98 \'b\', ch3 = 99 \'c\'\}, five_char=\{ch1 = 108 \'l\', ch2 = 109 \'m\', ch3 = 110 \'n\', ch4 = 111 \'o\', ch5 = 112 \'p\'\}, int_char_combo=\{int1 = 123, ch1 = 122 \'z\'\}, d1=\{double1 = 10.5\}, d2=\{double1 = -3.3399999999999999\}, d3=\{double1 = 675.09123\}, f1=\{float1 = 45.2340012, float2 = 43.5999985\}, f2=\{float1 = 78.0100021, float2 = 122.099998\}, f3=\{float1 = -1232.34497, float2 = -199.210007\}\\) at ${srcdir}/${subdir}/${srcfile}:992\[\r\n\]+992\[ \t\]+printf\\(\"double :.*\", a\\);.*$gdb_prompt $" { pass "step into print_long_arg_list" }
|
||||
-re ".*print_long_arg_list.*\\(a=22.219999999999999, b=33.332999999999998, c=0, d=-25, e=100, f=2345, struct1=\{value = 6, head = 0\}, struct2=\{value = 10, head = 0\}, struct3=\{value = 12, head = 0\}, struct4=\{value = 14, head = 0\}, flags=\{alpha = 1, beta = 0, gamma = 1, delta = 0, epsilon = 1, omega = 0\}, flags_combo=\{alpha = 1, beta = 0, ch1 = 121 \'y\', gamma = 1, delta = 0, ch2 = 110 \'n\', epsilon = 1, omega = 0\}, three_char=\{ch1 = 97 \'a\', ch2 = 98 \'b\', ch3 = 99 \'c\'\}.*\\) at ${srcdir}/${subdir}/${srcfile}:992\[\r\n\]+992\[ \t\]+printf\\(\"double :.*\", a\\);.*$gdb_prompt $" {pass "step into print_long_arg_list (short match)"}
|
||||
-re ".*$gdb_prompt $" { fail "step into print_long_arg_list" }
|
||||
timeout { fail "step into print_long_arg_list (timeout)" }
|
||||
}
|
||||
} else {
|
||||
# If skipping float tests, don't expect anything in arg list.
|
||||
gdb_expect {
|
||||
-re ".*print_long_arg_list \\(.*\\).*$gdb_prompt $" { pass "step into print_long_arg_list" }
|
||||
-re ".*$gdb_prompt $" { fail "step into print_long_arg_list" }
|
||||
|
|
@ -444,16 +450,23 @@ if { [istarget "hppa*-*-hpux*"] } {
|
|||
}
|
||||
}
|
||||
|
||||
set ws "\[\n\r\t \]+"
|
||||
|
||||
#call print_small_structs(struct1, struct2, struct3, struct4, flags, flags_combo, three_char, five_char, int_char_combo, d1, d2, d3, f1, f2, f3)
|
||||
if {![target_info exists gdb,skip_float_tests]} {
|
||||
send_gdb "print print_small_structs(struct1, struct2, struct3, struct4, flags, flags_combo, three_char, five_char, int_char_combo, d1, d2, d3, f1, f2, f3)\n"
|
||||
gdb_expect {
|
||||
-re ".*alpha\[\t\r\n \]+gamma\[\t\r\n \]+epsilon\[\t\r\n \]+alpha\[\t\r\n \]+gamma\[\t\r\n \]+epsilon\[\t\r\n \]+ch1: y\tch2: n\[\t\r\n \]+Contents of three_char_t:\[\t\r\n \]+a\tb\tc\[\t\r\n \]+Contents of five_char_t:\[\t\r\n \]+l\tm\tn\to\tp\[\t\r\n \]+Contents of int_char_combo_t:\[\t\r\n \]+123.*z\[\t\r\n \]+Sum of the 4 struct values and seed :\[\t\r\n \]+52\[\t\r\n \]+Contents of struct1:\[\t\r\n \]+6.*0\[\t\r\n \]+Contents of struct2:\[\t\r\n \]+10.*0\[\t\r\n \]+Contents of struct3:\[\t\r\n \]+12.*0\[\t\r\n \]+Contents of one_double_t:\[\t\r\n \]+10.500000\[\t\r\n \]+Contents of one_double_t:\[\t\r\n \]+-3.340000\[\t\r\n \]+Contents of one_double_t:\[\t\r\n \]+675.091230\[\t\r\n \]+Contents of two_floats_t:\[\t\r\n \]+45.234001.*43.599998\[\t\r\n \]+Contents of two_floats_t:\[\t\r\n \]+78.010002.*122.099998\[\t\r\n \]+Contents of two_floats_t:\[\t\r\n \]+-1232.344971.*-199.210007\[\t\r\n \]+.*$gdb_prompt $" {
|
||||
pass "print print_small_structs from print_long_arg_list "
|
||||
# On Solaris, some of the args are passed by ref, others by value,
|
||||
# and GDB gets confused and says "Invalid cast" because it thinks
|
||||
# it has to cast the structure into a pointer to structure. A real
|
||||
# GDB bug, probably for all Sparc configs, but obscure. -sts 1999-08-17.
|
||||
setup_xfail "sparc*-*-solaris*"
|
||||
send_gdb "print print_small_structs(struct1, struct2, struct3, struct4, flags, flags_combo, three_char, five_char, int_char_combo, d1, d2, d3, f1, f2, f3)\n"
|
||||
gdb_expect {
|
||||
-re ".*alpha${ws}gamma${ws}epsilon${ws}alpha${ws}gamma${ws}epsilon${ws}ch1: y\tch2: n${ws}Contents of three_char_t:${ws}a\tb\tc${ws}Contents of five_char_t:${ws}l\tm\tn\to\tp${ws}Contents of int_char_combo_t:${ws}123.*z${ws}Sum of the 4 struct values and seed :${ws}52${ws}Contents of struct1:${ws}6.*0${ws}Contents of struct2:${ws}10.*0${ws}Contents of struct3:${ws}12.*0${ws}Contents of one_double_t:${ws}10.500000${ws}Contents of one_double_t:${ws}-3.340000${ws}Contents of one_double_t:${ws}675.091230${ws}Contents of two_floats_t:${ws}45.234001.*43.599998${ws}Contents of two_floats_t:${ws}78.010002.*122.099998${ws}Contents of two_floats_t:${ws}-1232.344971.*-199.210007${ws}.*$gdb_prompt $" {
|
||||
pass "print print_small_structs from print_long_arg_list"
|
||||
}
|
||||
-re ".*$gdb_prompt $" { fail "print print_small_structs from print_long_arg_list" }
|
||||
timeout { fail "(timeout) print_small_structs from print_long_arg_list" }
|
||||
}
|
||||
-re ".*$gdb_prompt $" { fail "print print_small_structs from print_long_arg_list" }
|
||||
timeout { fail "(timeout) print_small_structs from print_long_arg_list" }
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -308,9 +308,13 @@ proc test_whereis { } {
|
|||
proc test_func { } {
|
||||
gdb_test "cont" ""
|
||||
gdb_test "step" ""
|
||||
# This always fails, but it's not clear why. -sts 1999-08-17
|
||||
setup_xfail "*-*-*"
|
||||
gdb_test "func sum" "'sum' not within current stack frame\."
|
||||
gdb_test "stop in sum" "Breakpoint.*at.*: file.*sum\.c, line 11\."
|
||||
gdb_test "cont"
|
||||
# This always fails, but it's not clear why. -sts 1999-08-17
|
||||
setup_xfail "*-*-*"
|
||||
gdb_test "func print_average" ".*in print_average.*\\(list=.*, low=0, high=6\\).*at.*average\.c:24\r\n24\[ \t\]+total = sum\\(list, low, high\\);"
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -32,6 +32,12 @@ if ![ istarget "*-*-hpux*" ] then {
|
|||
return
|
||||
}
|
||||
|
||||
# When we are in "wide" mode we do not necessary have $$dyncall as a symbol
|
||||
# name, which makes all these tests useless
|
||||
if ![ istarget "hppa*w-*-hpux11*" ] then {
|
||||
return
|
||||
}
|
||||
|
||||
if $tracelevel then {
|
||||
strace $tracelevel
|
||||
}
|
||||
|
|
|
|||
16
gdb/thread.c
16
gdb/thread.c
|
|
@ -160,6 +160,11 @@ delete_thread (pid)
|
|||
else
|
||||
thread_list = tp->next;
|
||||
|
||||
/* NOTE: this will take care of any left-over step_resume breakpoints,
|
||||
but not any user-specified thread-specific breakpoints. */
|
||||
if (tp->step_resume_breakpoint)
|
||||
delete_breakpoint (tp->step_resume_breakpoint);
|
||||
|
||||
free (tp);
|
||||
|
||||
return;
|
||||
|
|
@ -350,20 +355,11 @@ prune_threads ()
|
|||
{
|
||||
struct thread_info *tp, *tpprev, *next;
|
||||
|
||||
tpprev = 0;
|
||||
for (tp = thread_list; tp; tp = next)
|
||||
{
|
||||
next = tp->next;
|
||||
if (!thread_alive (tp))
|
||||
{
|
||||
if (tpprev)
|
||||
tpprev->next = next;
|
||||
else
|
||||
thread_list = next;
|
||||
free (tp);
|
||||
}
|
||||
else
|
||||
tpprev = tp;
|
||||
delete_thread (tp->pid);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
17
gdb/value.h
17
gdb/value.h
|
|
@ -27,23 +27,6 @@
|
|||
* be possible for a program lval value to survive over a call to the inferior
|
||||
* (ie to be put into the history list or an internal variable).
|
||||
*/
|
||||
enum lval_type
|
||||
{
|
||||
/* Not an lval. */
|
||||
not_lval,
|
||||
/* In memory. Could be a saved register. */
|
||||
lval_memory,
|
||||
/* In a register. */
|
||||
lval_register,
|
||||
/* In a gdb internal variable. */
|
||||
lval_internalvar,
|
||||
/* Part of a gdb internal variable (structure field). */
|
||||
lval_internalvar_component,
|
||||
/* In a register series in a frame not the current one, which may have been
|
||||
partially saved or saved in different places (otherwise would be
|
||||
lval_register or lval_memory). */
|
||||
lval_reg_frame_relative
|
||||
};
|
||||
|
||||
struct value
|
||||
{
|
||||
|
|
|
|||
|
|
@ -1,3 +1,15 @@
|
|||
1999-08-20 Doug Evans <devans@casey.cygnus.com>
|
||||
|
||||
* genmloop.sh: New args -parallel-generic-write, -parallel-only.
|
||||
* cgen-engine.h (SEMANTIC_FN): Don't use version with PAREXEC
|
||||
buffer arg if WITH_PARALLEL_GENWRITE.
|
||||
(struct insn_sem): Handle WITH_PARALLEL_GENWRITE.
|
||||
(struct idesc): Ditto.
|
||||
|
||||
Wed Aug 18 18:17:28 1999 Doug Evans <devans@canuck.cygnus.com>
|
||||
|
||||
* sim-model.c (model_option_handler): Add \n to error message.
|
||||
|
||||
1999-08-08 Doug Evans <devans@casey.cygnus.com>
|
||||
|
||||
* cgen-engine.h (SEM_FN_NAME,SEMF_FN_NAME): Delete.
|
||||
|
|
|
|||
|
|
@ -90,7 +90,7 @@ typedef void (EXTRACT_FN) (SIM_CPU *, IADDR, CGEN_INSN_INT, ARGBUF *);
|
|||
|
||||
/* Instruction fields are extracted into ARGBUF before calling the
|
||||
semantic routine. */
|
||||
#if HAVE_PARALLEL_INSNS
|
||||
#if HAVE_PARALLEL_INSNS && ! WITH_PARALLEL_GENWRITE
|
||||
typedef SEM_PC (SEMANTIC_FN) (SIM_CPU *, SEM_ARG, PAREXEC *);
|
||||
#else
|
||||
typedef SEM_PC (SEMANTIC_FN) (SIM_CPU *, SEM_ARG);
|
||||
|
|
@ -103,7 +103,7 @@ typedef unsigned int SEM_STATUS;
|
|||
|
||||
/* Instruction fields are extracted by the semantic routine.
|
||||
??? TODO: multi word insns. */
|
||||
#if HAVE_PARALLEL_INSNS
|
||||
#if HAVE_PARALLEL_INSNS && ! WITH_PARALLEL_GENWRITE
|
||||
typedef SEM_STATUS (SEMANTIC_FN) (SIM_CPU *, SEM_ARG, PAREXEC *, CGEN_INSN_INT);
|
||||
#else
|
||||
typedef SEM_STATUS (SEMANTIC_FN) (SIM_CPU *, SEM_ARG, CGEN_INSN_INT);
|
||||
|
|
@ -329,8 +329,8 @@ do { \
|
|||
/* Instruction information. */
|
||||
|
||||
/* Sanity check, at most one of these may be true. */
|
||||
#if WITH_PARALLEL_READ && WITH_PARALLEL_WRITE
|
||||
#error "Both WITH_PARALLEL_READ && WITH_PARALLEL_WRITE can't be true."
|
||||
#if WITH_PARALLEL_READ + WITH_PARALLEL_WRITE + WITH_PARALLEL_GENWRITE > 1
|
||||
#error "At most one of WITH_PARALLEL_{READ,WRITE,GENWRITE} can be true."
|
||||
#endif
|
||||
|
||||
/* Compile time computable instruction data. */
|
||||
|
|
@ -346,7 +346,7 @@ struct insn_sem {
|
|||
/* Semantic format number. */
|
||||
int sfmt;
|
||||
|
||||
#if WITH_PARALLEL_READ || WITH_PARALLEL_WRITE
|
||||
#if HAVE_PARALLEL_INSNS && ! WITH_PARALLEL_ONLY
|
||||
/* Index in IDESC table of parallel handler. */
|
||||
int par_index;
|
||||
#endif
|
||||
|
|
@ -397,7 +397,7 @@ struct idesc {
|
|||
#endif
|
||||
|
||||
/* Parallel support. */
|
||||
#if WITH_PARALLEL_READ || WITH_PARALLEL_WRITE
|
||||
#if HAVE_PARALLEL_INSNS && (! WITH_PARALLEL_ONLY || (WITH_PARALLEL_ONLY && ! WITH_PARALLEL_GENWRITE))
|
||||
/* Pointer to parallel handler if serial insn.
|
||||
Pointer to readahead/writeback handler if parallel insn. */
|
||||
struct idesc *par_idesc;
|
||||
|
|
|
|||
|
|
@ -85,6 +85,8 @@
|
|||
#
|
||||
# -parallel-read: support parallel execution with read-before-exec support.
|
||||
# -parallel-write: support parallel execution with write-after-exec support.
|
||||
# -parallel-generic-write: support parallel execution with generic queued
|
||||
# writes.
|
||||
#
|
||||
# One of these options is specified in addition to -simple, -scache,
|
||||
# -pbb. Note that while the code can determine if the cpu supports
|
||||
|
|
@ -92,6 +94,12 @@
|
|||
# technically unnecessary], having this option cuts down on the clutter
|
||||
# in the result.
|
||||
#
|
||||
# -parallel-only: semantic code only supports parallel version of insn
|
||||
#
|
||||
# Semantic code only supports parallel versions of each insn.
|
||||
# Things can be sped up by generating both serial and parallel versions
|
||||
# and is better suited to mixed parallel architectures like the m32r.
|
||||
#
|
||||
# -switch file: specify file containing semantics implemented as a switch()
|
||||
#
|
||||
# -cpu <cpu-family>
|
||||
|
|
@ -116,6 +124,7 @@ type=mono
|
|||
#full_switch=
|
||||
#pbb=
|
||||
parallel=no
|
||||
parallel_only=no
|
||||
switch=
|
||||
cpu="unknown"
|
||||
infile=""
|
||||
|
|
@ -134,6 +143,8 @@ do
|
|||
-no-parallel) ;;
|
||||
-parallel-read) parallel=read ;;
|
||||
-parallel-write) parallel=write ;;
|
||||
-parallel-generic-write) parallel=genwrite ;;
|
||||
-parallel-only) parallel_only=yes ;;
|
||||
-switch) shift ; switch=$1 ;;
|
||||
-cpu) shift ; cpu=$1 ;;
|
||||
-infile) shift ; infile=$1 ;;
|
||||
|
|
@ -189,22 +200,36 @@ fi
|
|||
|
||||
echo ""
|
||||
echo "/* HAVE_PARALLEL_INSNS: non-zero if cpu can parallelly execute > 1 insn. */"
|
||||
if [ x$parallel != xno ] ; then
|
||||
echo "#define HAVE_PARALLEL_INSNS 1"
|
||||
if [ x$parallel = xread ] ; then
|
||||
echo "/* Parallel execution is supported by read-before-exec. */"
|
||||
echo "#define WITH_PARALLEL_READ 1"
|
||||
echo "#define WITH_PARALLEL_WRITE 0"
|
||||
else
|
||||
echo "/* Parallel execution is supported by write-after-exec. */"
|
||||
echo "#define WITH_PARALLEL_READ 0"
|
||||
echo "#define WITH_PARALLEL_WRITE 1"
|
||||
fi
|
||||
else
|
||||
echo "#define HAVE_PARALLEL_INSNS 0"
|
||||
echo "#define WITH_PARALLEL_READ 0"
|
||||
echo "#define WITH_PARALLEL_WRITE 0"
|
||||
fi
|
||||
# blah blah blah, other ways to do this, blah blah blah
|
||||
case x$parallel in
|
||||
xno)
|
||||
echo "#define HAVE_PARALLEL_INSNS 0"
|
||||
echo "#define WITH_PARALLEL_READ 0"
|
||||
echo "#define WITH_PARALLEL_WRITE 0"
|
||||
echo "#define WITH_PARALLEL_GENWRITE 0"
|
||||
;;
|
||||
xread)
|
||||
echo "#define HAVE_PARALLEL_INSNS 1"
|
||||
echo "/* Parallel execution is supported by read-before-exec. */"
|
||||
echo "#define WITH_PARALLEL_READ 1"
|
||||
echo "#define WITH_PARALLEL_WRITE 0"
|
||||
echo "#define WITH_PARALLEL_GENWRITE 0"
|
||||
;;
|
||||
xwrite)
|
||||
echo "#define HAVE_PARALLEL_INSNS 1"
|
||||
echo "/* Parallel execution is supported by write-after-exec. */"
|
||||
echo "#define WITH_PARALLEL_READ 0"
|
||||
echo "#define WITH_PARALLEL_WRITE 1"
|
||||
echo "#define WITH_PARALLEL_GENWRITE 0"
|
||||
;;
|
||||
xgenwrite)
|
||||
echo "#define HAVE_PARALLEL_INSNS 1"
|
||||
echo "/* Parallel execution is supported by generic write-after-exec. */"
|
||||
echo "#define WITH_PARALLEL_READ 0"
|
||||
echo "#define WITH_PARALLEL_WRITE 0"
|
||||
echo "#define WITH_PARALLEL_GENWRITE 1"
|
||||
;;
|
||||
esac
|
||||
|
||||
if [ "x$switch" != x ] ; then
|
||||
echo ""
|
||||
|
|
@ -360,13 +385,15 @@ void
|
|||
|
||||
EOF
|
||||
|
||||
if [ x$parallel != xno ] ; then
|
||||
cat << EOF
|
||||
case x$parallel in
|
||||
xread | xwrite)
|
||||
cat << EOF
|
||||
PAREXEC pbufs[MAX_PARALLEL_INSNS];
|
||||
PAREXEC *par_exec;
|
||||
|
||||
EOF
|
||||
fi
|
||||
;;
|
||||
esac
|
||||
|
||||
# Any initialization code before looping starts.
|
||||
# Note that this code may declare some locals.
|
||||
|
|
@ -1118,13 +1145,15 @@ void
|
|||
|
||||
EOF
|
||||
|
||||
if [ x$parallel != xno ] ; then
|
||||
cat << EOF
|
||||
case x$parallel in
|
||||
xread | xwrite)
|
||||
cat << EOF
|
||||
PAREXEC pbufs[MAX_PARALLEL_INSNS];
|
||||
PAREXEC *par_exec = &pbufs[0];
|
||||
|
||||
EOF
|
||||
fi
|
||||
;;
|
||||
esac
|
||||
|
||||
# Any initialization code before looping starts.
|
||||
# Note that this code may declare some locals.
|
||||
|
|
@ -1208,13 +1237,15 @@ void
|
|||
|
||||
EOF
|
||||
|
||||
if [ x$parallel != xno ] ; then
|
||||
cat << EOF
|
||||
case x$parallel in
|
||||
xread | xwrite)
|
||||
cat << EOF
|
||||
PAREXEC pbufs[MAX_PARALLEL_INSNS];
|
||||
PAREXEC *par_exec = &pbufs[0];
|
||||
|
||||
EOF
|
||||
fi
|
||||
;;
|
||||
esac
|
||||
|
||||
# Any initialization code before looping starts.
|
||||
# Note that this code may declare some locals.
|
||||
|
|
|
|||
|
|
@ -51,7 +51,7 @@ model_option_handler (SIM_DESC sd, sim_cpu *cpu, int opt,
|
|||
const MODEL *model = sim_model_lookup (arg);
|
||||
if (! model)
|
||||
{
|
||||
sim_io_eprintf (sd, "unknown model `%s'", arg);
|
||||
sim_io_eprintf (sd, "unknown model `%s'\n", arg);
|
||||
return SIM_RC_FAIL;
|
||||
}
|
||||
sim_model_set (sd, cpu, model);
|
||||
|
|
|
|||
Loading…
Reference in New Issue