diff options
Diffstat (limited to 'gdb/ChangeLog')
| -rw-r--r-- | gdb/ChangeLog | 2818 |
1 files changed, 2818 insertions, 0 deletions
diff --git a/gdb/ChangeLog b/gdb/ChangeLog index db86c1d..3e03426 100644 --- a/gdb/ChangeLog +++ b/gdb/ChangeLog @@ -1,3 +1,2821 @@ +Thu Dec 31 16:54:30 1998 David Taylor <taylor@texas.cygnus.com> + + The following changes were made by + Elena Zannoni <ezannoni@kwikemart.cygnus.com> + Edith Epstein <eepstein@sophia.cygnus.com> + David Taylor <taylor@texas.cygnus.com> + + * config/pa/tm-hppa.h (INSTRUCTION_NULLIFIED): change to read + nullify instruction bit from IPSW only when we are not in a system + call. + (STRCAT_REGISTER, pa_do_strcat_registers_info): additional + parameter -- precision. + + * Makefile.in (BUILD_TUI): to build the tui, only when configured + with --enable-tui. + (YLWRAP): use ylwrap to avoid problems on systems w/o bison. + (gdb$(EXEEXT)): make it dependent on BUILD_TUI. + (all-tui): remove dependency from phony target. + (c-exp.tab.c): use ylwrap instead of bison. + (jv-exp.tab.c): ditto. + (f-exp.tab.c): ditto. + (m2-exp.tab.c): ditto. + + * configure.in (ENABLE_CFLAGS): define and export BUILD_TUI. + + * configure : regenerated. + + * c-typeprint.c (c_type_print_base): get to the method name by + skipping over all the namespaces, classes and '::'. + + * infcmd.c (run_command): only call SOLIB_RESTART if it's + defined. + (detach_command): ditto. + + * infptrace.c (call_ptrace): add some debugging code. + + * infrun.c (follow_inferior_fork): only define on HP. + (wait_for_inferior): only call SOLIB_IN_DYNAMIC_LINKER if we have + shared libraries; restore test of IN_SOLIB_DYNSYM_RESOLVE_CODE + removed by HP. + + Also, altered calls to c_val_print and val_print, to + reflect additional parameter to c_val_print and val_print. + Affected functions : scm_val_print, scm_value_print + + Also, altered calls to c_val_print, to + reflect additional parameter to c_val_print. + Affected functions : m2_val_print + + Altered calls to val_print, to reflect the + additional parameter for val_print. + Affected files : val_print_array_elements + + In addition there are new macro definitions : + target_pid_to_exec_file, target_acknowledge_forked_child, + target_create_catch_fork_hook, target_create_catch_vfork_hook, + target_has_forked, target_has_vforked. These are generalized + macros for dealing with fork/vfork/exec. + + In addition, there are new functions : normal_pid_to_exec_file, + normal_acknowledge_forked_child, normal_target_has_forked, + normal_target_has_vforked. + + Note : initialized the new fields to NULL -> use the definitions + supplied by inftarg.c. This may not be the correct thing + in all cases. Fix later. + + The INHERIT macro has additional entries for + to_require_attach and to_require_detach. + + The de_fault macro has additional entries for + to_require_attach and to_require_detach. + + The setup_target_debug function is altered to make + sure that the to_require_attach and to_require_detach + fields are set for the current_target. + + There are 4 new functions : find_default_require_attach, + find_default_require_detach, debug_to_require_attach, + debug_to_require_detach. + + removed some target_ops vector fields, HP folks changed + their minds about them : to_create_catch_fork_hook, + to_create_catch_vfork_hook + + * Makefile.in (ALLDEPFILES): add somread.c, hp-psymtab-read.c, + hp-symtab-read.c. + (SFILES): remove the above files + (COMMON_OBS): remove somread.o + + * Makefile.in (SFILES): Add the tui files to this, so they get + included in etags tables. + + * Makefile.in (all-tui): Renamed from tui-all, for consistency + with everything else. + + * Makefile.in (gdb$(EXEEXT)): Add tui-all to the list of + dependencies, and add tui/libtui.a to the link list. + (tui-all): New rule, which does a recursive make in the tui + subdir. + + * Makefile.in (tui/libtui.a): When recursing, pass down + ${FLAGS_TO_PASS}. And don't echo the make command. This is + closer to what the other recursions do. + + * Makefile.in: (HFILES_NO_SRCDIR) add hpread.h + (COMMON_OBS): add hp-psymtab-read.o, hp-symtab-read.o + (SFILES): add hp-psymtab-read.c, hp-symtab-read.c + add rules for the new files. + Remove hpread.c, hpread.o + + * Makefile.in: Allow the TUI code to be conditionally enabled. + (TUI_TARGET, TUI_LIBRARY): New variables, whose values are set by + the configuration script. They're set to the empty string when + the TUI isn't enabled. + (gdb$(GDBEXT)): Use those, instead of referring to tui-all and + tui/libtui.a directly. + + * Makefile.in: Avoid spurious relinking. + (gdb$(EXEEXT)): Depend on the actual tui library, not on a + fictitious target. Since the fictitious target never existed, make + would always relink. + (tui/libtui.a): Renamed from all-tui. Always recurse to make sure + the library is up to date. + (TUI_TARGET): Variable removed; there's no need for it any more. + + * Makefile.in: look for tui include files in the tui source dir. + + * Use automake's `aclocal' program to generate aclocal.m4, to allow + us to use automake macros in configure.in with impunity. + + * acconfig.h: Add an entry for the `TUI' symbol. + + * acinclude.m4: New file, containing the code from the old + aclocal.m4. Incorporate (by reference) ../bfd/acinclude.m4, not + ../bfd/aclocal.m4, since we only want bfd's local macros. + + * aclocal.m4: Now automagically generated. Just run aclocal! + + * annotate.c: HP merge, 4/15/98 snapshot + New function. annotate_catchpoint + + * annotate.h: HP merge, 4/15/98 snapshot + New function declaration. annotate_catchpoint + + * annotate.h: taking the new includes (symtab.h and gdbtypes.h). + not taking the ansic C build fix. + + * blockframe.c (blockvector_for_pc_sect): check that the end of + the block is >= to the pc, not just >. + (bpstat_do_actions): if we just set cmd to NULL, don't then try to + set it to cmd->next as we'll SEGV. + + * breakpoint.c (create_temp_exception_breakpoint): #if it out -- + nothing calls it. + (bpstat_stop_status): don't call SOLIB_HAVE_LOAD_EVENT if it's not + defined; don't call SOLIB_HAVE_UNLOAD_EVENT if it's not defined. + (bpstat_get_triggered_catchpoints): if we don't have shared + library support, then don't call SOLIB_LOADED_LIBRARY_PATHNAME nor + SOLIB_UNLOADED_LIBRARY_PATHNAME. + (watch_command_1): don't require a run before a watch command + unless we're on HP [it's an HP OS bug, not a generic limitation] + (catch_load_command_1): don't define if no shared libraries. + (catch_command_1): don't claim to support fork catchpoints unless + CHILD_INSERT_FORK_CATCHPOINT is defined, don't claim to support + vfork catchpoints unless CHILD_INSERT_VFORK_CATCHPOINT is defined, + don't clain to support shared library load catchpoints if shared + libraries aren't supported, and don't claim to support exec + catchpoints unless CHILD_INSERT_EXEC_CATCHPOINT is defined + + (bpstat_do_actions): simplify significantly. It's + now almost as simple as before the merge and it no longer has the + HP bug that breakpoint commands are executed repeatedly. + + (break_at_finish_command_1): rewrite and make sure + selected_frame points to a frame before using it. Fix string + termination error. + (break_at_finish_at_depth_command_1): ditto. + + (can_use_hw_watchpoints): new static variable. + (read_memory_nobpt): test for breakpoint type bp_none. + (insert_breakpoints): test for breakpoint type bp_catch_exec; + insure have a current frame before getting the frame address. + (remove_breakpoints): check for breakpoints of types bp_none, + bp_catch_fork, bp_catch_vfork, and bp_catch_exec. + (bpstat_stop_status): fix updates of b->hit_count. + (bpstat_have_active_hw_watchpoints): new function. + (create_exec_event_watchpoint): new function. + (watch_command_1): use can_use_hw_watchpoints. + (catch_fork_command_1): change name of function to call from + target_create_catch_(v)fork_hook to create_(v)fork_even_catchpoint. + (delete_breakpoint): test for already deleted breakpoints; add + support for bp_catch_fork, bp_catch_vfork, and bp_catch_exec + breakpoints. + (_initialize_breakpoint): add can-use-hw-watchpoints to list of + user settable debugger variables. + + (clear_command): When there is no argument + to the clear command, delete all breakpoints that are hit at + default line. This will include a breakpoint whose line number + does not correspond to the default line, but has been set at + the default address. + + (delete_breakpoint): don't call bpstat_clear_actions, instead + clear things explicitly; if clearing breakpoint_at, then also + clear any associated actions so that bpstat_do_actions won't try + to execute them. + (_initialize_breakpoint): fix function name for bx command. + + (tbreak_command): remove static from declaration. + (maintenance_info_breakpoints): ditto. + + (reattach_breakpoints): new funct definition, used with with + hardware watchpoints + (breakpoint_1): change format and add entries to bptypes[] + (maintenance_info_breakpoints): function is no longer static + + (_initialize_breakpoint): removed a comment. + (exception_catchpoints_are_fragile, + exception_support_initialized): define. + (breakpoint_here_p): fixed syntax error in conditional + (disable_watchpoints_before_interactive_call_start): fixed call to + check_duplicates. Need a section parameter. + (enable_watchpoints_after_interactive_call_stop): fixed call to + check_duplicates. Need a section parameter. + (breakpoint_re_set_one): fixed call to check_duplicates. Need a + section parameter. + (delete_command): fixed syntax error in conditional + (breakpoint_re_set): fixed some typos. + + (args_for_catchpoint_enable): New type for handling exceptions. + (current_exception_event): New variable for handling exceptions. + (insert_breakpoints): check for additional breakpoint types -- + bp_catch_throw, bp_catch_catch, call_disabled. Also, do some + additional work to handle an exception catchpoint. + (remove_breakpoint): there are additional breakpoint types to + check for : bp_catch_throw, bp_catch_catch, call_disabled. Also do + some additional work to remove the exception catchpoints + (breakpoint_init_inferior): new input parameter. If there are + exception catchpoints delete them. + (breakpoint_here_p): there are additional breakpoint enable + settings to check for : shlib_disabled, call_disabled + (breakpoint_thread_match): there are additional breakpoint enable + settings to check for : call_disabled + (ep_is_catchpoint): there are additional breakpoint types to check + for : bp_catch_throw, bp_catch_catch + (ep_is_exception_catchpoint): new function + (bpstat_find_step_resume_breakpoint): new function + (bpstat_do_actions): introduce a local copy of the bpstat + structure. + (print_it_normal): there are additional breakpoint types to check + for : bp_catch_throw, bp_catch_catch Changeing the control + structure a bit (adding else ifs) Add code to print out info about + exceptions. + (bpstat_stop_status): there are additional breakpoint enable + settings to check for : call_disabled. there are additional + breakpoint types to chack for : bp_catch_catch and bp_catch_throw. + Check to see if stopped due to an exception. Minor fixes to the + catch_errors calls. Make sure to count all encountered + breakpoints. There was something funky going on previously with + the counting. + (bpstat_what): Add cases for new breakpoint types : + bp_catch_catch, bp_catch_throw. + (bpstat_get_triggered_catchpoints): Check for new breakpoint types + : bp_catch_catch, bp _catch_throw. + (breakpoint_1): account for new breakpoint types. + (describe_other_breakpoints): account for new breakpoint enable + setting (call_disabled) + (check_duplicates): account for new breakpoint enable setting + (call_disabled) + (disable_breakpoints_in_shlibs): new function + (disable_watchpoints_before_interactive_call_start): new function + (mention): account for new breakpoint types. + (break_command_1): some additional checking for a valid PC. + (watch_command_1): some dditional checking to prevent a watch + before a run command. + (ep_parse_optional_filename): simplified for loop. + (create_exception_catchpoint): new function + (cover_target_enable_exception_callback): new function + (handle_gnu_4_16_catch_command): this used to be thcatch_command_1 + function.e + (create_temp_exception_breakpoint): new function + (catch_command_1): differs from gdb 4.16 and gdb 4.17. Is now + calling catch_exception_command_1 using the EX_EVENT_CATCH and + EX_EVENT_THROW values as parameters. + (clear_command): additional comments + (delete_breakpoint): handle exceptions. Check for additional + breakpoint enable settings : shlib_disabled, call_disabled. + (delete_command): HP folks are claiming that we should not delete + shlib_event breakpoints + (breakpoint_re_set_one): moved call to check_duplicates. Add new + breakpoint types to switch statement. + (breakpoint_re_set_thread): new function + (enable_command): account for new breakpoint types. + + (insertion_state_t): new enumerated type. + (remove_breakpoint): new param in funct prototype. + (insert_breakpoints): check for bp_catch_fork and bp_catch_vfork. + (remove_breakpoints): changed call to remove_breakpoint. + (detach_breakpoints): new function. + (remove_breakpoint): New parameter, is. Also changed the + way b->inserted is set. + (ep_is_catchpoint): New function. + (ep_is_shlib_catchpoint): New function. + (print_it_normal): check for bp_catch_load, bp_catch_unload, + bp_catch_fork, bp_catch_vfork, bp_catch_exec. Also new code + to print out catchpoints properly. + (bpstat_stop_status): check for bp_catch_fork, bp_catch_vfork, + and bp_catch_exec. Also, some code to check for catching a + shared library load/unload. + (bpstat_what): Added catch_shlib_event to class enumeration. + Defined new macro, shlr. Expanded the bpstat_what_main_action + table. Add cases for bp_catch_load, bp_catch_unload, + bp_catch_fork, bp_catch_vfork, and bp_catch_exec. + (bpstat_get_triggered_catchpoints): New function. + (breakpoint_1): changes to bptypes definition. Also check for + bp_catch_load, bp_catch_unload, bp_catch_fork, bp_catch_vfork, + bp_catch_exec. Similar changes to the switch statement. + (set_raw_breakpoint): initialize new breakpoint structure fields. + dll_pathname, triggered_dll_pathname, forked_inferior_pid, + exec_pathname. + (create_solib_load_unload_event_breakpoint): New function. + (create_solib_load_event_breakpoint): New function. + (create_solib_unload_event_breakpoint): New function. + (create_fork_vfork_event_catchpoint): New function. + (create_fork_event_catchpoint): New function. + (create_vfork_event_catchpoint): New function. + (mention): new cases for bp_catch_load, bp_catch_unload, + bp_catch_fork, bp_catch_vfork, bp_catch_exec. + (ep_skip_leading_whitespace): New function. + (ep_find_event_name_end): New function. + (ep_parse_optional_if_clause): New function. + (ep_parse_optional_filename): New function. + (catch_fork_kind): New enumerated type. + (catch_fork_command_1): New function. + (catch_exec_command_1) : New function. + (catch_load_command_1) : New function. + (catch_unload_command_1) : New function. + (catch_throw_command_1) : New function. + (catch_command_1) : now calls catch_throw_command_1. + (tcatch_command) : New function. + (delete_breakpoint) : changed call to remove_breakpoint. + Also free the new fields in the breakpoint structure. + (breakpoint_re_set_one) : handle bp_catch_load, bp_catch_unload, + bp_catch_fork, bp_catch_vfork, bp_catch_exec. + (disable_command): handle bp_catch_load, bp_catch_unload, + bp_catch_fork, bp_catch_vfork, bp_catch_exec. + (enable_command): handle bp_catch_load, bp_catch_unload, + bp_catch_fork, bp_catch_vfork, bp_catch_exec. + (_initialize_breakpoint): Alter add_com call for catchpoints, + add add_com call for watchpoints. + + * breakpoint.h (enum bptype): new entries bp_catch_catch, + bp_catch_throw, and bp_none, bp_catch_load, bp_catch_unload, + bp_catch_fork, bp_catch_vfork,bp_catch_exec. Add declarations for + new functions bpstat_have_active_hw_watchpoints and + create_exec_event_catchpoint. + (tbreak_command): add prototype. + (update_breakpoints_after_exec): add prototype; update comments. + (reattach_breakpoints): new funct prototype declaration. + (enable): new enumerated value call_disabled. + (bpstat_find_step_resume_breakpoint): new funct decl. + (inf_context): new enumerated type. + (breakpoint_re_set_thread): new funct decl. + (breakpoint_init_inferior): new parameter. + (disable_watchpoints_before_interactive_call_start): new funct decl. + (enable_watchpoints_after_interactive_call_stop): new funct decl. + (disable_breakpoints_in_shlibs): new funct decl. + (struct breakpoint) : new fields, dll_pathname,triggered_dll_pathname, + forked_inferior_pid,exec_pathname BPSTAT_WHAT_CHECK_SHLIBS_RESUME_FROM_HOOK. + (bpstat_get_triggered_catchpoints): New function. + (detach_breakpoints): New function. + (create_solib_load_event_breakpoint): New function. + (create_solib_unload_event_breakpoint) New function. + (create_fork_event_catchpoint): New function. + (create_vfork_event_catchpoint): New function. + (ep_is_catchpoint): New function. + (ep_is_shlib_catchpoint) New function. + (enum bpstat_what_main_action) : new entry. + + * buildsym.c (finish_block): get rid of processing_hp_compilation; + handle LOC_INDIRECT case. Set the BLOCK_GCC_COMPILED to the right + compiler. + (push_context): add symbols for parameters to the context_stack. + (merge_symbol_lists): new function. Merges two symbol lists. + (struct context_stack): add new field param. + + (processing_hp_compilation): new external var. + + * c-exp.y: use external flag hp_som_som_object_present to decide + whether code was compiled by HP's compilers. Add two new C++ + tokens for true and false. + (yylex): check for template name is done differently for the + HP/aCC compiler case; change some of the template processing code + for handling HP aCC templates. + + * c-lang.c (c_create_fundamental_type): added case to handle + template args. Handle FT_BOOLEAN type. Set no sign flag for + FT_CHAR. + (cplus_builtin_types): new structure for c++ builtin types. + (cplus_language_defn): use cplus_builtin_types instead of + c_builtin_types. + + * c-lang.h(cp_print_value_fields): update prototype; fixed + prototype decl for c_val_print funct -- it needed an + embedded_offset param; fixed prototype of cp_print_value_fields. + include value.h. + (C_LANG_H): define. + + * c-typeprint.c (c_type_print_base): don't print 'privete' label + for a class if all members are private, similarly don't print + 'public' for a struct. Add support for sized enums (HP/aCC). get + rid of the 'static' keyword printed by the demangler for member + function, when printing the type of a class. 'static' will be + added by this function. If the demangled name is null, and the + method is not stubbed, get the signature by looking at the + information stored in the symbol structure. Remove printing of + 'const' and 'volatile' keywords for methods. This is now taken + care as part of the demangled member names. + (cp_type_print_method_args): new function. To print a C++ method + arguments and name to the output stream. + + (c_type_print_cv_qualifier): new function. Print out "const" and + "volatile" attributes. + (c_type_print_varspec_prefix): print const or volatile qualifiers. + (c_type_print_args): print 'void' for c++. + (c_type_print_varspec_suffix): print 'void' for a no argument + function. + (c_type_print_base): print const or volatile qualifiers. Do not + print 'unnamed union' if HP aCC compiler used. Distinguish + between struct and class based on the DECLARED_TYPE. Handle + HP/aCC compiler case for not printing vtable. Add Template + support. + + (cp_type_print_derivation_info): print out 'protected' when + appropriate. This applies only to HP's compilers, not gcc. + + (c_val_print): added parameter embedded_offset. Add + embedded_offset to valaddr in function calls; fix calls to + val_print and cp_print_value_fields. process TYPE_CODE_METHOD as + well. moved call to check_typedef out of conditional. added + embedded offset param to val_print call. + + (c_value_print): add new parameter to call to val_print. + handle pointer to class case. Attempt to + determine the real type of the object to be printed. + ensure that const char *, const unsigned char * + come out without the type but the volatile variants + and the signed variants don't. + + * ch-lang.h: + Added a parameter to the chill_val_print funct decl + + * coff-solib.c (coff_solib_add): add parameters to call + to symbol_file_add. + + * coff-solib.h: + (SOLIB_REMOVE_INFERIOR_HOOK): new macro. defined to 0. + functionality not implemented for coff. + + * coff-solib.h: + (SOLIB_CREATE_CATCH_LOAD_HOOK): new macro, generate error message + for coff. + (SOLIB_CREATE_CATCH_UNLOAD_HOOK): ditto. + (SOLIB_HAVE_LOAD_EVENT): ditto. + (SOLIB_LOADED_LIBRARY_PATHNAME): ditto. + (SOLIB_HAVE_UNLOAD_EVENT): ditto. + (SOLIB_UNLOADED_LIBRARY_PATHNAME): ditto. + (SOLIB_IN_DYNAMIC_LINKER): ditto. + (SOLIB_RESTART): ditto. + + * command.c (find_cmd): new function. (lookup_cmd_1): call it, + change parsing if tui_version or xdb_commands is set. + (_initialize_command): install new alias if xdb_commands is set. + + * complaints.h: add ifdef...endif pair at beginning and end of file. + + * config.in, configure: Regenerated. + + * config/pa/hppabsd.mh (NATDEPFILES): added new files + hp-psymtab-read.o and hp-symtab-read.o. + * config/pa/hppahpux.mh (NATDEPFILES): ditto. + + * config/pa/hppahpux.mh (TERMCAP): use -lHcurses + * config/pa/hppaosf.mh (NATDEPFILES): ditto. + + * config/pa/hpux1020.mh (TERMCAP): use -lHcurses + (MH_CFLAGS): new flag, -D__HP_CURSES, this define + is used by HP's linker to find the correct curses library + + * config/pa/hpux1020.mh: new file. + + * config/pa/hpux1020.mt: new file. + + * config/pa/hpux1100.mh (TERMCAP): Link against -lcurses, not + -lHcurses. The latter does not contain mvwaddstr, wscrl, or + wstbwlmkfzz. + + * config/pa/hpux1100.mh (TERMCAP): use -lHcurses + (MH_CFLAGS): new flag, -D__HP_CURSES, this define + is used by HP's linker to find the correct curses library + + * config/pa/hpux1100.mh (TERMCAP): when hosting on hpux 11.00, use + -lHcurses rather than -lcurses. + + * config/pa/hpux1100.mh: new file. + + * config/pa/hpux1100.mt: new file. + + * config/pa/nm-hppah.h (CHILD_HAS_SYSCALL_EVENT): new macro + (CHILD_THREAD_ALIVE): new macro + (STOPPED_BY_WATCHPOINT): add a condition to the macro, + ! stepped_after_stopped_by_watchpoint + (TARGET_ENABLE_HW_WATCHPOINTS): new macro + (hppa_enable_hw_watchpoints): new funct decl + (TARGET_DISABLE_HW_WATCHPOINTS): new macro + ( hppa_disable_hw_watchpoints): new funct decl + these are for HP's implementation of fast + watchpoints (via page protection). + (target_pid_to_str): new macro, calls hppa_pid_to_str + (target_tid_to_str): new macro, calls hppa_tid_to_str + + * config/pa/nm-hppah.h (CHILD_POST_WAIT): delete; + (CHILD_CREATE_CATCH_FORK_HOOK): replace with + CHILD_INSERT_FORK_CATCHPOINT and CHILD_REMOVE_FORK_CATCHPOINT. + (CHILD_CREATE_CATCH_VFORK_HOOK): replace with + CHILD_INSERT_VFORK_CATCHPOINT and CHILD_REMOVE_VFORK_CATCHPOINT. + (CHILD_CAN_FOLLOW_VFORK_PRIOR_TO_EXEC, + CHILD_INSERT_EXEC_CATCHPOINT, CHILD_REMOVE_EXEC_CATCHPOINT, + CHILD_HAS_EXECD, CHILD_REPORTED_EXEC_EVENTS_PER_EXEC_CALL, + CHILD_POST_ATTACH, TARGET_HAS_HARDWARE_WATCHPOINTS, + TARGET_CAN_USE_HARDWARE_WATCHPOINT, + TARGET_REGION_SIZE_OK_FOR_HW_WATCHPOINT, + TARGET_RANGE_PROFITABLE_FOR_HW_WATCHPOINT, STOPPED_BY_WATCHPOINT, + HAVE_NONSTEPPABLE_WATCHPOINT, target_insert_watchpoint, + target_remote_watchpoint): new macros.. + + * config/pa/nm-hppah.h (CHILD_XFER_MEMORY): reinsert accidentally + deleted define. + + * config/pa/nm-hppah.h: + (PREPARE_TO_PROCEED): defined macro to use + hppa_prepare_to_proceed + (hppa_pid_to_str): extern decl + (hppa_tid_to_str): extern decl + (target_pid_or_tid_to_str): new macro definition + (hppa_pid_or_tid_to_str): extern decl + (ENSURE_VFORKING_PARENT_REMAINS_STOPPED): new macro - for + handling events caused by a call to vfork. + (hppa_ensure_vforking_parent_remains_stopped): extern decl + (RESUME_EXECD_VFORKING_CHILD_TO_GET_PARENT_VFORK): new macro - + for handling events caused by a call to vfork. + (hppa_resume_execd_vforking_child_to_get_parent_vfork): extern decl + + * config/pa/nm-hppah.h: fix PREPARE_TO_PROCEED macro. + + * config/pa/nm-hppah.h: fix for gcc compile on HPUX + change PT_RDUAREA to PT_RUAREA + + * config/pa/nm-hppah.h: introduced an HPUXHPPA define. + A bit of a hack so that I can ifdef some code that + only works for the HP wildebeest debugger. + + * config/pa/nm-hppah.h: lots of new CHILD_ defines; + process_event_kind enum. + + * config/pa/tm-hppa.h (BREAKPOINT32): new define. + (CALL_DUMMY_HAS_COMPLETED): new define. + + * config/pa/tm-hppa.h (STACK_ALIGN): new macro + (NO_EXTRA_ALIGNMENT_NEEDED): new macro + (PC_REQUIRES_RUN_BEFORE_USE): new macro. + (REGISTER_NAMES): formatting in file changed. + (CR27_REGNUM): base register for thread local storage. + (USE_STRUCT_CONVENTION): new macro used to decide whether + a function returning a value of type type will + put it on the stack or into registers (based on the + PA risc calling conventions). + (EXTRACT_RETURN_VALUE): fixed calculation for extracting return value + (VALUE_RETURNED_FROM_STACK): new macro. + (TARGET_READ_PC): declared the function used in the definition. + (SKIP_TRAMPOLINE_CODE): declared the function used in the definition. + (TARGET_WRITE_PC): declared the function used in the definition. + (TARGET_READ_FP): declared the function used in the definition. + + * config/pa/tm-hppa.h (STRCAT_REGISTER): define macro for + future use. + (pa_do_strcat_registers_info): moved function decl from + defs.h to this HPUX specific .h file. + + * config/pa/tm-hppa.h (USE_STRUCT_CONVENTION): TYPE_LENGTH returns + bytes, not bits; fix off by 8 error. + + * config/pa/tm-hppa.h: + new comment for obj_unwind_info definition + New typedef, obj_private_struct + + * config/pa/tm-hppa.h: delete most target_ macros -- use default + versions instead; remove extraneous comma from proc_wait macro. + + * config/pa/tm-hppa.h: get rid of macro HP_COMPILED_TARGET. + + * config/pa/tm-hppa.h: removed redefinitions of + USE_STRUCT_CONVENTION and STACK_ALIGN macros. + + * config/pa/tm-hppa.h: some new definitions + New macros : ARG0_REGNUM, ARG1_REGNUM, ARG2_REGNUM, ARG3_REGNUM. + target_pid_to_exec_file, target_acknowledge_forked_child, + target_create_catch_fork_hook, target_create_catch_vfork_hook, + target_has_forked, target_has_vforked, require_attach, + require_detach, proc_wait + New funct decls : hppa_pid_to_exec_file, + hppa_acknowledge_forked_child, hppa_create_catch_fork_hook, + hppa_create_catch_vfork_hook, hppa_target_has_forked, + hppa_target_has_vforked, hppa_require_attach, + hppa_require_detach, process_wait + (unwind_table_entry): added comments to describe struct fields. + + * config/pa/tm-hppah.h (somsolib.h): include it. + + * config/pa/tm-hppah.h: + (CHILD_ENABLE_EXCEPTION_CALLBACK): new define + (CHILD_GET_CURRENT_EXCEPTION_EVENT): new define + + * config/pa/tm-hppah.h: Added a #define HPPUX_SNAP2 + + * configure, config.in: Regenerated. + + * configure.host (hppa-*-hpux10.20, hppa-*-hpux11.0*): New configs. + + * configure.in (AC_CHECK_HEADERS): Add check for term.h. + + * configure.in: Add an --enable-tui argument. + + * configure.in: Construct tui/Makefile from tui/Makefile.in. + + * configure.in: Use AM_PROG_CC_STDC. If we have the GUI, then we + need this to process libgui.h. + + * configure: Regenerated. + + * convex-tdep.c (decout): change FILE to GDB_FILE. + + * corefile.c (): add new include "objfiles.h". + (core_file_command): attempt to determine the name of the symbol + file from the core file. (read_memory_string): new function. + + * corefile.c: + (core_file_command): temporary hack to make non-hpux + work. For, non-hpux, t->to_core_file_to_sym_file + does not have a reasonable value. No target_ops vector + on the stack gives it a non-zero value. fix later. + + * corefile.c: add include of symfile.h (needed by objfiles.h). + + * corelow.c: + (core_file_to_sym_file): added new local variable, failing command, + and do some explicit type castings. + (core_ops): add three new fields : to_has_syscall_event, + to_enable_exception_callback, to_get_current_exception_event. + Necessary since we still have oldstyle initialization in + this file + + * corelow.c: HP merge, 4/15/98 snapshot + There are new target_ops vector fields that pertain + only to HPUX. Added the to_require_attach and + to_require_detach fields to core_ops. These new + fields are ifdef'ed for HPUX_SNAP1. + + * corelow.c: More target_ops vector changes for HPUX + (core_ops): new fields. ifdefed for HPUX_SNAP2. New fields are + to_post_wait, to_post_startup_inferior + to_acknowledge_created_inferior, to_clone_and_follow_inferior, + to_post_follow_inferior_by_clone, to_create_catch_fork_hook, + to_create_catch_vfork_hook, to_has_forked, to_has_vforked, + to_post_follow_vfork, to_pid_to_exec_file + + * corelow.c: include unistd.h + (core_file_to_sym_file): new function + (core_file_thread_alive): new function + (core_ops) : added new target ops vector fields. see below. And + yes we definitiely need to initialize them here, as long as + we're using static initialization. + + * corelow.c: remove HPUX_SNAP1 and HPUX_SNAP2 ifdefs + + * cxux-nat.c: + (add_shared_symbol_files): additonal params for calls to + symbol_file_add + + * defs.h + (gdb_file_isatty): new function decl. + + * defs.h (GDB_FILE): if TUI is defined, define a structure rather + than making this an alias for FILE. + (gdb_stdout, gdb_stderr): if TUI is defined, then define these + as pointers to variables of type GDB_FILE rather than making them + be aliases for stdout and stderr. + + * defs.h (TUIDO): add definition conditionalized on definition + (or lack thereof) of TUI. + + * defs.h (command_class): add two additional values. + (precision_type): new enum. + + * defs.h (gdb_fclose): add declaration. + + * defs.h (store_address): change prototype to match function. + + * defs.h (tui_version, xdb_commands, dbx_commands): add decl's. + + * defs.h: + (gdb_file_deallocate): new function declaration + + * defs.h: + (pa_do_strcat_registers_info): new function declaration. + tuiRegs.c currently calls this function directly. This + is not great. Should instead use a macro that is defined + in tm-hppa.h to be mapped to pa_do_strcat_registers_info. + Will change soon. Checking this in so that HP will have + something functional. + + * defs.h: + (streamtype): new enumerated type to distinguish between + output to a FILE and output to a buffer. + (tui_stream): new struct type, named GDB_FILE. Contains, + streamtype, FILE, buffer, and bufferlength fields. + (gdb_stdout): of type GDB_FILE, will pass this around gdb + rather than stdout. + (gdb_stderr): of type GDB_FILE, will pass this around gdb + rather than stderr. + (fputs_unfiltered_hook): change stream parameter from FILE to + GDB_FILE + (flush_hook): change stream parameter from FILE to GDB_FILE + (gdb_fclose): Fix declaration for gdb_fclose; parameter is now of + type GDB_FILE ** + (gdb_file_adjust_strbuf): new function declaration. function lives in + utils.c. + (gdb_file_init_astring): new function declaration. function lives + in utils.c + (gdb_file_get_strbuf): new function declaration. function lives + in utils.c + + * defs.h: Remove pa_do_strcat_registers_info function + declaration. + + * defs.h: additional include files included when TUI is defined. + + * defs.h: funct decl source_full_path_of. + + * demangle.c: add HP_DEMANGLING_STYLE_STRING. + + * demangle.c: added new demangling style, EDG_DEMANGLING_STYLE_STRING, + to the demanglers structure. This is for support of + Kuck & Assoc.'s changes for demangling. + + * eval.c (evaluate_subexp_standard): C++ member function changes. + + * eval.c (evaluate_subexp_standard): verify TYPE_TARGET_TYPE is + non NULL before dereferencing it. + + * eval.c (evaluate_subexp_standard): with HP/aCC compiler it is not possible + to perform inferior calls via function pointers. + Resolve calls to overloaded functions using find_overload_match. + We cannot handle HP/aCC pointers to member functions. + Deal with HP/aCC pointers to members in various kind of expressions. + + * f-lang.c (f_printchar): change FILE to GDB_FILE. + (f_printstr): ditto. + (emit_char): ditto. + + * f-lang.c (f_printstr): change stdout to gdb_stdout. + + * f-typeprint.c (f_print_type): change FILE to GDB_FILE. + (f_type_print_varspec_prefix): ditto. + (f_type_print_args): ditto. + (f_type_print_varspec_suffix): ditto. + (print_equivalent_f77_float_type): ditto. + (f_type_print_base): ditto. + + * findvar.c (): HP snapshot 3 changes. (extract_address): coerce + return value from extract_unsigned_integer to CORE_ADDR. + (store_address): change val from CORE_ADDR to LONGEST; changes to + support machines where CORE_ADDR and LONGEST are different sizes. + (get_saved_register): coerce arg to store_address to LONGEST. + (read_relative_register_raw_bytes): cast last arg to + store_address to LONGEST. (read_register): cast return from + extract_address to a CORE_ADDR. (write_register_pid): change val + from LONGEST to CORE_ADDR. (read_pc_pid): save and restore + inferior_pid if necessary. (write_pc_pid): ditto. + (read_var_value): cast arg to store_address. + + * findvar.c (read_relative_register_raw_bytes_for_frame): new + function. + (read_relative_register_raw_bytes): call it. + + * findvar.c (symbol_read_needs_frame): handle LOC_THREAD_LOCAL_STATIC and + LOC_INDIRECT. + + * fork-child.c (fork_inferior): chenge fifth parameter to be a + function returning void. + + * fork-child.c (fork_inferior): delete unused variable f. + + * fork-child.c: + (STARTUP_WITH_SHELL): new macro -- interim fix for a bug + (breakup_args): new function -- breaks up an argument string into + an argument suitable for passing into execvp(). + (fork_inferior): handling problems with starting up gdb with a shell. + -- again, this appears to be an interim fix. + + * fork-child.c: + (fork_inferior): Added a comment + (clone_and_follow_inferior): new function. + (startup_inferior): minor formatting changes. + + * fork-child.c: + (fork_inferior): HP change is problematic. The -f option has + different meanings for different shells. It is particularly + inappropriate for bourne shells. + + * fork-child.c: + (fork_inferior): added new parameter, pre_trace_fun. + pre_trace_fun is a function pointer. For some targets, + like HPUX, this function gets called to prepare for forking + a child. + + * fork-child.c: + (fork_inferior): fixed call to init_trace_fun + + * fork-child.c: + Moved definition of STARTUP_WITH_SHELL to inferior.h + Added a DEBUGGING macro. Currently set to 0. May remove + later. + breakup_args: add DEBUGGING ifdefs. more sophisticated + parsing to break up args. + (fork_inferior): rename kshell variable to shell. new local + variable, tryname. Make use of STARTUP_WITH_SHELL macro. + More error processing if starting up with a shell. + (startup_inferior): distinguish between starting up with a shell + and not doing so. + + * gdbthread.h: + Declarations for load_infrun_state and save_infrun_state take + an additional parameter. + + * gdbthread.h: Note that sometime between gdb 4.16 and 4.17, + thread.h was renamed gdbthread.h + (load_infrun_state): additional parameters + (store_infrun_state): additional parameters + + * gdbthread.h: include breakpoint.h + + * gnu-nat.c: + (init_gnu_ops): adding new target_ops vector fields and + removing a few. see list below + + * gnu-nat.c: + (init_gnu_ops): initializing new target ops vector fields + to_require_attach, to_require_detach, to_post_wait, + to_post_startup_inferior, to_acknowledge_created_inferior, + to_clone_and_follow_inferior, to_create_catch_fork_hook, + to_create_catch_vfork_hook, to_has_forked, to_has_vforked, + to_post_follow_vfork, to_pid_to_exec_file + (gnu_create_inferior): add param to fork_inferior call + + * hp-psymtab-read.c (QUICK_LOOK_UP): redefine to be 0. + (hpread_build_psymtabs): deal with enums. + (hpread_start_psymtab): include section offset. + (hpread_end_psymtab): take care of offset. + + * hp-psymtab-read.c (TRUE): define. + (FALSE): define. + (file_exists): new function. Checks for existance of file. + (hpread_pxdb_needed): rewrite. + (hpread_quick_traverse): use correct demangling style. + Handle F77 case. + (hpread_get_header): rewrite. + (hpread_get_textlow): add support for DOC_FUNCTION. + (hpread_build_psymtabs): make sure we do the right thing + for pxdb and F77. + + * hp-psymtab-read.c (hpread_pxdb_check): change parenthesis positions. + + * hp-psymtab-read.c (hpread_quick_traverse): compare CORE_ADDR + variable end_addr to 0 instaed of NULL to get rif of gcc warning. + + * hp-psymtab-read.c: + (hpread_get_textlow) : added param to function + Defined convennience macros and some datatypes and variables for + processing the quick lookup-tables. Looks like the code existed + before, but has been munged. + (hpread_pxdb_needed): Major rearrangements of code. Additional local + variables. Also, more extensive checking for various scenarios : + debug info for optimized code vs. unoptimized code, pxdb has been + run vs. pxdb has not been run. + (VALID_FILE): new macro + (VALID_MODULE): new macro + (VALID_PROC): new macro + (VALID_CLASS): new macro + (FILE_START): new macro + (MODULE_START): new macro + (PROC_START): new macro + (FILE_END): new macro + (MODULE_END): new macro + (PROC_END): new macro + (FILE_ISYM): new macro + (MODULE_ISYM): new macro + (PROC_ISYM): new macro + (VALID_CURR_FILE): new macro + (VALID_CURR_MODULE): new macro + (VALID_CURR_PROC): new macro + (VALID_CURR_CLASS): new macro + (CURR_FILE_START): new macro + (CURR_MODULE_START): new macro + (CURR_PROC_END): new macro + (CURR_FILE_ISYM): new macro + (CURR_MODULE_ISYM): new macro + (CURR_PROC_ISYM): new macro + (TELL_OBJFILE): new macro + (pst_syms_struct) : new typedef to keep track of the start/end symbol + table (LNTT) indices of psymtabs created so far. + (pst_syms_count) : new variable + (pst_syms_size): new variable + (told_objfile): new variable + (init_pst_syms): new function. sets up psymtab symbol index stuff. + (clear_pst_syms): new function. clean up psymtab symbol index stuff. + (record_pst_syms): new function. add info about newest psymtab to symbol + index table. + (find_next_pst_start): new function. Find a suitable symbol table index. + (find_next_file_isym): new function + (find_next_proc_isym): new function + (find_next_module_isym): new function + (scan_procs): new function. Scan and record partial symbols for all + functions starting from specified index and in a specified code range. + (hpread_quick_traverse: major rearrangement of code. The function + now uses all the nifty macros. There are some new local variables. + Check for EDG_DEMANGLING style. ifdef out some code for handling F77. + Previously, the function looped over all the modules in the table. + Now, the function loops over all the files, modules, and procedures. + With HP aCC and CTTI, it is possible for a compiled object to have a + file and no module. + (hpread_build_psymtabs): Added a section of code ifdefed by + QUICK_LOOK_UP. It check to see whether or not there are any globals + in the executable. Fix number of params to hpread_start_psymtab call. + Some changes to the way DNTT_TYPE_MODULE is handled. + (hpread_get_textlow): change in signature, minor code changes. The + function finds the low address associated with a specified symbol. + In looking for the address for the symbol avoid going of the end of + the LNTT file. + + * hp-psymtab-read.c: change TRUE to 1 and FALSE to 0. Do some + reformatting. + + * hp-psymtab-read.c: include demangle.h + (trans_lang): new function to let gdb know the correct language. + (hpread_quick_traverse): Use ARM style demangling. + Demangle procedures names. + Use gdb language names instead of hp language names. + Add symbol to list using its demangled name. + + * hp-psymtab-read.c: new file. + (hpread_call_pxdb): new function. Call PXDB to process our file. + (hpread_pxdb_check): new function. Return TRUE if the file needs + pre-processing by PXDB and we have thus called PXDB to do this + processing and the file needs to be re-loaded. + (hpread_quick_traverse): new function. Traverse the quick look-up + tables, building a set of psymtabs. + (hpread_get_header): new function. Get appropriate header from obj + file, based on pxdb type + (hpread_symfile_init): no change from hpread.c + (hpread_build_psymtabs): if there are quick lookup tables, read those, + then scan the global section LNTT. Otherwise, just scan the whole LNTT. + Changed: Add a global function entry to the global partial symbol list. + Handle end of symbols, for QLT case. + In case of TAGDEF, if it is a class or a template, add the name to the + var_namespace, so that it is known as a type by gdb. + In case of CONSTANT, and it is global, add it to the globals. + (hpread_symfile_finish): no change from hpread.c + (hpread_get_lntt): make it not static + (hpread_get_gntt): no change from hpread.c + (hpread_get_slt): make it not static + (hpread_get_textlow): no change from hpread.c + (hpread_start_psymtab): no change from hpread.c + (hpread_end_psymtab): no change from hpread.c + + * hp-symtab-read.c (hpread_get_scope_start): renamed. It was + hpread_get_depth. + (hpread_type_translate): distinguish between signed and unsigned char + types. + (hpread_psymtab_to_symtab): set flag for hp compilation. + (hpread_read_function_type): append symbols for parameters to local + list as well as to the global list. Get the parameters types from the + local list instead of the global list. + (hpread_read_struct_type): add new field num_fn_fields to next_fn_field + structure. Rewrite handling of templates + (hpread_type_lookup): change handling of dntt_type_modifier. + (hpread_process_one_debug_symbol): call hpread_get_scope_start instea + of hpread_get_depth. Handle enum as well. + (hpread_get_scope_depth): new function. Get nesting depth for a + DNTT entry. + + * hp-symtab-read.c (hpread_psymtab_to_symtab): set + processing_gcc_compilation to 0. + + * hp-symtab-read.c (hpread_psymtab_to_symtab_1): change stdout to + gdb_stdout; change fflush to gdb_flush. + (hpread_psymtab_to_symtab): change fflush to gdb_flush. + + * hp-symtab-read.c (hpread_read_enum_type): declare variable. + (hpread_read_struct_type): eliminate references + to 'args' member of fn_field. + + * hp-symtab-read.c (hpread_read_struct_type): a static member + is now indicated by the bitsize field, not the bitpos. + Initialize physname to empty. + (fix_static_member_physnames): use new macros to deal with + physnames. + + * hp-symtab-read.c (hpread_read_struct_type): change references + to bitpos member of struct field to use the FIELD_BITPOS macro. + + * hp-symtab-read.c (hpread_read_struct_type): comment out reference to + obsolete field fn_field.args. + Add struct complaint definitions for complaints. + (hpread_read_struct_type): change call to complain. + (hpread_read_array_type): change call to complain. + (hpread_type_lookup): change call to complain. + (hpread_process_one_debug_symbol): change calls to complain. + (hpread_type_translate): change calls to complain. + + * hp-symtab-read.c (hpread_read_struct_type): make sure bitvector + has been allocated before calling has_vtable. + + * hp-symtab-read.c (hpread_read_struct_type): revert change, + just check for vtable without checking for bitvectors too. + + * hp-symtab-read.c: + (hpread_expand_symtab): change name of local variable from + at_end_of_module to at_module_boundary. + Also, if demangling style is already EDG, do not reset it + to the HP demangling style. + Change at_end_of_module param to hpread_process_one_debug_symbol + call to at_module_boundary. + No longer break out of loop when reach end of module. With CTTI, + the compiler can generate function symbols which are not in + any module. Typically they show up after the end of one + module and before the start of the next module. + (hpread_read_struct_type): check that the debug info for + a TEMPLATE_ARG is correct. + (hpread_process_one_debug_symbol): change name of at_end_of_module_p + param to at_module_boundary_p. + Also set *at_module_boundary_p = -1 if missing a module end and set + it to 1 when finished expanding the debug info. + Handle TLS variable. + + * hp-symtab-read.c: include defs.h, symtab.h, gdbtypes.h, complaints.h. + (fixup_class): new static variable. + (fixup_method): new static variable. + (hpread_get_location): rewrite. + (hpread_has_name): add cases for DNTT_TYPE_DOC_FUNCTION and + DNTT_TYPE_DOC_MEMFUNC + (hpread_expand_symtab): use HP demangling style. + Set hp_som_som_object_present to 1. + (hpread_type_translate): error out if not immediate. Issue warning + if there is an unhandled type code. + (error_in_hpread_type_translate_complaint): remove this structure. + (hpread_read_enum_type): don't assume size of enum is always 4 bytes. + (hpread_read_function_type): add new parameter to indicate a new block. + Do not add the parameters to the symbol list. + If the type was read in earlier, do not modify the type structure. + If we are creating a new block, set the local symbol list to be the + param list. + Need to mark this type as preprocessed. + (hpread_read_doc_function_type): new function. Read and internalize + a native DOC function debug symbol. + (hpread_read_struct_type): a method can be of type doc_function and + doc_memfunc too. + Handle case in which a method is read before its class. Deal with + incomplete method types. + Handle cases in which HP/aCC compiler creates operator names w/o + the 'operator' keyword. Rewrite the loop over the fileds. + (fix_static_member_physnames): new function. Adjust the physnames for + each static member. + (fixup_class_method_type): new function. Fix-up the type structure for a + class. + (hpread_read_array_type): cahnge complaint to warning. + (hpread_type_lookup): add case for DNTT_TYPE_DOC_FUNCTION. + For structures/classes set static member to point to strings with full + names. + Change calls to hpread_read_function_type to pass extra parameter. + (hpread_record_lines): handle case for SLT_NORMAL_OFFSET. + (class_of): new function. Given a function "f" which is a member of a class, + find the classname that it is a member of. + (hpread_process_one_debug_symbol): deal with possible alias field from the + som record for the Function or Entry type. + Do the demangling ourselves if the gdb demangler failed. + Add support for DOC functions. + For function types, add parameters to local list. + (hpread_get_scope_depth): make this function a no-op. + (hpread_adjust_bitoffsets): new function. Adjust the bitoffsets for all + fields of an anonymous union. + (hpread_get_next_skip_over_anon_unions): new function. Skip over anonymous + unions. + + * hp-symtab-read.c: include demangle.h + (hpread_expand_symtab): Ensure we are using ARM-style demangling. + (hpread_process_one_debug_symbol): Set the mangled and demangled + names for functions. + Record the class name to generate the demangled names of member + functions. + + * hp-symtab-read.c: new file. + (hpread_get_depth): no change from hpread.c + (hpread_get_line): no change from hpread.c + (hpread_get_location): no change from hpread.c + (hpread_has_name): make it not static. Return 1 for DNTT_TYPE_BLOCKDATA + and DNTT_TYPE_MEMFUNC. Return 0 for CLASS_SCOPE, REFERENCE,PTRMEM, + PTRMEMFUNC, CLASS, GENFIELD, VFUNC, MEMACCESS, INHERITANCE, + FRIEND_CLASS, FRIEND_FUNC, MODIFIER, OBJECT_ID, TEMPLATE, TEMPLATE_ARG, + FUNC_TEMPLATE, LINK. + (hpread_psymtab_to_symtab_1): no changes from hpread.c + (hpread_psymtab_to_symtab): make it a static function + (hpread_expand_symtab): modified + (hpread_type_translate): if not typep.dntti.immediate do not abort, + but complain and return. Same for default action. Handle more HP_TYPEs. + (hpread_lookup_type): initially allocate a correct-size type-vector. + (hpread_alloc_type): reset type_addr only if a type was allocated. + (hpread_read_enum_type): if this has already a type associated, return. + (hpread_read_function_type): do different things depending on whether + function is a MEMFUNC, a TEMPLATE, a FUNCTION som record. + Do not use the LOC_REGPARM_ADDR symbol class. + (hpread_read_struct_type): handle classes and templates too. Major + rewrite. + (hpread_get_nth_template_arg): new function. + (hpread_read_templ_arg_type): new function. + (hpread_read_set_type): no change from hpread.c + (hpread_read_array_type): modified + (hpread_read_subrange_type): add handling of more DNTT entries. + added support for templates, classes, references, virtual functions. + (hpread_type_lookup): handle DNNT_TYPE_MODULE. + (hpread_record_lines): no changes from hpread.c + (hpread_process_one_debug_symbol): Handle WITH, COMMON, + CLASS_SCOPE. Expand TAGDEF case to handle classes and templates. + + * hppa-tdep.c: + (pa_do_strcat_registers_info): Has a new parameter, precision, + which is passed into the call to pa_strcat_fp_reg to indicate + whether to display the floating point registers using + single or double preceision. + (pa_strcat_registers): Introduce local variable, precision, and + pass it into call to pa_strcat_fp_reg. + (pa_strcat_fp_reg): Modified function. New parameter, precision, + used by function to decide whether to use single or double + precision. Also added the code to put a double precision value + into a buffer. + + * hppa-tdep.c: (): add'l includes <machine/save_state.h>, + <unistd.h>, declare pa_register_look_aside, define is_pa_2. + (rp_saved): check for where to read the return pointer from. + (pa_do_registers_info): handle is_pa_2. (pa_register_look_aside): + new function. (pa_print_registers): handle is_pa_2. + (in_solib_call_trampoline): handle a compiler/linker error. + (skip_trampoline_code): changes to some masks used in examining + instructions. (inst_saves_fr): test for FSTWS instruction. + (skip_prologue): renamed to skip_prologue_hard_way. + (after_prologue): new function. (skip_prologue): new function. + + * hppa-tdep.c (after_prologue): if f is NULL, don't dereference + it. + + * hppa-tdep.c (after_prologue): if no debug info, return zero + telling caller that we need to find the end of the prologue via + the hard way (instruction examination). + + * hppa-tdep.c (find_unwind_entry): avoid dereferencing a null + pointer. + + * hppa-tdep.c (hppa_pid_to_exec_file): deleted -- no longer used. + + * hppa-tdep.c (hppa_prepare_to_proceeed): add prototype. + (read_unwind_info): purecov comments, bug fixes. + (find_unwind_entry): purecov comments, bug fixes. + (find_stub_with_shl_get): purecov comments. + (frame_chain): additional parens. + (hppa_push_arguments): changes to commented out version of routine. + (hppa_fix_call_dummy): purecov comments, fix location of end.o. + (in_solib_call_trampoline): purecov comments. + (in_solib_return_trampoline): purecov comments. + (setup_d_pid_in_inferior): fix location of end.o. + (initialize_hp_cxx_exception_support): fix location of end.o. + (child_enable_exception_callback): purecov comments. + + * hppa-tdep.c: + (pa_do_strcat_registers_info): new routine. called by + tui/tuiRegs.c:_tuiRegisterFormat to place a register name + and value into a string buffer. Interface may change in + future. Checking this in so that we have something + functional for HP. + (pa_strcat_registers): new routine, called by + pa_do_strcat_registers_info. Does same thing as + pa_print_registers except it takes a stream parameter. + This routine should disappear in future. Checking in + so that we have something functional to give HP + (pa_strcat_fp_reg): new routine, called by + pa_do_strcat_registers_info and pa_strvat_registers + to place a floating point register name and value into + a buffer. This interface may change in future. + Checking in so that we have something functional to give HP. + + * hppa-tdep.c: (pa_print_fp_reg): change prototype to match def'n. + (pa_register_look_aside): fix comment immediately before function. + + * hppa-tdep.c: changes to better support stack unwinding, + reading and writing registers for HPUX. The HP folks had + an advantage ... access to a runtime architecture spec ;-}. + New includes : ptrace.h + (internalize_unwinds): initialize new fields in table. + (read_unwind_info): entries in the table are now more complex + structures. References of the form ...->table[index].stub_type + are now ...->table[index].stub_unwind.stub_type. + (find_proc_framesize) : added a check for pc == 0. + (rp_saved): entries in the table are now more complex + structures. References of the form ...->table[index].stub_type + are now ...->table[index].stub_unwind.stub_type. + (frameless_function_invocation): stub_type becomes + stub_unwind.stub_type + (saved_pc_after_call): stub_type becomes stub_unwind.stub_type + (hppa_frame_saved_pc): stub_type becomes stub_unwind.stub_type + (frame_chain_valid): stub_type becomes stub_unwind.stub_type + (hppa_call_dummy): stub_type becomes stub_unwind.stub_type + (pa_print_fp_reg): additional params to call val_print + (in_solib_call_trampoline): stub_type becomes stub_unwind.stub_type + (in_solib_return_trampoline): stub_type becomes stub_unwind.stub_typ + (skip_trampoline_code): additional code to handle external + dyncalls. Also stub_type becomes stub_unwind.stub_type + (hppa_pid_to_exec_file): new funct. FOr HPUX 10.0 and beyond there + is an explicit ptrace request for getting the pathname associated + with a process id (pid). + + * hppa-tdep.c: fix for gcc compile on HPUX + (hppa_pid_to_exec_file): remove unwanted param from + call to call_ptrace. Note, hppa_pid_to_exec_file goes + away in subsequent hp snapshots. + + * hppa-tdep.c: include bfd.h. + include dl.h + (args_for_find_stub): new structure. + (find_unwind_entry): deal with null input pc value. + (rp_saved): ditto. + For the import stub, return -24 always. + (hppa_frame_saved_pc): save old pc value, to detect we are in a loop. + (init_extra_frame_info): use TARGET_READ_FP. + (frame_chain): include thread support. + If the caller's pc is zero, we loose and return, just like stack bottom. + Disable warning about being unable to find unwind info. + (hppa_push_arguments): rewrite. + (hppa_value_returned_from_stack): new function. Handles returning a value + larger that 64 bits, stored on the stack. + (find_stub_with_shl_get): new function. To look up symbols in shlibs. + (cover_find_stub_with_shl_get): new function. Cover routine for + find_stub_with_shl_get to pass to catch_errors. + (hppa_fix_call_dummy): comment out old stub mechanism. Rewrite using dyncall. + (target_read_fp): new function. + (pa_do_registers_info): floating point registers start at FP4. + (pa_print_registers): use FP4_REGNUM instead of 72. + (skip_trampoline_code): do machine instruction matching for PA2.0. + (setup_d_pid_in_inferior): new function. Exception handling support. + (initialize_hp_cxx_exception_support): ditto. + (child_enable_exception_callback): ditto. + (child_get_current_exception_event): ditto. + + * hppah-nat.c (child_post_wait, child_post_follow_vfork, + child_post_follow_inferior_by_clone): new functions. + + * hppah-nat.c (child_xfer_memory): make sure the call to ptrace really + fails before we give up. + (hppa_pid_to_str): new function. Format a process id. + (hppa_tid_to_str): new function. Format a thread id. + + * hppah-nat.c (child_xfer_memory): use xmalloc, not alloca. + (child_post_wait): delete. + (child_post_follow_vfork): delete decl of child_ops; delete + large chunks of function -- let it be handled by the normal + mechanism that notices and handles exec events, in resume(). + + * hppah-nat.c (require_notification_of_exec_events): new function; + just notify of exec events, not all events, and just the specified + pid, don't include it's children (10.20 version). + (child_acknowledge_created_inferior): call new function + require_notification_of_exec_events instead of + require_notification_of_events. + + * hppah-nat.c [!GDB_NATIVE_HPUX_11]: Move HPUX 10.x-specific + support code here from infptrace.c. + + * hppah-nat.c: removed #define ptrace call_ptrace + replaced all calls to ptrace with calls to call_ptrace + (parent_attach_all): removed call to ptrace + + * hpread.c (hpread_psymtab_to_symtab_1): change fflush to + gdb_flush; change stdout to gdb_stdout. + (hpread_psymtab_to_symtab): change fflush to gdb_flush. + + * hpread.h: new file. Includes all includes, struct defs, defines + from hpread.c. + + * infcmd.c + (attach_command): new local variable, exec_file, added code to + determine exec_file from pid if exec_file is not already known, + call new target operation, target_post_attach -- a no-op unless + on HPUXHPPA + (detach_command): after detaching, do a SOLIB_RESTART + + * infcmd.c (objfiles.h): fix typo on include line. + + * infcmd.c (run_command): only call SOLIB_RESTART if it's + defined. + (detach_command): ditto. + + * infcmd.c: + (run_stack_dummy): add calls to + disable_watchpoints_before_interactive_call_start and + enable_watchpoints_after_interactive_call_stops + (finish_command): alter code handling the evaluation and printing + of the target function's return value. + (attach_command): when given a pid, but no exec file, try to determine + the exec file from the process. If the process does not record a + full path name, try to qualify the filename against the source path. + (_initialize_infcmd): add some verbiage about how to use the attach command + + * infcmd.c: + Include objfiles.h + (run_command): If program has already been started, and decide + to restart it, the kill the target, fluch the caches, + call init_wait_for_inferior. Also purge old solib objfiles. + + * infcmd.c: cahnged calls to val_print, using a new macro, + SOLIB_RESTART + (run_command): calls SOLIB_RESTART + (do_registers_info): changed calls to val_print + + * infcmd.c: made the symfile.h include preceed the + objfiles.h include. The other ordering caused a + compile problem (incompletely defined types). + + * inferior.h (REQUIRE_DETACH): Fix default definition. + * inftarg.c (child_post_attach): Fix declaration, make static. + (proc_wait): Make globally visible. + (child_insert_fork_catchpoint, etc): Fix return type. + + * inferior.h (STARTUP_WITH_SHELL): new define. + (START_INFERIOR_TRAPS_EXPECTED): new define + + * inferior.h (fork_inferior): change fifth parameter to be a function + returning void. + + * inferior.h (proc_wait): Declare. + + * inferior.h: + (REQUIRE_ATTACH): new macro + (REQUIRE_DETACH): new macro + (detach): definition is now an extern + (clone_and_follow_inferior): new definition, it's also an extern + + * inferior.h: + (require_attach): default definition for require_attach funct + (require_detach): default definition for require_detach funct + (pre_fork_inferior): new funct decl for function defined in + infptrace.c + (fork_inferior): new parameter in funct decl. + + * inferior.h: + New variable decls : inferior_ignoring_startup_exec_events, + inferior_ignoring_leading_exec_events -- these variables + are used when processing an exec call. + (CALL_DUMMY_HAS_COMPLETED): new default macro -- for targets + where PC in call dummy implies that call dummy has + completed. Note, that on HPUX this inference does not hold. + + * infptrace.c + (require_notification_of_events): new function + (child_acknowledge_created_inferior): previously named + hppa_acknowledge_forked_child. Also calling + require_notification_of_events and clearing some semaphore + variables + (child_post_startup_inferior): new function + (child_create_catch_fork_hook): previously named + hppa_create_catch_fork_hook + (child_create_catch_vfork_hook): previously named + hppa_create_catch_vfork_hook + (child_has_forked) : previously named hppa_target_has_forked + (child_has_vforked): previously named hppa_target_has_vforked + (process_wait): changed to call target_post_wait + (attach): add call to require_notification_of_events + (child_pid_to_exec_file): new function + (hppa_require_attach): new local variable, pt_status + (hppa_get_process_events): new function + + * infptrace.c (call_ptrace): Simplify control flow. + (proc_wait): Move here from inftarg.c, add target_post_wait call. + + * infptrace.c (call_ptrace): add some debugging code. + + * infptrace.c (child_pid_to_exec_file): declare variable. + + * infptrace.c (kill_inferior): clean up call to proc_wait. + + * infptrace.c: + (call_ptrace): when the ptrace request is PT_SETTRC, + call ptrace and then call parent_attach_all. + + * infptrace.c: + (child_has_syscall_event): new function. only applicable + (for now) on HPUX 10.30 and beyond via the ttrace call. + In infptrace.c there is a default operation. + With ttrace, it is possible to tell the kernel to + notify the debugger that the target program is about to make + or return from a syscall. + (child_thread_alive): new function. a default function. + ptrace doesn't support kernel threads. + (hppa_enable_page_protection_events): defualt function + (hppa_disable_page_protection_events): default function + + * infptrace.c: + (child_pid_to_exec_file): fix number of params to cal_ptrace call. + + * infptrace.c: + (hppa_pid_or_tid_to_str): new function + (hppa_switched_threads): new function + (hppa_ensure_vforking_parent_remains_stopped): new function + (hppa_resume_execd_vforking_child_to_get_parent_vfork): new function + + * infptrace.c: Most of the changes found in infptrace.c should + be moved to hppah-nat.c + (PT_VERSION): a new define + (startup_semaphore_t): a new struct type. it is used to + coordinate the parent and child processes after a fork and + before an exec on HPUX. + (call_ptrace): changes to determine whether the ptrace + request is for starting the tracing of the target process. + (parent_attach_all): new funct. used on HPUX for coordinating + the parent and child processes after a fork and before and exec. + (hppa_acknowledge_forked_child) : new funct. prabably belongs + in hppah-nat.c + (hppa_enable_catch_fork) : new funct. probably belongs in + hppah-nat.c + (hppa_disable_catch_fork): new funct. probably belongs in + hppah-nat.c + (hppa_create_catch_fork_hook): new funct. probably belongs in + hppah-nat.c + (hppa_enable_catch_vfork): new funct. probably belongs in + hppah-nat.c + (hppa_disable_catch_vfork): new funct. probably belongs in + hppah-nat.c + (hppa_create_catch_vfork_hook): new funct. probably belongs to + hppah-nat.c + (hppa_target_has_forked): new funct. probably belongs in + hppah-nat.c + (hppa_target_has_vforked): new funct. probably belongs in + hppah-nat.c + (process_wait): new funct. also ifdefed for proc_wait. + (kill_inferior): call proc_wait rather than wait. this is + pretty hacky. + (pre_fork_inferior): new function. used only by HPUX. + probably should be defined elsewhere. + + * infrun.c (follow_inferior_fork): only define on HP. + (wait_for_inferior): only call SOLIB_IN_DYNAMIC_LINKER if we have + shared libraries; restore test of IN_SOLIB_DYNSYM_RESOLVE_CODE + removed by HP. + + * infrun.c (normal_stop): Add a call to the TUIDO + macro just before the annotate_stopped label. This + updates the windows after each program stop. + + * infrun.c (normal_stop): verify stop_command is non-zero before + dereferencing it (it won't be set if dbx_commands is set). + + * infrun.c (resume): Add #ifdef HPPAHPUX around HPUX-specific + code. + + * infrun.c (resume): add missing semicolon. + + * infrun.c (wait_for_inferior): fix syntax error. + + * infrun.c: + (follow_fork): eclosed calls to target_require_detach and + target_require_attach with HPUX_SNAP1 ifdef + + * infrun.c: + (follow_fork_mode_kind_names) : removed "both" option + (follow_fork): added parameters. additional code for handling + following of parent, following of child + (resume): added code for deciding how to resume in presence of + fork. Additional params to follow_fork call. + + * infrun.c: + (follow_exec): ifdef for HPUXHPPA for the moment, the + code in here assumes the existance of the child_ops + target vector. This is incorrect for Solaris. + + * infrun.c: + (resume): fixed ifdefs, HPPAHPUX -> HPUXHPPA + + * infrun.c: + (wait_for_inferior): fixed a matching parenths problem -- + matching curly brace inside ifdefed code which is not being + compiled. Change local validFlag to be an 'int' rather than + a 'bool' and fixed the corresponding assignment statements. + + * infrun.c: + Two new global variables: inferior_ignoring_startup_exec_events and + inferior_ignoring_leading_exec_events. + New static variables: parent_of_vfork_trap_expected_and_ignorable, + step_resume_breakpoint, through_sigtramp_breakpoint, pending_follow, + follow_vfork_when_exec + (follow_inferior_fork): does what follow_fork did! + (follow_fork): is now a wrapper function for follow_inferior_fork + (follow_vfork): is now a wrapper function for follow_inferior_fork + (follow_exec): new function, handles an exec event. + (resume): remove 3 local variables: child_pid, has_forked, has_vforked. + move and expand code that tries to follow a fork (i.e. also check + for vfork and exec + (init_wait_for_inferior): initialize the new structure, pending_follow + (delete_breakpoint_current_contents): when deleting all the breakpoints also + set the breakpoint struct pointer to NULL. + (wait_for_inferior): a number of changes. + The step_resume_breakpoint and through_sigtramp_breakpoint local + variables are now visible in entire module. + Changed name of variable from child_inferior_pid to saved_inferior_pid. + Added several cases to the event processing switch statement: + TARGET_WAITKIND_FORKED, TARGET_WAITKIND_VFORKED, TARGET_WAITKIND_EXECD. + Also, for TARGET_WAITKIND_STOPPED, check to see if expecting a trap + from the parent of a vfork (ignorable) otherwise break as usual. + When determining the value of 'random_signal' (0 or 1), no longer check for + catchpoints. + When determining how to handle unexpected signals, must now take into + account fork, vfork, and exec. + Change call to PC_IN_CALL_DUMMY to a call to CALL_DUMMY_HAS_COMPLETED + At stop_stepping label, check to see if stopped for fork or + vfork event. + + * infrun.c: New code is related to threads and fork/vfork/exec. + New static variable : thread_step_needed + Deleted static variable : parent_of_vfork_trap_expected_and_ignorable + Altered the pending_follow and fork_event structs + (follow_inferior_fork): Before detaching from child and removing + all breakpoints form it -- but only if forking or following + vforks as soon as they happen. Also reset the solib inferior hook. + The same kind of logic applies to hitting step_resume_breakpoints + (calling breakpoint_re_set_thread) and to resetting and inserting + breakpoints. + (follow_exec): forward decl + (follow_vfork): check to see if gdb followed the child. If + the child exec'd before gdb saw the parent's vfork event + then call follow_exec. + (follow_exec): if the exec occured after a vfork, then follow + the vfork as well. Do it before following the exec. + Make sure to update breakpoints after and exec + (resume): new local variable, should_resume. + Change parameters in calls to follow_fork, follow_vfork, and + follow_exec. Some changes to the way various pending_follow.kind + situations are handled (there's TARGET_WAITKIND_FORKED, + TARGET_WAITKIND_VFORKED, ARGET_WAITKIND_EXECD. Some additional + conditions to check before deciding to resume the target (i.e. + should_resume=1, stepping?, thread_step_needed?i, regular + resume?) + (proceed): When proceeded at location that does not have a breakpoint + set thread_step_needed=0 to indicate that it is not necessary to + single step thread over breakpoint. SOme additional checks to see + if it is necessary to step thread over breakpoint. + (start_remote): remove call to clear_proceed_status. + (init_wait_for_inferior): initialize new fields in fork_event + structure and add a call to clear_proceed_status. + (wait_for_inferior): new local variable : new_thread_event. + Initialize thread_step_needed = 0. + Minor massaging of conditions for adding a new thread to the thread list. + No longer resuming execution after adding a new thread. Let user play with thread first. + Some changes in the way TARGET_WAITKIND_FORKED, ARGET_WAITKIND_VFORKED, + TARGET_WAITKIND_EXECD are handled -- this is all HPUX related. + Simplified TARGET_WAITKIND_STOPPED -- HP previously had some + more complicated code in here. + Moved the code to resume threads to after the large case statement that processes the events. + Additional processing for stop_signal=TARGET_SIGNAL_TRAP. + Cleanup code at process_event_stop_test label. + Set thread_step_needed when processing a BPSTAT_WHAT_SINGLE. + Minor massaging of fork/vfork/exec part of stop_stepping code. + (normal_stop): minor changes. calling show_and_print_stack_frame. + (xdb_handle_command): new function + (_initialize_infrun): handle xdb_commands. also handle dbx commands + + * infrun.c: changes to support following forks, and handling + catchpoints. + (follow_fork_mode_kind_names): new array + (follow_fork): new function. implements the follow parent, + or child functionality. + (resume): additions to check whether the target process + just forked and decide which process to follow. + (wait_for_inferior): additional variables (child_inferior_pid, + stepping_through_solib_after_catch, + - stepping_through_solib_catchpoints. + - Altered CURRENTLY_STEPPING macro to check for stepping through + a shared library after hitting a catchpoint. + - Add parameters to save_infrun_state call + - Check for fork and vfork when deciding if event is a random + signal + - When considering stops due to breakpoints, check for + BPSTAT_WHAT_CHECK_SHLIBS_RESUME_FROM_HOOK + - Check for stop due to an explicit catchpoint + - When checking for single stepping event, also check for + stepping to get out of dynamic linker's hook after catching + a shlib event + (is_internal_shlib_eventpoint): new funct. check to see if + event type is bp_shlib_event. + (stopped_for_internal_shlib_event): new funct. check for shlib + events + (stopped_for_shlib_catchpoint): new funct. check for catchpoints. + (normal_stop): additions to check for shlib event + (set_follow_fork_mode_command): new funct. handles the new follow + fork command. + (_initialize_infrun): additions for follow-fork-mode command. + + * infrun.c: ifdefing references to + switched_from_inferior_pid for HPUXHPPA. They don't seem + useful for Solaris (i.e. non-HPUX) + + * infrun.c: included tuiData.h and tuiDataWin.h, ifdefed for TUI. + Included top.h. New static variables : switched_from_inferior_pid, + number_of_threads_in_syscalls. + (follow_inferior_fork): If there is a step_resume breakpoint + explicitly reset the thread number. + (resume): For TARGET_WAITKIND_VFORKED, removed a check for getting + the vfork event to soon. + (init_wait_for_inferior): added parameter to call to + breakpoint_init_inferior. Initialize number_of_threads_in_syscalls. + (wait_for_inferior): New local variables : prev_sal, + enable_hw_watchpoints_after_wait, stepping_through_sigtramp, + stepped_after_stopped_by_watchpoint. Enable watchpoints after a wait. + Added cases for TARGET_WAITKIND_SYSCALL_ENTRY and + TARGET_WAITKIND_SYSCALL_RETURN. + Do additional processing if stop due to breakpoint, but breakpoint is + only valid for a thread other than the one currently running. Additional + parameters to save_infrun_state and load_infrun_state. Some additional + processing for BPSTAT_WHAT_STEP_RESUME. Some additional processing to + handle stepping over a function. + (normal_stop): added notification of switching threads. ifdefing some + TUI changes and leaving out non-essential TUI changes. + (restore_selected_frame): ifdefing some TUI changes + (restore_inferior_status): ifdefing some TUI changes + + * infrun.c: remove HPUX_SNAP1 and HPUX_SNAP2 ifdefs + + * infrun.c: removed the TUI ifdefs and TUI code. Also removed + include for top.h. HP introduced this. I'm taking it out. + + * inftarg.c (child_detach_from_process): declare. + (child_attach_to_process): declare. + (child_stop): make static to match declaration. + + * inftarg.c (ptrace_him): change prototype back to return int. + + * inftarg.c (ptrace_me): Remove debug output, pass NULL to + fork_inferior if not HPUX. + + * inftarg.c: + (child_require_attach): new funct prototype and definition + (child_require_detach): new funct prototype and definition + (proc_wait): funct prototype and definition are enclosed by + proc_wait ifndef + (child_attach_to_process): new function, does most of the + work that child_attach used to do and some additional + work to determine whether gdb is already attached to the + target how to react. + (child_attach): altered. It's now a wrapper for + child_attach_to_process. + (child_require_attach): new function, called if should attach + even when gdb is already attached to target. + (child_detach_from_process): new function, does most of the + work that child_detach used to do and some additional work + to determine whether gdb is currently attached to the target. + (child_detach): altered. It's now a wrapper for + child_detach_from_process. + (child_require_detach): new function, called if should try to + detach even when gdb is not attached to target. + (ptrace_him): calls a new function, target_acknowledge_forked_child. + Currently, target_acknowledge_forked_child, is only defined to + do something for HPUX. + (child_create_inferior): changed call to fork_inferior. + (child_ops): added to_require_attach and to_require_detach fields + to the child_ops target ops vector. + + * inftarg.c: + Some hacks for ttrace work + (child_wait): Additional local variables, additional code in + while loop to check for : process exited, process forked, + process vforked, process execd + (child_thread_alive): John B. seems to think that the kill + call is inapproapriate for HPUX. + (child_attach_to_process): using strtol rather than atoi. + no longer check for case where there is no known exec file. + (child_post_attach): new function, a default, a no-op + (child_insert_fork_catchpoint): new function, a default, a no-op + (child_remove_fork_catchpoint): new function, a default, a no-op + (child_create_catch_fork_hook): deleted + (child_create_catch_vfork_hook): deleted + (child_insert_vfork_catchpoint): new function, a default, a no-op + (child_remove_vfork_catchpoint): new function, a default, a no-op + (child_can_follow_vfork_prior_to_exec ):new function, a default, + a no-op + (child_insert_exec_catchpoint): new function, a default, a no-op + (child_remove_exec_catchpoint): new function, a default, a no-op + (child_has_execd): new function, a default, returns 0 + (child_reported_exec_events_per_exec_call): new function, a + default, returns 1 + (child_has_exited): new function, a default. + (child_core_file_to_sym_file): new function, a default, returns NULL. + (child_ops): initialize new target_ops vector fields to the + child* functions. + * infptrace.c: + (call_ptrace): for HPUX, handle additional requests : PT_CONTIN1, + PT_STEP1. + (require_notification_of_events): add several signals to the + set of events requiring notification : PTRACE_SIGNAL, + PTRACE_EXEC, PTRACE_FORK, PTRACE_VFORK + (child_acknowledge_created_inferior): This function is only + defined if CHILD_ACKNOWLEDGE_CREATED_INFERIOR is defined. + (child_post_startup_inferior): function is only defined if + CHILD_POST_STARTUP_INFERIOR is defiend. Also, now call + require_notification_of_events. + (child_create_catch_fork_hook): deleted + (child_create_catch_vfork_hook): deleted + (child_insert_fork_catchpoint): new function + (child_remove_fork_catchpoint): new function + (child_insert_vfork_catchpoint): new function + (child_remove_vfork_catchpoint): new function + (child_has_forked): now enclosed by a CHILD_HAS_FORKED ifdef + (child_has_vforked): now enclosed by CHILD_HAS_VFORKED ifdef + (child_can_follow_vfork_prior_to_exec): new function + (child_insert_exec_catchpoint): new function + (attach): removed call to require_notification_of_events + (child_post_attach): new function, call to + require_notification_of_events moved here. + (child_pid_to_exec_file): new enclosed by CHILD_PID_TO_EXEC_FILE ifdef + introduced the concept of a saved_inferior_pid + (hppa_require_attach): Add some code to decide if gdb is already + attached to process. Can not figure this out via a ptrace call. + (hppa_insert_hw_watchpoint): new function + (hppa_remove_hw_watchpoint): new function + + * inftarg.c: + (child_attach_to_process): change position in file + (child_detach_from_process): change position in file + + * inftarg.c: + (child_attach_to_process): changed parameter to child_wait call + + * inftarg.c: + (child_post_wait): new function declaration and definition + (ptrace_him): + - change return value to a void. + - change target_acknowledge_forked_child call to + target_acknowledge_created_inferior + - call target_post_startup_inferior rather than returning pid. + (child_attach_to_process): change param name, fail_if_already_attached + -> after_fork. + Invert a couple of if-then-else statments. + Use REQUIRE_ATTACH macro + (child_attach): change params in child_attach_to_process call + (child_require_attach): change params in child_attach_to_process call + (child_detach_to_process): change param name, + fail_if_already_attached -> after_fork. + Invert a couple of if-then-else statments. + Use REQUIRE_DETACH macro + (child_detach): change params in child_detach_from_process call + (child_require_detach): change params in child_detach_from_process + call + (child_post_startup_inferior): new function + (child_acknowledge_created_inferior): new function + (child_clone_and_follow_inferior): new function + (child_post_follow_inferior_by_clone): new function + (child_create_catch_fork_hook): new function + (child_create_catch_vfork_hook): new function + (child_has_forked): new function + (child_has_vforked): new function + (child_post_follow_vfork): new function + (child_stop): no longer a static function + (child_pid_to_exec_file): new function + + * inftarg.c: + (child_wait): child_pid becomes related pid. return pid + rather than inferior_pid. Changes are in code handling fork + and vfork + + * inftarg.c: + Include gdb_stat.h and sys/unistd.h + (child_wait): new local variables. Check for live threads. + Check for syscall events + (child_thread_alive): no longer a static funct. + (ptrace_him): remove some code inserted in snap3 + (child_create_inferior): added a bunch of code to handle a + bad interaction between start-up-with-shell and the HP + catch-fork/catch-exec logic. I am ifdefing this for + HPUXHPPA for now. + (child_has_syscall_event): new default target_ops function + (child_enable_exception_callback): new default target_ops function + (child_get_current_exception_event): new default target_ops function + (child_ops): 3 new fields + + * inftarg.c: remove HPUX_SNAP1 and HPUX_SNAP2 ifdefs + + * inftarg.c: reverted previous change. + + * infttrace.c (hppa_remove_hw_watchpoint): fix check for write + access hardware watchpoint. + + * infttrace.c (proc_wait): Rename from proc_wait. + + * infttrace.c (require_notification_of_exec_events): new function; + just notify of exec events, not all events, and just the specified + pid, don't include it's children. + (child_acknowledge_created_inferior): call new function + require_notification_of_exec_events instead of + require_notification_of_events. + (child_post_startup_inferior): call require_notification_of_events + + * infttrace.c: changed all references to boolean to int. + Changed all references to TRUE and FALSE to 1 and 0. + + * irix5-nat.c: + (symbol_add_stub): add params to call to symbol_file_add. + + * jv-lang.c: + (get_dynamics_objfile): add 2 more parameters to call to + allocate_objfile. + + * m3-nat.c: + (m3_create_inferior): add param to fork_inferior call + (m3_pid_to_exec_file): new function + (m3_ops): initializing new target ops vector fields. see list below. + + * m3-nat.c: + (m3_ops): adding new target_ops vector fields and + removing a few. see list below + + * main.c: + (fputs_unfiltered): changes to prevent cursor form jumping around + in the TUI. Altered where tuiTermUnsetup and tuiTermSetup are + called + + * main.c (fputs_unfiltered): Changed function so that it + checks to see if output is to a string buffer or to a + FILE stream and does the correct action (i.e. strcat or + fputs). Fixed params for fputs call. + + * main.c (fputs_unfiltered): Don't try to call the TUI's + CommandCharCount functions when the TUI isn't enabled. + + * main.c (fputs_unfiltered): change FILE to GDB_FILE. + + * main.c (main): If the user asks for the TUI, then disable + GDB/Tk. + + * main.c (main): If the user gives the --version or --help flags, + disable the TUI. + + * main.c (tui_version, xdb_commands, dbx_commands): new variables. + (main): new command line arguments --tui, --xdb, --dbx; add call + to tyiCleanUp via tuiDo to main loop. + (fputs_unfiltered): tui related changes. + + * main.c: + Define 2 new global variables, gdb_stdout and gdb_stderr of type GDB_FILE. + (main): Allocate space for and initialize gdb_stdout and gdb_stdin. + + * objfiles.c (find_pc_sect_section): make end condition be less + than s->endaddr, not less than or equal to s->endaddr. + + * objfiles.c: + (allocate_objfile): 2 new parameters : user_loaded and is_solib. + When appropriate, record in the object file that it is user loaded. + The run command can use this information to purge object file + entries associated with the old inferior and keep user loaded + object files loaded via the add-symbol-file command. + (objfile_purge_solibs): new function. deletes all objectfile entries + that are not explicitly loaded by the user. + + * objfiles.c: + (objfile_relocate): check for LOC_INDIRECT + (find_pc_sect_section): change condition from + pc < s->endaddr to pc <= s->endaddr + + * objfiles.h: + New variables : user_loaded and is_solib + (OBJF_SHARED): new macro. used to distinguish objfile for + shared library from "vanilla" objfile. + (allocate_objfile): add new parameters to function decl. + (objfile_purge_solibs): new function decl. + + * objfiles.h: Add some typedefs : ImportEntry, ExportEntry. + Add some new variables : import_list, import_list_size, + export_list, export_list_size + + * osfsolib.c: + (symbol_add_stub): added params to call to symbol_file_add + + * pa/hpux1020.mh (NATDEPFILES): Add corelow.o, symbol table and + solib files. + + * pa/hpux1100.mh (NAT_FILE): Use nm-hppah11.h. + (NATDEPFILES): Add symbol table and solib files. + + * pa/nm-hppah11.h: New file, HPUX11-only definitions. + + * pa/tm-hppa.h (proc_wait): Remove decl and macro. + + * parse.c (write_dollar_variable): handle cases in which variables + besides the debugger ones start with $ and $$. + (parse_nested_classes_for_hpacc): new function. Parse a string that + is possibly a namespace / nested class specification. + (find_template_name_end): new function. + + * procfs.c: + (procfs_init_inferior): return value is now a void. + + * procfs.c: + (procfs_ops): initializing new target ops vector fields. see list below. + + * procfs.c: + (procfs_ops): adding new target_ops vector fields and + removing a few. see list below + + * procfs.c: added new fields to procfs_ops. + Necessary since we still have oldstyle initialization in + this file + + * pyr-tdep.c (pyr_do_registers_info): change stdout to gdb_stdout. + (frame_locals_address): change stderr to gdb_stderr. + (frame_args_addr): ditto. + + * pyr-xdep.c (fetch_inferior_registers): change stderr to + gdb_stderr. + + * remote-udi.c: + (init_udi_ops): adding new target_ops vector fields and + removing a few. see list below + + * remote-udi.c: + (init_udi_ops): initializing new target ops vector fields. see list below. + + * remote-udi.c: + (udi_load): fixed params in call to symbol_file_add + + * remote-vx.c: + (vx_add_symbols): fixed params in call to symbol_file_add + + * remote-vx.c: + (init_vx_ops): adding new target_ops vector fields and + removing a few. see list below + (init_vx_run_ops): ditto + + * remote-vx.c: + (init_vx_ops): initializing new target ops vector fields. see list below. + (init_vx_run_ops):initializing new target ops vector fields. see list below. + + * serial.c (serial_close): call gdb_fclose, not fclose on a + GDB_FILE. + + * serial.c (serial_logchar): change chtype to ch_type. sigh. + + * solib.c (look_for_base): the parameter to file must be + of type FILE *. So cast exec_bfd -> iostream in the call + to fileno as a FILE *, not a GDB_FILE *. This will work because + exec_bfd -> iostream is declared and given a value in bdf and + bfd will continue to use FILE rather than GDB_FILE. + + * solib.c: + (solib_add): remove references to exec_ops. + + * solib.c: + (solib_add): update exec_ops.to_sections + + * solib.c: + (symbol_add_stub): added params to call to symbol_file_add + + * solib.h: + (SOLIB_REMOVE_INFERIOR_HOOK): new macro. defined to 0. + functionality not implemented for this target. + + * solib.h: Added macro definitions. These macros generate + error messages for solaris?? + (SOLIB_CREATE_CATCH_LOAD_HOOK) + (SOLIB_CREATE_CATCH_UNLOAD_HOOK) + (SOLIB_HAVE_LOAD_EVENT) + (SOLIB_LOADED_LIBRARY_PATHNAME) + (SOLIB_HAVE_UNLOAD_EVENT) + (SOLIB_UNLOADED_LIBRARY_PATHNAME) + (SOLIB_IN_DYNAMIC_LINKER) + (SOLIB_RESTART) + + * somread.c (is_in_import_list): ditto. + + * somread.c (som_symfile_read): added some comments + + * somread.c (som_symfile_read): read in import and export lists. + (som_symtab_read): change test for dynamic executable. + (is_in_import_list): new function. Check if a given symbol name + is in the import list. + (init_import_symbols): new function. Read in and initialize the + som import list. + (init_export_symbols): new function. Read in and initialize the + som export list. + + * somread.c: + (som_symfile_read): fix missing comment delimiters + + * somsolib.c (DLD_FLAGS_MAPPRIVATE): new macro. + Define bit of __dld_flags in HP-UX a.out files. + (DLD_FLAGS_HOOKVALID): ditto. + (DLD_FLAGS_LISTVALID): ditto. + (DLD_FLAGS_BOR_ENABLE): ditto. + (som_solib_total_st_size): cumulative size in bytes of the + symbol tables of all shared objects on the so_list_head list. + (som_solib_st_size_threshhold_exceeded): threshold for adding symbols + for shlibs. + (som_solib_sizeof_symbol_table): new function. Computes size of + symbol table for a shlib. + (som_solib_load_symbols): new function. Load symbols from shlib. + (som_solib_add): detect if __dld_list is not valid. + Record main program's symbol table size. + Load symbols if called from command line. + Keep threshold into account when loading shlib symbols. + (som_solib_create_inferior_hook): use dld_flags macros. + (som_sharedlibrary_info_command): let user know if symbols were + not loaded. + (som_solib_restart): discard all the shlibs descriptors. + (_initialize_som_solib): chenge help message for auto-solib-add + command. + Set threshold for symbol table to 50 megabytes. + + * somsolib.c (_initialize_som_solib): added call to som_solib_restart. + (som_solib_restart): new function + (som_solib_in_dynamic_linker): new function + (som_solib_desire_dynamic_linker_symbols): new function + (som_solib_unloaded_library_pathname): new function + (som_solib_loaded_library_pathname): new function + (som_solib_library_pathname): new function + (som_solib_have_unload_event): new function + (som_solib_have_load_event): new function + (som_solib_create_catch_unload_hook): new function + (som_solib_create_catch_load_hook): new function + (som_solib_create_inferior_hook): rewritten + dld_cache: new struct + addr_and_unwind_t: new struct + (find_unwind_entry) added prototype + + * somsolib.c (som_solib_create_inferior_hook): introduce new local + msymbol2 and change some msymbol's to msymbol2's -- was clobbering + msymbol, passing a NULL to lookup_minimal_symbol_solib_trampoline, + and ultimately core dumping with a SEGV. + + * somsolib.c: + Include assert.h + (som_solib_mapped_entry): additional comments for text_addr, + text_link_addr, text_end, and tsd_start_addr fields. Commenting + out 2 tsd fields, __data_start and __data_end. + (som_solib_add_solib_objfile): add params to calls to symbol_file_add. + Add some code for distinguishing between a shared library and other + objfiles. This appears to be a prelude to thread local storage. + (som_solib_load_symbols): changes to printf statement + enclosed by SOLIB_DEBUG ifdef. + (som_solib_add): change comment to correctly specify path + to end.o -- /opt/langtools/lib/end.o. changes to printf statement + enclosed by SOLIB_DEBUG ifdef. + Removed several SOLIB_DEBUG ifdefs and the associated printfs. + Add code to find the start address for the object file's thread + local storage + (som_solib_create_inferior_hook): Fix warning messages use correct + path to end.o -- /opt/langtools/lib/end.o. Change control flow. + No longer user early returns from function is cases of error. + (reset_inferior_pid): new function + (som_solib_remove_inferior_hook): new function + (so_lib_thread_start_addr): new function. used for tsd. + + * somsolib.c: Removed references to ASSERT macro. + + * somsolib.c: add debugging macro. + (struct som_solib_mapped_entry): add new field tsd_start_addr. + (struct so_list): added new field solib_addr. + (som_solib_add_solib_objfile): new function. + (som_solib_load_symbols): rewritten. + (som_solib_add): make sure we don't load the symbols in if the + threshold was exceeded. + (som_solib_get_solib_by_pc): new function. Return the address of + handle of the shared library. + (som_solib_restart): disable breakpoints at restart. + (_initialize_som_solib): set threshold to 100 megabytes. + + * somsolib.c: add include of fcntl.h so that O_RDONLY is defined. + + * somsolib.h (DISABLE_UNSETTABLE_BREAK): new macro. + (PC_SOLIB): new macro. + + * somsolib.h: + (SOLIB_CREATE_CATCH_LOAD_HOOK): define + (SOLIB_CREATE_CATCH_UNLOAD_HOOK): define + (SOLIB_HAVE_LOAD_EVENT): define + (SOLIB_LOADED_LIBRARY_PATHNAME): define + (SOLIB_HAVE_UNLOAD_EVENT): define + (SOLIB_UNLOADED_LIBRARY_PATHNAME): define + (SOLIB_IN_DYNAMIC_LINKER): define + (SOLIB_RESTART): define + + * somsolib.h: + (SOLIB_REMOVE_INFERIOR_HOOK): new macro. defined to use + som_solib_remove_inferior_hook. + + * somsolib.h: + (som_solib_create_catch_load_hook) + (som_solib_create_catch_unload_hook) + (som_solib_have_load_event) + (som_solib_loaded_library_pathname) + (som_solib_have_unload_event) + (som_solib_unloaded_library_pathname) + (som_solib_in_dynamic_linker) + Fix prototypes to use type names, not parameter names. + + * source.c (find_source_lines): make non static. + (open_source_file): ditto. + (source_full_path_of): new function. + (print_source_lines): rename to print_source_lines_base and make + static; formatting. + (print_source_lines): new function. + (forward_search_command): tui changes. + (reverse_search_command): tui changes. + (_initialize_source): add xdb and dbx compatibility commands. + + * source.c (list_command): handle case of odd number of source + lines to display. + + * source.c: + (source_full_path_of): new function. file was overlooked + in merge ;-/. + + * stack.c (func_command): make high bound be <, not <=. + + * stack.c (_initialize_stack): for the backtrace command, delete + the help line about usage, since this has to be a valid help + message for the 'where' command too. + + * stack.c (current_frame_command): add a check for the + existance of a stack. If there is no stack produce an + error message and exit. + + * stack.c (down_silently_base, up_silently_base, + args_plus_locals_info, print_frame_info_base, + print_stack_frame_base, print_stack_frame_base_stub): declare. + (print_frame_local_vars): add'l parameter. + (print_stack_frame_stub): new version created, old version renamed + to show_and_print_stack_frame_base_stub. + (print_stack_frame_base_stub, print_only_stack_frame_stub, + show_and_print_stack_frame, print_only_stack_frame, + stack_publish_stopped_with_no_frame, print_frame_info, + show_stack_frame, backtrace_full_command, args_plus_locals_info, + select_and_print_frame, select_and_maybe_print_frame, + current_frame_command, func_command): new functions. + (backtrace_command): new function, old renamed to + backtrace_command_1. + (print_block_frame_locals, print_frame_local_vars): additional + parameter, number of tabs. + (up_silently_command): new function, old renamed to + up_silently_command_base. + (down_silently_command): new function, old renamed to + down_silently_base. + (_initialize_stack): register new commands based on values of + xdb_commands and dbx_commands variables. + + * stack.c (func_command): make high bound be <, not <=. + + * stack.c (parse_frame_specification): fix prototype to match + function definition. + (show_and_print_stack_frame_stub): fix name. + (select_and_print_frame): change uncaught tuiDO call. + + * stack.c (up_silent_base): rename from up_silently_command_base. + + * symfile.c (symbol_file_command): only call SOLIB_RESTART if it's + defined. + + * symfile.c (add_psymbol_with_dem_name_to_list): new function. + Adds a symbol with a long value to a psymtab. Differs from + add_psymbol_to_list in taking both a mangled and a demangled name. + + * symfile.c (compare_psymbols): call strcmp directly, instead of + using macro. + + * symfile.c (symbol_file_add): reindent portions. + (symbol_file_command): add call to tuiDo. + + * symfile.c (symbol_file_command): only call SOLIB_RESTART if it's + defined. + + * symfile.c (symfile_bfd_open): add code to call PXDB on hpux, if + the file has not already been processed by pxdb. + Added define USE_PXDB. + + * symfile.c (symfile_bfd_open): change parenthesis positioning + around call to hpread_pxdb_check. + + * symfile.c (symfile_bfd_open): make not static. + (RESET_HP_UX_GLOBALS): new macro. Resets globals when new symbol + file loaded. + (USE_PXDB): not needed. Removed. + (symbol_file_add): add HP specific code to deal with pxdb. + (symbol_file_command): reset HP specific globals if new symbol file + loaded. + (symfile_bfd_open): comment out checking for pxdb. + (reread_symbols): reset HP specific globals. + + * symfile.c (symfile_bfd_open): uncomment hpus specific code. + + * symfile.c: + (symbol_file_add): add user_loaded and is_solib parameters. + fixed number of parameters in call to allocate_objfile + (symbol_file_command): added call to SOLIB_RESTART macro. + fixed number of parameters in calls to symbol_file_add. + (add_symbol_file_command): fixed number of parameters in calls to + symbol_file_add. + + * symfile.c: added prototype for hpread_pxdb_check. + + * symfile.c: changed HPUX_SNAP1 ifdef to HPUXHPPA. enclosed calls to + RESET_HP_UX_GLOBALS with an HPUXHPPA ifdef + + * symfile.h (symfile_bfd_open): add protptype. + + * symfile.h: add prototype for add_psymbol_with_dem_name_to_list. + + * symfile.h: clarify purpose of auto_solib_add. + + * symmisc.c (maintenance_print_symbols): call gdb_fclose, not + fclose on a GDB_FILE* during cleanup. + (maintenance_print_psymbols): call gdb_fclose, not fclose on a + GDB_FILE* during cleanup. + (maintenance_print_msymbols): call gdb_fclose, not fclose on a + GDB_FILE* during cleanup. + + * symmisc.c (maintenance_print_symbols): gdb_fclose now takes a + GDB_FILE ** parameter. Fix the local GDB_FILE variables and the + call to make_cleanup. + (maintenance_print_psymbols): ditto + (maintenance_print_msymbols): ditto + + * symmisc.c (print_objfile_statistics): close quotes in + output strings. + + * symmisc.c: + (print_symbol): Add LOC_INDIRECT to switch statement + (print_partial_symbols): Add LOC_INDIRECT to switch statement + + * symtab.c (find_pc_sect_psymtab): high bounds should be <, not <=. + (find_pc_sect_symtab): ditto. + + * symtab.c (hp_som_som_object_present): new flag to indicate HP + compiled code. + (find_pc_sect_psymtab): change tests to make sure we are checking + the texthigh adress as well. + (lookup_transparent_type): new function. Look up a type name + in the struct_namespace. The type returned must not be opaque. + (find_pc_sect_symtab): make sure we check the address 'pc' itself, + too. + (find_addr_symbol): prepare to handle LOC_INDIRECT address class, but + leave it commented out. + (find_pc_sect_line): return correct information if pc is in import + or export stub (trampoline). + (decode_line_1): skip two chars, if they are '$$'. Like for HP's + $$dyncall. Handle cases in which varaible and function names can start + with $. + (overload_list_add_symbol): if cannot demangle name, use it as is. + Free string after use. + (make_symbol_overload_list): initialize oload_name to NULL and + oload_name_len to 0. If demangle not successful, use name as it is. + Free string after use. + + * symtab.c (lookup_symbol): Changed call to find_pc_sect_symtab, + to the original find_pc_symtab, in HP added fragment. + + * symtab.c (lookup_symbol): change HPUX_SNAP1 ifdef to a HPUXHPPA ifdef + + * symtab.c (lookup_symbol): ifdef the searching of symbol in the + minimal symbol tables, for hpux we move this check at the end + of the function. + Before we error out if symbol is not found in the symtab, look + in the statics. + Before erroring out if static symbol not found look in the globals. + + * symtab.c (lookup_symbol): return symbol as soon as found. + (decode_line_1): check whether we have a conditional break. Temporarily + remove it from the line, to not confure perenthesis checking. + Handle namespaces. + (overload_list_add_symbol): new function. Overload + resolution support. + (make_symbol_overload_list): ditto. + + * symtab.c: + (find_template_name_end): new prototype decl. + (lookup_symbol): when a global or static symbol shows up in the + psymtab table, but not the symtab table, tell the user that + the symbol may be an inlined function or a template function and + provide some guidance to the user about how to more fully + specify the symbol. + (lookup_transparent_type): when a global or static symbol shows up + in the psymtab table, but not the symtab table, tell the user that + the symbol may be an inlined function or a template function and + provide some guidance to the user about how to more fully + specify the symbol. + (decode_line_1): handle template function specification when decoding a + line. May need to be ifdefed for HP's aCC? + (_initialize_symtab): handle dbx commands. + + * symtab.h (address_class): add new address calss for + LOC_THREAD_LOCAL_STATIC and LOC_INDIRECT. + (lookup_transparent_type): add prototype. + (exception_event_kind): new enum for exception catchpoints. + (exception_event_record): new structure for exception catchpoints. + (CURRENT_EXCEPTION_KIND): new macro. + (CURRENT_EXCEPTION_CATCH_SAL): new macro. + (CURRENT_EXCEPTION_CATCH_LINE): new macro. + (CURRENT_EXCEPTION_CATCH_FILE): new macro. + (CURRENT_EXCEPTION_CATCH_PC): new macro. + (CURRENT_EXCEPTION_THROW_SAL): new macro. + (CURRENT_EXCEPTION_THROW_LINE): new macro. + (CURRENT_EXCEPTION_THROW_FILE) new macro.: + (CURRENT_EXCEPTION_THROW_PC): new macro. + + * symtab.h(make_symbol_overload_list): add prototype. + + * symtab.h: + (symbol_file_add): add new params to function decl. + + * target.c (cleanup_target): changed casting of default functions for + to_has_forked, to_has_vforked, to_pid_to_exec_file to get rid of + warnings. + + * target.c (cleanup_target): changed the default functions for + to_pid_to_exec_file and to_core_file_to_sym_file + + * target.c (cleanup_target): fixed PARAMS for to_has_syscall_event + + * target.c (cleanup_target): syntax error, mismatched paranthesis. + + * target.c (debug_to_open): change stderr to gdb_stderr. + (debug_to_close): ditto. + (debug_to_attach): ditto. + (debug_to_post_attach): ditto. + (debug_to_require_attach): ditto. + (debug_to_detach): ditto. + (debug_to_require_detach): ditto. + (debug_to_resume): ditto. + (debug_to_wait): ditto. + (debug_to_post_wait): ditto. + (debug_to_fetch_registers): ditto. + (debug_to_store_registers): ditto. + (debug_to_prepare_to_store): ditto. + (debug_to_xfer_memory): ditto. + (debug_to_files_info): ditto. + (debug_to_insert_breakpoint): ditto. + (debug_to_remove_breakpoint): ditto. + (debug_to_terminal_init): ditto. + (debug_to_terminal_inferior): ditto. + (debug_to_terminal_ours_for_output): ditto. + (debug_to_terminal_ours): ditto. + (debug_to_terminal_info): ditto. + (debug_to_kill): ditto. + (debug_to_load): ditto. + (debug_to_lookup_symbol): ditto. + (debug_to_create_inferior): ditto. + (debug_to_post_startup_inferior): ditto. + (debug_to_acknowledge_created_inferior): ditto. + (debug_to_clone_and_follow_inferior): ditto. + (debug_to_post_follow_inferior_by_clone): ditto. + (debug_to_insert_fork_catchpoint): ditto. + (debug_to_remove_fork_catchpoint): ditto. + (debug_to_insert_vfork_catchpoint): ditto. + (debug_to_remove_vfork_catchpoint): ditto. + (debug_to_has_forked): ditto. + (debug_to_has_vforked): ditto. + (debug_to_can_follow_vfork_prior_to_exec): ditto. + (debug_to_post_follow_vfork): ditto. + (debug_to_insert_exec_catchpoint): ditto. + (debug_to_remove_exec_catchpoint): ditto. + (debug_to_has_execd): ditto. + (debug_to_reported_exec_events_per_exec_call): ditto. + (debug_to_has_syscall_event): ditto. + (debug_to_has_exited): ditto. + (debug_to_mourn_inferior): ditto. + (debug_to_can_run): ditto. + (debug_to_notice_signals): ditto. + (debug_to_thread_alive): ditto. + (debug_to_stop): ditto. + (debug_to_enable_exception_callback): ditto. + (debug_to_get_current_exception_event): ditto. + (debug_to_pid_to_exec_file): ditto. + (debug_to_core_file_to_sym_file): ditto. + + * target.c: + (default_clone_and_follow_inferior): new funct prototype declaration + and function definition + (dummy_target) : More target_ops vector changes for HPUX + new fields. ifdefed for HPUX_SNAP2. New fields are + to_post_wait, to_post_startup_inferior + to_acknowledge_created_inferior, to_clone_and_follow_inferior, + to_post_follow_inferior_by_clone, to_create_catch_fork_hook, + to_create_catch_vfork_hook, to_has_forked, to_has_vforked, + to_post_follow_vfork, to_pid_to_exec_file + (de_fault): add new HPUX specific target_ops operations to + the de_fault macro + (INHERIT): add new HPUX specific target_ops operations to the + INHERIT macro + (find_default_clone_and_follow_inferior): new funct definition + (debug_to_post_wait): new funct + (debug_to_post_startup_inferior): new funct + (debug_to_acknowledge_created_inferior): new funct + (debug_to_clone_and_follow_inferior): new funct + (debug_to_post_follow_inferior_by_clone): new funct + (debug_to_create_catch_fork_hook): new funct + (debug_to_create_catch_vfork_hook): new funct + (debug_to_has_forked): new funct + (debug_to_has_vforked): new funct + (debug_to_post_follow_vfork): new funct + (setup_target_debug): initialize new target_ops vector fields. + + * target.c: + (cleanup_target): fixed the return type on a few of the + default function values. + + * target.c: + (dummy_target): Add 3 new fields + (nosupport_runtime): new function, used in cleanup_target + (cleanup_target): changes in the de_fault macro, both to + accomodate the new target_ops vector fields and to use + more accurate default functions. + (update_current_target): Add new target_ops vector fields to the + INHERIT macro + (generic_mourn_inferior): the call to breakpoint_init_inferior now takes a + parameter + (normal_pid_to_str): Adding a \0 to the end of buf. + (debug_to_has_syscall_event): new func + (debug_to_enable_exception_callback): new func + (debug_to_get_current_exception_event): new func + (setup_target_debug): initialize the 3 new target_ops vector fields + + * target.c: + (struct signals): fix message associated with SIGRETRACT. + + * target.c: + (dummy_target): fix syntax error + (cleanup_target): changed the default values for the new + target_ops vector fields. HP folks inappropriately set + most of them to noprocess(). They should be a mixture + of ignore() and return_zero(). + + * target.c: + (dummy_target): Add new target_ops vector fields and their initializations + (cleanup_target): Added new new target_ops vector fields to the de_fault + macro definition. + (update_current_target): Added new new target_ops vector fields to the INHERIT + macro definition + (return_one): new function, used by the de_fault macro + (debug_to_post_attach): new function + (debug_to_wait): added new cases : TARGET_WAITKIND_FORKED, TARGET_WAITKIND_VFORKED, + TARGET_WAITKIND_EXECD + (debug_to_insert_fork_catchpoint): new function + (debug_to_remove_fork_catchpoint): new function + (debug_to_insert_vfork_catchpoint): new function + (debug_to_remove_vfork_catchpoint): new function + (debug_to_can_follow_vfork_prior_to_exec): new function + (debug_to_insert_exec_catchpoint): new function + (debug_to_remove_exec_catchpoint): new function + (debug_to_core_file_to_sym_file): new function + (setup_target_debug): give new fields in current_target target_ops vector values. + + * target.c: HP merge, 4/15/98 snapshot + There are new target_ops fields that pertain only + to HPUX. All the changes relate to this. Fist, + new fields are added to the dummy_target target_ops + vector : to_require_attach, to_require_detach. + + * target.c: remove HPUX_SNAP1 and HPUX_SNAP2 ifdefs + + * thread.c (info_threads_command): call print_only_stack_frame + instead of print_stack_frame. + (_initialize_thread): make t an alias for thread only if + xdb_commands is not set. + + * thread.c (thread_command): if no arguments, don't generate an + error, instead tell the user which thread is current. + (info_threads_commands): don't lose the users position within the + current thread -- remember it and then restore it. + + * thread.c: + (struct thread_info): add stepping_through_sigtramp field + (add_thread): initialize stepping_through_sigtramp field + (load_infrun_state): add stepping_through_sigtramp param and + make sure it gets assigned a value. + (save_infrun_state): add stepping_through_sigtramp param and + make sure that the value gets saved. + (info_threads_command): ifdefing some local variables and + code for HPUXHPPA. HP folks want print the tid rather than pid? + Also, looks like the HP folks solved the same thread switching + problem that 4.17 solves. Taking 4.17. + (restore_current_thread): print out the current frame after + switching threads. + (thread_apply_all_command): ifdefing a print statement for + HPUXHPPA. The HP folks want to print out a tid rather than pid? + (thread_apply_command): ifdefing a print statement for + HPUXHPPA. The HP folks want to print out a tid rather than pid? + (thread_command): decided not to take HP change. + + * thread.c: Fixing gdb core dump problem causing many testsuite + failures. + (add_thread): remove call to bpstat_clear, initialize + tp->stepping_through_solib_catchpoints = NULL; + + * thread.c: changes for catchpoints, shared libaries, + (thread_info) : additional fields in the thread_info struct + for stepping_through_solib_after_catch and + stepping_through_solib_catchpoints. + (add_thread): initialize the new thread_info fields. + (load_infrun_state) : additional parameters for handling + catchpoints and shared libraries. + (save_infrun_state): additional parameters for handling + catchpoints and shared libraries. + + * top.c (command_loop): initialize space_at_cmd_start to 0. + + * top.c (set_prompt): new function. + + * top.c (togglelist, stoplist): new command lists. + (command_loop): tui changes -- paranoia to make sure + insert mode is off when not editing. + (quit_force): clean up tui on exit. + (init_main): make definition of info status command dependent upon + dbx mode not being set. + + * top.c: + (fputs_unfiltered_hook): changed stream parameter from FILE + to GDB_FILE + (flush_hook): changed stream parameter from FILE to GDB_FILE + + * top.h: declare it. + + * typeprint.c (whatis_exp): decide real runtime type. For the vtable + case. + + + * utils.c: + (query): changes to prevent cursor from jumping around in the + TUI. Call tuiBufferGetc explicitly, rather than passing it + into tuiDo. The tuiDo function does some additional work + that is inappropriate when handling queries. + + * utils.c + (GDB_FILE_ISATTY): new macro that takes a GDB_FILE param and + determines whether or not it's using a tty. + (gdb_file_isatty); called by the GDB_FILE_ISATTY macro. Does + the actual work + (init_page_info): Call GDB_FILE_ISATTY rather than ISATTY + (print_spaces): fix parameter to fputc. fix call to + gdb_file_adjust_strbuf. + (gdb_file_init_astring): fix parameter to xmalloc + (gdb_file_deallocate): new function to deallocate + a GDB_FILE object and possibly a string buffer + + * utils.c (gdb_file_init_astring): initialize buffer as the empty + string. + Indent GNU style. + + + * utils.c (gdb_fopen): gdb_fopen is called if the GDB_FILE object is + actually afile rather than astring. The routine now allocates space + for a GDB_FILE object and initializes its fields in addition to + performing an fopen. + (gdb_flush): fix the parameter passed into fflush. It's now stream->ts_filestream. + (gdb_fclose): Pass in an object of type GDB_FILE **. Fix parameter to fclose. It's + now tmpstream->ts_filestream. Make sure to free the GDB_FILE object and set the + GDB_FILE * object to NULL. + (gdb_adjust_strbuf): new function. Determine if the current ts_strbuf field + contains sufficient space to concatenate a string of length n on the end. + If not, then reallocate the ts_strbuf. + (print_spaces): Check to see if the GDB_FILE is afile or astring. If it is + astring, then adjust the size of the ts_strbuf field and concatenate the + correct number of spaces onto the end of the buffer. Otherwise continue to + use fputc. + (gdb_file_get_strbuf): new function. return a ptr to the ts_strbuf field in a + GDB_FILE object + (gdb_file_init_astring): new function to allocate space for and initialize + a GDB_FILE object when it is an astring. + + * utils.c (set_width): declare it. + (pagination_enabled): define it. + (query): tui changes. + (init_page_info, set_width): new functions. + (set_width_command): call set_width. + (_initialize_utils): replace termcap stuff with call to + init_page_info; if xdb_commands set, define am and sm commands; + define pagination as a set/show command. + + * utils.c (vfprintf_maybe_filtered): change FILE to GDB_FILE. + (fputs_maybe_filtered): ditto. + (print_spaces): ditto. + (gdb_printchar): ditto. + (gdb_flush): ditto. + (fputs_filtered): ditto. + (vfprintf_filtered): ditto. + (vfprintf_unfiltered): ditto. + (fprintf_filtered): ditto. + (fprintf_unfiltered): ditto. + (fprintfi_filtered): ditto. + (print_spaces_filtered): ditto. + (fprintf_symbol_filtered): ditto. + (gdb_fclose): new function. + + * valops.c (call_function_by_hand): assign to param_type only + if function has parameters. + + * valops.c (call_function_by_hand): ifdef the + HP_COMPILED_TARGET stuff. + (value_arg_coerce): ditto. + + * valops.c (call_function_by_hand): make sure param_type is + initialized to NULL. + + * valops.c (find_rt_vbase_offset): add parameter to value_at. + (value_rtti_type): ditto. + (value_full_object): ditto. + + * valops.c (search_struct_field_aux): fixed mismatching parenths + + + * valops.c (search_struct_field_aux): make sure TYPE_TAG_NAME + is not null before copying it. + + + * valops.c (search_struct_field_aux): set found_class_name to null + if class has no name (anon unions case). Adjust base_addr + computation. + + * valops.c (value_arg_coerce): change final arg to int. + + * valops.c (value_arg_coerce): remove the conditional on HP + compiled target, for doing coercion of float to double. Removed + third parameter, using_gcc. + (call_function_by_hand): do not use HP_COMPILED_TARGET, just + use the gcc_compiled variable. + + * valops.c (value_cast): take case of the enclosing_type and + pointer_to_offset fields. + (value_at): use VALUE_CONTENTS_ALL_RAW + (value_fetch_lazy): ditto + (value_assign): handle enclosing_type, embedded_offset and + pointed_to_offset fields. + (value_repeat): use VALUE_CONTENTS_ALL_RAW and VALUE_ENCLOSING_TYPE. + (value_ind): set enclosing_type and embedded_offset correctly, + for a pointer value being dereferenced. Target memory bytes + corresponding to the size of the enclosing type are retreived. + (value_addr): handle enclosing_type and pointed_to_offset. + (value_push): use VALUE_CONTENTS_ALL and VALUE_ENCLOSING_TYPE. + (value_arg_coerce): coerce floats to doubles only if gcc was not + used to compile the target. + (call_function_by_hand): handle pointers to functions as paramters. + (value_array): use VALUE_CONTENTS_ALL and VALUE_ENCLOSING_TYPE. + (search_struct_method): produce more informative error message. + (find_rt_vbase_offset): deal with negative offsets. + (value_find_oload_method_list): new function. Return the list of + overloaded methods of a specified name. + (find_method_list): new function. Search through the methods of an + object (and its bases) to find a specified method. + (value_full_object): new function. Given a value, check its real + run-time type. + (value_rtti_target_type): new function. Given a pointer value V, find + the real (RTTI) type of the object it points to. + (value_rtti_type): new function. Find the real run-time type of a + value using RTTI. + + * valops.c: include gdbcmd.h + Set global overload_resolution to 0. + (find_function_in_inferior): modify error message. + (value_allocate_space_in_inferior): modify error message. + (value_cast): deal with HP/aCC peculiarities. + (value_of_variable): use SYMBOL_SOURCE_NAME instead of SYMBOL_NAME. + (value_addr): modify address value by adding the embedded offset. + (value_ind): modify the address of the object by the pointed_to_offset. + (call_function_by_hand): do not do any extra alignment if not needed. + Fetch the return value from the stack rather then from the register, + for the hppa architecture. + (search_struct_field): rewritten. Now this function uses + search_struct_field_aux to do all the work. + (search_struct_field_aux): new function. This is the old + search_struct_field rewritten. + (find_rt_vbase_offset): give error if virtual table pointer is not good. + (find_overload_match): new function. Find the best function that + matches on the argument types according to the overload resolution + rules. + (_initialize_valops): add new set/show command for overload-resolution. + + * value.h (VALUE_POINTED_TO_OFFSET): new macro. + Add field pointed_to_offset to value structure. + Add prototypes for new functions in valops.c. + + * value.h (write_register_pid): change prototype to match + function. + + * value.h: HP merge, 4/15/98 snapshot + Added parameter to val_print func decl. + Added new macro, VALUE_EMBEDDED_OFFSET, and + new func decl, find_rt_vbase_offset, for C++ + support. + + * values.c (allocate_value): allocate also for value_embedded_offset + and value_enclosing_type. + (value_copy): copy value_embedded_offset and value_enclosing_type too. + Use all_raw in copying the value itself. + (value_primitive_field): add handling of base subobjects. + + * values.c (value_copy): copy the pointed_to_offset as well. + (allocate_value): allocate the pointed_to_offset as well. + (value_virtual_fn_field): rewrite. + + * values.c (value_primitive_field): adjust embedded offset and + offset calculation. + + * values.c (value_static_field): take into consideration that static + data members can be minimal symbols too. + + * values.c (value_virtual_fn_field): fix call to value_at. + + * win32-nat.c (child_ops): Remove unneeded settings. + + * win32-nat.c: + (handle_load_dll): added params to call to symbol_file_add. + + * win32-nat.c: + (init_child_ops): adding new target_ops vector fields and + removing a few. see list below + + * win32-nat.c: + (init_child_ops): initializing new target ops vector fields. see list below. + + Other changes have to do with XDB compatability. Leave oout + for now. + + defs.h (vfprintf_filtered): change FILE to GDB_FILE in decl. + (fprintf_filtered): ditto. + (fprintfi_filtered): ditto. + (vfprintf_unfiltered): ditto. + (fprintf_unfiltered): ditto. + + infcmd.c (_initialize_infcmd): if xdb_commands is set, make S an + alias for next and define R, lr, g. Define go. + + pyr-tdep.c (pyr_print_insn): change FILE to GDB_FILE. + + + * breakpoint.c (create_temp_exception_breakpoint): #if it out -- + nothing calls it. + (bpstat_stop_status): don't call SOLIB_HAVE_LOAD_EVENT if it's not + defined; don't call SOLIB_HAVE_UNLOAD_EVENT if it's not defined. + (bpstat_get_triggered_catchpoints): if we don't have shared + library support, then don't call SOLIB_LOADED_LIBRARY_PATHNAME nor + SOLIB_UNLOADED_LIBRARY_PATHNAME. + (watch_command_1): don't require a run before a watch command + unless we're on HP [it's an HP OS bug, not a generic limitation] + (catch_load_command_1): don't define if no shared libraries. + (catch_command_1): don't claim to support fork catchpoints unless + CHILD_INSERT_FORK_CATCHPOINT is defined, don't claim to support + vfork catchpoints unless CHILD_INSERT_VFORK_CATCHPOINT is defined, + don't clain to support shared library load catchpoints if shared + libraries aren't supported, and don't claim to support exec + catchpoints unless CHILD_INSERT_EXEC_CATCHPOINT is defined + + There are new target_ops vector fields that pertain + only to HPUX. Added the to_require_attach and + to_require_detach fields to exec_ops. These new + fields are ifdef'ed for HPUX_SNAP1. + + * breakpoint.h: + Fix compile error in enum bptype. + + * coff-solib.h: + Fixed a number of macro definitions. SOLIB_LOADED_LIBRARY_PATHNAME, + SOLIB_HAVE_LOAD_EVENT, SOLIB_HAVE_UNLOAD_EVENT, + SOLIB_UNLOADED_LIBRARY_PATHNAME, SOLIB_IN_DYNAMIC_LINKER. These + macros are only meaningful (for now) for SOM. So, all + the macros were defined as error(...), but were used in + conditions. This caused the compile to crap out. I redefined + these (for now) to be 0. + + * procfs.c: + (procfs_create_inferior): fix call to fork_inferior -- need another + parameter. + + * solib.h: + Fixed a number of macro definitions. SOLIB_LOADED_LIBRARY_PATHNAME, + SOLIB_HAVE_LOAD_EVENT, SOLIB_HAVE_UNLOAD_EVENT, + SOLIB_UNLOADED_LIBRARY_PATHNAME, SOLIB_IN_DYNAMIC_LINKER. These + macros are only meaningful (for now) for SOM. So, all + the macros were defined as error(...), but were used in + conditions. This caused the compile to crap out. I redefined + these (for now) to be 0. + + * valops.c: + (search_struct_field): undeclared local variable, "assigned". + (find_rt_vbase_offset): fixed call to value_at + + * value.h: + Fix signature for find_rt_vbase_offset funct decl (missing a param) + Wed Dec 30 17:48:12 1998 Stan Shebs <shebs@andros.cygnus.com> From J.T. Conklin <jtc@redbacknetworks.com>: |