From 8ecd559a563f80c84562ccc1633059f5437678bf Mon Sep 17 00:00:00 2001 From: David Taylor Date: Tue, 8 Dec 1998 15:44:05 +0000 Subject: [PATCH] HP merge changes by David Taylor, Edith Epstein, Jim Blandy, and Elena Zannoni. * hpux-core.c (hpux_core_core_file_p): this function now understands HPUX 10.30 thread info. Yes, the thread stacks can be found in the corefile! Also, in hpux_core_core_file_p, if we encounter a section with an unknown type, don't punt. Instead, just skip it. Also, count the number of sections of known type that we encounter. If we encounter at least one good one, then we'll declare that the file is a core file. If we encounter any unknown ones but some known ones, then we'll issue a warning (but still declare it to be a core file). Also, correctly decide when a file is not a core. (PROC_INFO_HAS_THREAD_ID): define if CORE_ANON_SHMEM defined. (CORE_ANON_SHMEM): define if not defined. (hpux_core_struct): add members lwpid and user_tid. (core_kernel_thread_id, core_user_thread_id): new macros. (make_bfd_asection): use bfd_alloc to allocate room for a copy of the name before storing it in the bfd. (hpux_core_core_file_p): handle threads. * libhppa.h (GET_FIELD): protect against redefinition. (HPPA_WIDE): define. (GET_FIELD): define. (GET_BIT): define. (MASK): define. (CATENATE): define. (ELEVEN): define. (sign_extend): redefine. (assemble_6): define. (assemble_12): rewrite. (assemble_16): define. (assemble_16a): define. (assemble_17): rewrite. (assemble_22): define. --- bfd/ChangeLog | 46 +++++++++++ bfd/hpux-core.c | 208 ++++++++++++++++++++++++++++++++++++------------ 2 files changed, 204 insertions(+), 50 deletions(-) diff --git a/bfd/ChangeLog b/bfd/ChangeLog index 255a56cbc2e..34651c5d7b0 100644 --- a/bfd/ChangeLog +++ b/bfd/ChangeLog @@ -1,3 +1,49 @@ +Wed Dec 2 15:03:59 1998 David Taylor + + The following changes were made by David Taylor + , Edith Epstein + , Jim Blandy + , and Elena Zannoni + as part of the project to merge in + changes originally made by HP; HP did not create ChangeLog + entries. + + * aclocal.m4, configure, Makefile.in: Rebuilt using latest + automake macro library. + + * hpux-core.c (hpux_core_core_file_p): this function now + understands HPUX 10.30 thread info. Yes, the thread stacks can be + found in the corefile! Also, in hpux_core_core_file_p, if we + encounter a section with an unknown type, don't punt. Instead, + just skip it. Also, count the number of sections of known type + that we encounter. If we encounter at least one good one, then + we'll declare that the file is a core file. If we encounter any + unknown ones but some known ones, then we'll issue a warning (but + still declare it to be a core file). Also, correctly decide when a + file is not a core. + (PROC_INFO_HAS_THREAD_ID): define if CORE_ANON_SHMEM defined. + (CORE_ANON_SHMEM): define if not defined. + (hpux_core_struct): add members lwpid and user_tid. + (core_kernel_thread_id, core_user_thread_id): new macros. + (make_bfd_asection): use bfd_alloc to allocate room for a copy of + the name before storing it in the bfd. + (hpux_core_core_file_p): handle threads. + + * libhppa.h (GET_FIELD): protect against redefinition. + (HPPA_WIDE): define. + (GET_FIELD): define. + (GET_BIT): define. + (MASK): define. + (CATENATE): define. + (ELEVEN): define. + (sign_extend): redefine. + (assemble_6): define. + (assemble_12): rewrite. + (assemble_16): define. + (assemble_16a): define. + (assemble_17): rewrite. + (assemble_22): define. + 1998-12-07 Nick Clifton * elf32-fr30.c (fr30_final_link_relocate): Using signed diff --git a/bfd/hpux-core.c b/bfd/hpux-core.c index 7653b85166a..3baefb18a13 100644 --- a/bfd/hpux-core.c +++ b/bfd/hpux-core.c @@ -1,5 +1,5 @@ /* BFD back-end for HP/UX core files. - Copyright 1993 Free Software Foundation, Inc. + Copyright 1993, 94, 95, 96, 97, 1998 Free Software Foundation, Inc. Written by Stu Grossman, Cygnus Support. Converted to back-end form by Ian Lance Taylor, Cygnus SUpport @@ -17,13 +17,10 @@ GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software -Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ +Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ /* This file can only be compiled on systems which use HP/UX style - core files. In the config/XXXXXX.mh file for such a system add - HDEFINES=-DHPUX_CORE - HDEPFILES=hpux-core.o - */ + core files. */ #include "bfd.h" #include "sysdep.h" @@ -48,33 +45,49 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ #endif /* HOST_HPPABSD */ -#include -#include #include #include #include #include #include /* After a.out.h */ #include -#include + +/* Kludge: There's no explicit mechanism provided by sys/core.h to + conditionally know whether a proc_info has thread id fields. + However, CORE_ANON_SHMEM shows up first at 10.30, which is + happily also when meaningful thread id's show up in proc_info. */ +#if defined(CORE_ANON_SHMEM) +#define PROC_INFO_HAS_THREAD_ID (1) +#endif + +/* This type appears at HP-UX 10.30. Defining it if not defined + by sys/core.h allows us to build for older HP-UX's, and (since + it won't be encountered in core-dumps from older HP-UX's) is + harmless. */ +#if !defined(CORE_ANON_SHMEM) +#define CORE_ANON_SHMEM 0x00000200 /* anonymous shared memory */ +#endif /* These are stored in the bfd's tdata */ +/* .lwpid and .user_tid are only valid if PROC_INFO_HAS_THREAD_ID, else they + are set to 0. Also, until HP-UX implements MxN threads, .user_tid and + .lwpid are synonymous. */ struct hpux_core_struct { int sig; + int lwpid; /* Kernel thread ID. */ + unsigned long user_tid; /* User thread ID. */ char cmd[MAXCOMLEN + 1]; - asection *data_section; - asection *stack_section; - asection *reg_section; }; #define core_hdr(bfd) ((bfd)->tdata.hpux_core_data) #define core_signal(bfd) (core_hdr(bfd)->sig) #define core_command(bfd) (core_hdr(bfd)->cmd) -#define core_datasec(bfd) (core_hdr(bfd)->data_section) -#define core_stacksec(bfd) (core_hdr(bfd)->stack_section) -#define core_regsec(bfd) (core_hdr(bfd)->reg_section) +#define core_kernel_thread_id(bfd) (core_hdr(bfd)->lwpid) +#define core_user_thread_id(bfd) (core_hdr(bfd)->user_tid) + +static void swap_abort PARAMS ((void)); static asection * make_bfd_asection (abfd, name, flags, _raw_size, vma, alignment_power) @@ -86,8 +99,15 @@ make_bfd_asection (abfd, name, flags, _raw_size, vma, alignment_power) unsigned int alignment_power; { asection *asect; + char *newname; + + newname = bfd_alloc (abfd, strlen (name) + 1); + if (!newname) + return NULL; + + strcpy (newname, name); - asect = bfd_make_section (abfd, name); + asect = bfd_make_section_anyway (abfd, newname); if (!asect) return NULL; @@ -110,10 +130,23 @@ hpux_core_make_empty_symbol (abfd) return new; } -static bfd_target * + +/* this function builds a bfd target if the file is a corefile. + It returns null or 0 if it finds out thaat it is not a core file. + The way it checks this is by looking for allowed 'type' field values. + These are declared in sys/core.h + There are some values which are 'reserved for future use'. In particular + CORE_NONE is actually defined as 0. This may be a catch-all for cases + in which the core file is generated by some non-hpux application. + (I am just guessing here!) +*/ +static const bfd_target * hpux_core_core_file_p (abfd) bfd *abfd; { + int good_sections = 0; + int unknown_sections = 0; + core_hdr (abfd) = (struct hpux_core_struct *) bfd_zalloc (abfd, sizeof (struct hpux_core_struct)); if (!core_hdr (abfd)) @@ -132,6 +165,7 @@ hpux_core_core_file_p (abfd) case CORE_KERNEL: case CORE_FORMAT: bfd_seek (abfd, core_header.len, SEEK_CUR); /* Just skip this */ + good_sections++; break; case CORE_EXEC: { @@ -140,54 +174,125 @@ hpux_core_core_file_p (abfd) != core_header.len) break; strncpy (core_command (abfd), proc_exec.cmd, MAXCOMLEN + 1); + good_sections++; } break; case CORE_PROC: { struct proc_info proc_info; - core_regsec (abfd) = make_bfd_asection (abfd, ".reg", - SEC_ALLOC + SEC_HAS_CONTENTS, - core_header.len, - (int) &proc_info - (int) &proc_info.hw_regs, - 2); + char secname[100]; /* Of arbitrary size, but plenty large. */ + + /* We need to read this section, 'cause we need to determine + whether the core-dumped app was threaded before we create + any .reg sections. */ if (bfd_read (&proc_info, 1, core_header.len, abfd) != core_header.len) break; + + /* However, we also want to create those sections with the + file positioned at the start of the record, it seems. */ + if (bfd_seek (abfd, -core_header.len, SEEK_CUR) != 0) + break; + +#if defined(PROC_INFO_HAS_THREAD_ID) + core_kernel_thread_id (abfd) = proc_info.lwpid; + core_user_thread_id (abfd) = proc_info.user_tid; +#else + core_kernel_thread_id (abfd) = 0; + core_user_thread_id (abfd) = 0; +#endif + /* If the program was unthreaded, then we'll just create a + .reg section. + + If the program was threaded, then we'll create .reg/XXXXX + section for each thread, where XXXXX is a printable + representation of the kernel thread id. We'll also + create a .reg section for the thread that was running + and signalled at the time of the core-dump (i.e., this + is effectively an alias, needed to keep GDB happy.) + + Note that we use `.reg/XXXXX' as opposed to '.regXXXXX' + because GDB expects that .reg2 will be the floating- + point registers. */ + if (core_kernel_thread_id (abfd) == 0) + { + if (!make_bfd_asection (abfd, ".reg", + SEC_HAS_CONTENTS, + core_header.len, + (int) &proc_info - (int) & proc_info.hw_regs, + 2)) + return NULL; + } + else + { + /* There are threads. Is this the one that caused the + core-dump? We'll claim it was the running thread. */ + if (proc_info.sig != -1) + { + if (!make_bfd_asection (abfd, ".reg", + SEC_HAS_CONTENTS, + core_header.len, + (int) &proc_info - (int) & proc_info.hw_regs, + 2)) + return NULL; + } + /* We always make one of these sections, for every thread. */ + sprintf (secname, ".reg/%d", core_kernel_thread_id (abfd)); + if (!make_bfd_asection (abfd, secname, + SEC_HAS_CONTENTS, + core_header.len, + (int) &proc_info - (int) & proc_info.hw_regs, + 2)) + return NULL; + } core_signal (abfd) = proc_info.sig; + if (bfd_seek (abfd, core_header.len, SEEK_CUR) != 0) + break; + good_sections++; } - if (!core_regsec (abfd)) - return NULL; break; + case CORE_DATA: - core_datasec (abfd) = make_bfd_asection (abfd, ".data", - SEC_ALLOC + SEC_LOAD + SEC_HAS_CONTENTS, - core_header.len, - core_header.addr, - 2); - if (!core_datasec (abfd)) - return NULL; - bfd_seek (abfd, core_header.len, SEEK_CUR); - break; case CORE_STACK: - core_stacksec (abfd) = make_bfd_asection (abfd, ".stack", - SEC_ALLOC + SEC_LOAD + SEC_HAS_CONTENTS, - core_header.len, - core_header.addr, - 2); - if (!core_stacksec (abfd)) + case CORE_TEXT: + case CORE_MMF: + case CORE_SHM: + case CORE_ANON_SHMEM: + if (!make_bfd_asection (abfd, ".data", + SEC_ALLOC + SEC_LOAD + SEC_HAS_CONTENTS, + core_header.len, core_header.addr, 2)) return NULL; + bfd_seek (abfd, core_header.len, SEEK_CUR); + good_sections++; break; - default: - /* Falling into here is an error and should prevent this - target from matching. That way systems which use hpux - cores along with other formats can still work. */ - return 0; + + case CORE_NONE: + /* Let's not punt if we encounter a section of unknown + type. Rather, let's make a note of it. If we later + see that there were also "good" sections, then we'll + declare that this a core file, but we'll also warn that + it may be incompatible with this gdb. + */ + unknown_sections++; + break; + + default: return 0; /*unrecognized core file type */ } } /* OK, we believe you. You're a core file (sure, sure). */ + /* Were there sections of unknown type? If so, yet there were + at least some complete sections of known type, then, issue + a warning. Possibly the core file was generated on a version + of HP-UX that is incompatible with that for which this gdb was + built. + */ + if ((unknown_sections > 0) && (good_sections > 0)) + warning ("%s appears to be a core file,\nbut contains unknown sections. It may have been created on an incompatible\nversion of HP-UX. As a result, some information may be unavailable.\n", + abfd->filename); + return abfd->xvec; } @@ -218,13 +323,16 @@ hpux_core_core_file_matches_executable_p (core_bfd, exec_bfd) #define hpux_core_get_symtab _bfd_nosymbols_get_symtab #define hpux_core_print_symbol _bfd_nosymbols_print_symbol #define hpux_core_get_symbol_info _bfd_nosymbols_get_symbol_info -#define hpux_core_bfd_is_local_label _bfd_nosymbols_bfd_is_local_label +#define hpux_core_bfd_is_local_label_name \ + _bfd_nosymbols_bfd_is_local_label_name #define hpux_core_get_lineno _bfd_nosymbols_get_lineno #define hpux_core_find_nearest_line _bfd_nosymbols_find_nearest_line #define hpux_core_bfd_make_debug_symbol _bfd_nosymbols_bfd_make_debug_symbol +#define hpux_core_read_minisymbols _bfd_nosymbols_read_minisymbols +#define hpux_core_minisymbol_to_symbol _bfd_nosymbols_minisymbol_to_symbol /* If somebody calls any byte-swapping routines, shoot them. */ -void +static void swap_abort() { abort(); /* This way doesn't require any declaration for ANSI to fuck up */ @@ -234,12 +342,12 @@ swap_abort() #define NO_SIGNED_GET \ ((bfd_signed_vma (*) PARAMS ((const bfd_byte *))) swap_abort ) -bfd_target hpux_core_vec = +const bfd_target hpux_core_vec = { "hpux-core", bfd_target_unknown_flavour, - true, /* target byte order */ - true, /* target headers byte order */ + BFD_ENDIAN_BIG, /* target byte order */ + BFD_ENDIAN_BIG, /* target headers byte order */ (HAS_RELOC | EXEC_P | /* object flags */ HAS_LINENO | HAS_DEBUG | HAS_SYMS | HAS_LOCALS | WP_TEXT | D_PAGED), @@ -247,7 +355,6 @@ bfd_target hpux_core_vec = 0, /* symbol prefix */ ' ', /* ar_pad_char */ 16, /* ar_max_namelen */ - 3, /* minimum alignment power */ NO_GET, NO_SIGNED_GET, NO_PUT, /* 64 bit data */ NO_GET, NO_SIGNED_GET, NO_PUT, /* 32 bit data */ NO_GET, NO_SIGNED_GET, NO_PUT, /* 16 bit data */ @@ -278,6 +385,7 @@ bfd_target hpux_core_vec = BFD_JUMP_TABLE_RELOCS (_bfd_norelocs), BFD_JUMP_TABLE_WRITE (_bfd_generic), BFD_JUMP_TABLE_LINK (_bfd_nolink), + BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), (PTR) 0 /* backend_data */ }; -- 2.30.2