MatCat.OpenSource/8sa1-binutils-gdb
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Delete Tru64 support

Browse Source 
This commit does most of the mechanical removal.  IOW, the easy part.

procfs.c isn't touched beyond removing a couple obvious bits that are
guarded by a couple macros defined in config/alpha/nm-osf3.h.  Going
beyond that for procfs.c & co would be a harder excision that
potentially affects Solaris.

Some comments in the generic alpha code ABIs that may still be
relevant and I wouldn't know what to do with them.  That can always be
done on a separate pass, preferably by someone who can test on alpha.

A couple other spots have references to OSF/Tru64 and related files
being removed, but it felt like removing them would make things worse,
not better.  We can revisit those when we next need to touch that
code.

I didn't remove a reference to osf in testsuite/lib/future.exp, as I
believe that code is imported from DejaGNU.

Built and tested on x86_64 Fedora 20, with --enable-targets=all.

Tested that building for --target=alpha-osf3 on x86_64 Fedora 20
fails with:

 checking for default auto-load directory... $debugdir:$datadir/auto-load
 checking for default auto-load safe-path... $debugdir:$datadir/auto-load
 *** Configuration alpha-unknown-osf3 is obsolete.
 *** Support has been REMOVED.
 make[1]: *** [configure-gdb] Error 1
 make[1]: Leaving directory `build-osf'
 make: *** [all] Error 2

gdb/
2014-10-17  Pedro Alves  <palves@redhat.com>

	* Makefile.in (ALL_64_TARGET_OBS): Remove alpha-osf1-tdep.o.
	(HFILES_NO_SRCDIR): Remove config/alpha/nm-osf3.h.
	(ALLDEPFILES): Remove alpha-nat.c, alpha-osf1-tdep.c and
	solib-osf.c.
	* NEWS: Mention that support for alpha*-*-osf* has been removed.
	* ada-lang.h [__alpha__ && __osf__]
	(ADA_KNOWN_RUNTIME_FILE_NAME_PATTERNS): Delete.
	* alpha-nat.c, alpha-osf1-tdep.c: Delete files.
	* alpha-tdep.c (alpha_gdbarch_init): Remove reference to
	GDB_OSABI_OSF1.
	* config/alpha/alpha-osf3.mh, config/alpha/nm-osf3.h: Delete
	files.
	* config/djgpp/fnchange.lst (config/alpha/alpha-osf1.mh)
	(config/alpha/alpha-osf2.mh, config/alpha/alpha-osf3.mh): Delete.
	* configure: Regenerate.
	* configure.ac: Remove references to osf.
	* configure.host: Handle alpha*-*-osf* in the obsolete hosts
	section.  Remove all other references to osf.
	* configure.tgt: Add alpha*-*-osf* to the obsolete targets section.
	Remove all other references to osf.
	* dec-thread.c: Delete file.
	* defs.h (GDB_OSABI_OSF1): Delete.
	* inferior.h (START_INFERIOR_TRAPS_EXPECTED): New unconditionally
	defined.
	* osabi.c (gdb_osabi_names): Delete "OSF/1".
	* procfs.c (procfs_debug_inferior) [PROCFS_DONT_TRACE_FAULTS]:
	Delete code.
	(unconditionally_kill_inferior)
	[PROCFS_NEED_CLEAR_CURSIG_FOR_KILL]: Delete code.
	* solib-osf.c: Delete file.

gdb/testsuite/
2014-10-17  Pedro Alves  <palves@redhat.com>

	* gdb.base/callfuncs.exp: emove references to osf.
	* gdb.base/sigall.exp: Likewise.
	* gdb.gdb/selftest.exp: Likewise.
	* gdb.hp/gdb.base-hp/callfwmall.exp: Likewise.
	* gdb.mi/non-stop.c: Likewise.
	* gdb.mi/pthreads.c: Likewise.
	* gdb.reverse/sigall-precsave.exp: Likewise.
	* gdb.reverse/sigall-reverse.exp: Likewise.
	* gdb.threads/pthreads.c: Likewise.
	* gdb.threads/pthreads.exp: Likewise.

gdb/doc/
2014-10-17  Pedro Alves  <palves@redhat.com>

	* gdb.texinfo (Ada Tasks and Core Files): Delete mention of Tru64.
	(SVR4 Process Information): Delete mention of OSF/1.
This commit is contained in:
Pedro Alves 2014-10-17 11:18:59 +01:00
parent 80134cf5b3
commit 32a8097ba5
33 changed files with 72 additions and 1838 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

33
gdb/ChangeLog
View File

@ -1,3 +1,36 @@
2014-10-17 Pedro Alves <palves@redhat.com>
* Makefile.in (ALL_64_TARGET_OBS): Remove alpha-osf1-tdep.o.
(HFILES_NO_SRCDIR): Remove config/alpha/nm-osf3.h.
(ALLDEPFILES): Remove alpha-nat.c, alpha-osf1-tdep.c and
solib-osf.c.
* NEWS: Mention that support for alpha*-*-osf* has been removed.
* ada-lang.h [__alpha__ && __osf__]
(ADA_KNOWN_RUNTIME_FILE_NAME_PATTERNS): Delete.
* alpha-nat.c, alpha-osf1-tdep.c: Delete files.
* alpha-tdep.c (alpha_gdbarch_init): Remove reference to
GDB_OSABI_OSF1.
* config/alpha/alpha-osf3.mh, config/alpha/nm-osf3.h: Delete
files.
* config/djgpp/fnchange.lst (config/alpha/alpha-osf1.mh)
(config/alpha/alpha-osf2.mh, config/alpha/alpha-osf3.mh): Delete.
* configure: Regenerate.
* configure.ac: Remove references to osf.
* configure.host: Handle alpha*-*-osf* in the obsolete hosts
section. Remove all other references to osf.
* configure.tgt: Add alpha*-*-osf* to the obsolete targets section.
Remove all other references to osf.
* dec-thread.c: Delete file.
* defs.h (GDB_OSABI_OSF1): Delete.
* inferior.h (START_INFERIOR_TRAPS_EXPECTED): New unconditionally
defined.
* osabi.c (gdb_osabi_names): Delete "OSF/1".
* procfs.c (procfs_debug_inferior) [PROCFS_DONT_TRACE_FAULTS]:
Delete code.
(unconditionally_kill_inferior)
[PROCFS_NEED_CLEAR_CURSIG_FOR_KILL]: Delete code.
* solib-osf.c: Delete file.
2014-10-17 Pedro Alves <palves@redhat.com> 2014-10-17 Pedro Alves <palves@redhat.com>
* remote.c (clear_threads_listing_context): Move higher up, out of * remote.c (clear_threads_listing_context): Move higher up, out of

9
gdb/Makefile.in
View File

@ -607,7 +607,7 @@ TARGET_OBS = @TARGET_OBS@
ALL_64_TARGET_OBS = \ ALL_64_TARGET_OBS = \
aarch64-tdep.o aarch64-linux-tdep.o aarch64-newlib-tdep.o \ aarch64-tdep.o aarch64-linux-tdep.o aarch64-newlib-tdep.o \
alphabsd-tdep.o alphafbsd-tdep.o alpha-linux-tdep.o alpha-mdebug-tdep.o \ alphabsd-tdep.o alphafbsd-tdep.o alpha-linux-tdep.o alpha-mdebug-tdep.o \
alphanbsd-tdep.o alphaobsd-tdep.o alpha-osf1-tdep.o alpha-tdep.o \ alphanbsd-tdep.o alphaobsd-tdep.o alpha-tdep.o \
amd64fbsd-tdep.o amd64-darwin-tdep.o amd64-dicos-tdep.o \ amd64fbsd-tdep.o amd64-darwin-tdep.o amd64-dicos-tdep.o \
amd64-linux-tdep.o amd64nbsd-tdep.o \ amd64-linux-tdep.o amd64nbsd-tdep.o \
amd64obsd-tdep.o amd64-sol2-tdep.o amd64-tdep.o amd64-windows-tdep.o \ amd64obsd-tdep.o amd64-sol2-tdep.o amd64-tdep.o amd64-windows-tdep.o \
@ -910,7 +910,7 @@ common/gdb_locale.h arch-utils.h trad-frame.h gnu-nat.h \
language.h nbsd-tdep.h solib-svr4.h \ language.h nbsd-tdep.h solib-svr4.h \
macroexp.h ui-file.h regcache.h tracepoint.h tracefile.h i386-tdep.h \ macroexp.h ui-file.h regcache.h tracepoint.h tracefile.h i386-tdep.h \
inf-child.h p-lang.h event-top.h gdbtypes.h user-regs.h \ inf-child.h p-lang.h event-top.h gdbtypes.h user-regs.h \
regformats/regdef.h config/alpha/nm-osf3.h config/i386/nm-i386gnu.h \ regformats/regdef.h config/i386/nm-i386gnu.h \
config/i386/nm-fbsd.h \ config/i386/nm-fbsd.h \
config/nm-nto.h config/sparc/nm-sol2.h config/nm-linux.h \ config/nm-nto.h config/sparc/nm-sol2.h config/nm-linux.h \
top.h bsd-kvm.h gdb-stabs.h reggroups.h \ top.h bsd-kvm.h gdb-stabs.h reggroups.h \
@ -1601,9 +1601,9 @@ ALLDEPFILES = \
aarch64-tdep.c aarch64-linux-tdep.c aarch64-newlib-tdep.c \ aarch64-tdep.c aarch64-linux-tdep.c aarch64-newlib-tdep.c \
aarch64-linux-nat.c \ aarch64-linux-nat.c \
aix-thread.c \ aix-thread.c \
alpha-nat.c alphabsd-nat.c alpha-linux-nat.c \ alphabsd-nat.c alpha-linux-nat.c \
alpha-tdep.c alpha-mdebug-tdep.c \ alpha-tdep.c alpha-mdebug-tdep.c \
alpha-linux-tdep.c alpha-osf1-tdep.c \ alpha-linux-tdep.c \
alphabsd-tdep.c alphafbsd-tdep.c alphanbsd-tdep.c alphaobsd-tdep.c \ alphabsd-tdep.c alphafbsd-tdep.c alphanbsd-tdep.c alphaobsd-tdep.c \
amd64-nat.c amd64-tdep.c \ amd64-nat.c amd64-tdep.c \
amd64bsd-nat.c amd64fbsd-nat.c amd64fbsd-tdep.c \ amd64bsd-nat.c amd64fbsd-nat.c amd64fbsd-tdep.c \
@ -1666,7 +1666,6 @@ ALLDEPFILES = \
msp430-tdep.c \ msp430-tdep.c \
nios2-tdep.c nios2-linux-tdep.c \ nios2-tdep.c nios2-linux-tdep.c \
nbsd-nat.c nbsd-tdep.c obsd-nat.c obsd-tdep.c \ nbsd-nat.c nbsd-tdep.c obsd-nat.c obsd-tdep.c \
solib-osf.c \
somread.c solib-som.c \ somread.c solib-som.c \
posix-hdep.c \ posix-hdep.c \
ppc-sysv-tdep.c ppc-linux-nat.c ppc-linux-tdep.c ppc64-tdep.c \ ppc-sysv-tdep.c ppc-linux-nat.c ppc-linux-tdep.c ppc64-tdep.c \

1
gdb/NEWS
View File

@ -49,6 +49,7 @@ queue-signal signal-name-or-number
Support for these obsolete configurations has been removed. Support for these obsolete configurations has been removed.
alpha*-*-osf*
mips-sgi-irix5* mips-sgi-irix5*
mips-sgi-irix6* mips-sgi-irix6*

6
gdb/ada-lang.h
View File

@ -34,11 +34,7 @@ struct parser_state;
system and that might consider (confusing) debugging information. system and that might consider (confusing) debugging information.
Each name (a basic regular expression string) is followed by a Each name (a basic regular expression string) is followed by a
comma. FIXME: Should be part of a configuration file. */ comma. FIXME: Should be part of a configuration file. */
#if defined(__alpha__) && defined(__osf__) #if defined (__linux__)
#define ADA_KNOWN_RUNTIME_FILE_NAME_PATTERNS \
"^[agis]-.*\\.ad[bs]$", \
"/usr/shlib/libpthread\\.so",
#elif defined (__linux__)
#define ADA_KNOWN_RUNTIME_FILE_NAME_PATTERNS \ #define ADA_KNOWN_RUNTIME_FILE_NAME_PATTERNS \
"^[agis]-.*\\.ad[bs]$", \ "^[agis]-.*\\.ad[bs]$", \
"/lib.*/libpthread\\.so[.0-9]*$", "/lib.*/libpthread\\.a$", \ "/lib.*/libpthread\\.so[.0-9]*$", "/lib.*/libpthread\\.a$", \

210
gdb/alpha-nat.c
View File

@ -1,210 +0,0 @@
/* Low level Alpha interface, for GDB when running native.
Copyright (C) 1993-2014 Free Software Foundation, Inc.
This file is part of GDB.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>. */
#include "defs.h"
#include "inferior.h"
#include "gdbcore.h"
#include "target.h"
#include "procfs.h"
#include "regcache.h"
#include "alpha-tdep.h"
#include <sys/ptrace.h>
#include <alpha/coreregs.h>
#include <sys/user.h>
/* Extract the register values out of the core file and store
them into REGCACHE.
CORE_REG_SECT points to the register values themselves, read into memory.
CORE_REG_SIZE is the size of that area.
WHICH says which set of registers we are handling (0 = int, 2 = float
on machines where they are discontiguous).
REG_ADDR is the offset from u.u_ar0 to the register values relative to
core_reg_sect. This is used with old-fashioned core files to
locate the registers in a large upage-plus-stack ".reg" section.
Original upage address X is at location core_reg_sect+x+reg_addr. */
static void
fetch_osf_core_registers (struct regcache *regcache,
char *core_reg_sect, unsigned core_reg_size,
int which, CORE_ADDR reg_addr)
{
struct gdbarch *gdbarch = get_regcache_arch (regcache);
int regno;
int addr;
int bad_reg = -1;
/* Table to map a gdb regnum to an index in the core register
section. The floating point register values are garbage in
OSF/1.2 core files. OSF5 uses different names for the register
enum list, need to handle two cases. The actual values are the
same. */
static int const core_reg_mapping[ALPHA_NUM_REGS] =
{
#ifdef NCF_REGS
#define EFL NCF_REGS
CF_V0, CF_T0, CF_T1, CF_T2, CF_T3, CF_T4, CF_T5, CF_T6,
CF_T7, CF_S0, CF_S1, CF_S2, CF_S3, CF_S4, CF_S5, CF_S6,
CF_A0, CF_A1, CF_A2, CF_A3, CF_A4, CF_A5, CF_T8, CF_T9,
CF_T10, CF_T11, CF_RA, CF_T12, CF_AT, CF_GP, CF_SP, -1,
EFL + 0, EFL + 1, EFL + 2, EFL + 3,
EFL + 4, EFL + 5, EFL + 6, EFL + 7,
EFL + 8, EFL + 9, EFL + 10, EFL + 11,
EFL + 12, EFL + 13, EFL + 14, EFL + 15,
EFL + 16, EFL + 17, EFL + 18, EFL + 19,
EFL + 20, EFL + 21, EFL + 22, EFL + 23,
EFL + 24, EFL + 25, EFL + 26, EFL + 27,
EFL + 28, EFL + 29, EFL + 30, EFL + 31,
CF_PC, -1, -1
#else
#define EFL (EF_SIZE / 8)
EF_V0, EF_T0, EF_T1, EF_T2, EF_T3, EF_T4, EF_T5, EF_T6,
EF_T7, EF_S0, EF_S1, EF_S2, EF_S3, EF_S4, EF_S5, EF_S6,
EF_A0, EF_A1, EF_A2, EF_A3, EF_A4, EF_A5, EF_T8, EF_T9,
EF_T10, EF_T11, EF_RA, EF_T12, EF_AT, EF_GP, EF_SP, -1,
EFL + 0, EFL + 1, EFL + 2, EFL + 3,
EFL + 4, EFL + 5, EFL + 6, EFL + 7,
EFL + 8, EFL + 9, EFL + 10, EFL + 11,
EFL + 12, EFL + 13, EFL + 14, EFL + 15,
EFL + 16, EFL + 17, EFL + 18, EFL + 19,
EFL + 20, EFL + 21, EFL + 22, EFL + 23,
EFL + 24, EFL + 25, EFL + 26, EFL + 27,
EFL + 28, EFL + 29, EFL + 30, EFL + 31,
EF_PC, -1, -1
#endif
};
for (regno = 0; regno < ALPHA_NUM_REGS; regno++)
{
if (gdbarch_cannot_fetch_register (gdbarch, regno))
{
regcache_raw_supply (regcache, regno, NULL);
continue;
}
if (regno == ALPHA_ZERO_REGNUM)
{
const gdb_byte zero[8] = { 0 };
regcache_raw_supply (regcache, regno, zero);
continue;
}
addr = 8 * core_reg_mapping[regno];
if (addr < 0 || addr >= core_reg_size)
{
/* ??? UNIQUE is a new addition. Don't generate an error. */
if (regno == ALPHA_UNIQUE_REGNUM)
{
regcache_raw_supply (regcache, regno, NULL);
continue;
}
if (bad_reg < 0)
bad_reg = regno;
}
else
{
regcache_raw_supply (regcache, regno, core_reg_sect + addr);
}
}
if (bad_reg >= 0)
{
error (_("Register %s not found in core file."),
gdbarch_register_name (gdbarch, bad_reg));
}
}
#include <sys/procfs.h>
/* Prototypes for supply_gregset etc. */
#include "gregset.h"
/* See the comment in m68k-tdep.c regarding the utility of these
functions. */
void
supply_gregset (struct regcache *regcache, const gdb_gregset_t *gregsetp)
{
const long *regp = gregsetp->regs;
/* PC is in slot 32. */
alpha_supply_int_regs (regcache, -1, regp, regp + 31, NULL);
}
void
fill_gregset (const struct regcache *regcache,
gdb_gregset_t *gregsetp, int regno)
{
long *regp = gregsetp->regs;
/* PC is in slot 32. */
alpha_fill_int_regs (regcache, regno, regp, regp + 31, NULL);
}
/* Now we do the same thing for floating-point registers.
Again, see the comments in m68k-tdep.c. */
void
supply_fpregset (struct regcache *regcache, const gdb_fpregset_t *fpregsetp)
{
const long *regp = fpregsetp->regs;
/* FPCR is in slot 32. */
alpha_supply_fp_regs (regcache, -1, regp, regp + 31);
}
void
fill_fpregset (const struct regcache *regcache,
gdb_fpregset_t *fpregsetp, int regno)
{
long *regp = fpregsetp->regs;
/* FPCR is in slot 32. */
alpha_fill_fp_regs (regcache, regno, regp, regp + 31);
}
/* Register that we are able to handle alpha core file formats. */
static struct core_fns alpha_osf_core_fns =
{
/* This really is bfd_target_unknown_flavour. */
bfd_target_unknown_flavour, /* core_flavour */
default_check_format, /* check_format */
default_core_sniffer, /* core_sniffer */
fetch_osf_core_registers, /* core_read_registers */
NULL /* next */
};
/* Provide a prototype to silence -Wmissing-prototypes. */
extern initialize_file_ftype _initialize_alpha_nat;
void
_initialize_alpha_nat (void)
{
struct target_ops *t;
t = procfs_target ();
add_target (t);
deprecated_add_core_fns (&alpha_osf_core_fns);
}

78
gdb/alpha-osf1-tdep.c
View File

@ -1,78 +0,0 @@
/* Target-dependent code for OSF/1 on Alpha.
Copyright (C) 2002-2014 Free Software Foundation, Inc.
This file is part of GDB.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>. */
#include "defs.h"
#include "frame.h"
#include "gdbcore.h"
#include "value.h"
#include "osabi.h"
#include "objfiles.h"
#include "alpha-tdep.h"
static int
alpha_osf1_pc_in_sigtramp (struct gdbarch *gdbarch,
CORE_ADDR pc, const char *func_name)
{
return (func_name != NULL && strcmp ("__sigtramp", func_name) == 0);
}
static CORE_ADDR
alpha_osf1_sigcontext_addr (struct frame_info *this_frame)
{
struct gdbarch *gdbarch = get_frame_arch (this_frame);
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
struct frame_info *next_frame = get_next_frame (this_frame);
struct frame_id next_id = null_frame_id;
if (next_frame != NULL)
next_id = get_frame_id (next_frame);
return (read_memory_integer (next_id.stack_addr, 8, byte_order));
}
static void
alpha_osf1_init_abi (struct gdbarch_info info,
struct gdbarch *gdbarch)
{
struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
/* Hook into the MDEBUG frame unwinder. */
alpha_mdebug_init_abi (info, gdbarch);
/* The next/step support via procfs on OSF1 is broken when running
on multi-processor machines. We need to use software single
stepping instead. */
set_gdbarch_software_single_step (gdbarch, alpha_software_single_step);
tdep->sigcontext_addr = alpha_osf1_sigcontext_addr;
tdep->pc_in_sigtramp = alpha_osf1_pc_in_sigtramp;
tdep->jb_pc = 2;
tdep->jb_elt_size = 8;
}
/* Provide a prototype to silence -Wmissing-prototypes. */
extern initialize_file_ftype _initialize_alpha_osf1_tdep;
void
_initialize_alpha_osf1_tdep (void)
{
gdbarch_register_osabi (bfd_arch_alpha, 0, GDB_OSABI_OSF1,
alpha_osf1_init_abi);
}

8
gdb/alpha-tdep.c
View File

@ -1749,14 +1749,6 @@ alpha_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
struct gdbarch_tdep *tdep; struct gdbarch_tdep *tdep;
struct gdbarch *gdbarch; struct gdbarch *gdbarch;
/* Try to determine the ABI of the object we are loading. */
if (info.abfd != NULL && info.osabi == GDB_OSABI_UNKNOWN)
{
/* If it's an ECOFF file, assume it's OSF/1. */
if (bfd_get_flavour (info.abfd) == bfd_target_ecoff_flavour)
info.osabi = GDB_OSABI_OSF1;
}
/* Find a candidate among extant architectures. */ /* Find a candidate among extant architectures. */
arches = gdbarch_list_lookup_by_info (arches, &info); arches = gdbarch_list_lookup_by_info (arches, &info);
if (arches != NULL) if (arches != NULL)

7
gdb/config/alpha/alpha-osf3.mh
View File

@ -1,7 +0,0 @@
# Host: Little-endian Alpha running OSF/1-3.x and higher using procfs
NAT_FILE= nm-osf3.h
NATDEPFILES= alpha-nat.o fork-child.o \
solib-osf.o procfs.o proc-api.o proc-events.o proc-flags.o \
proc-why.o dec-thread.o
HAVE_NATIVE_GCORE_HOST = 1
NAT_CLIBS= -lpthreaddebug

35
gdb/config/alpha/nm-osf3.h
View File

@ -1,35 +0,0 @@
/* Native definitions for alpha running OSF/1-3.x and higher, using procfs.
Copyright (C) 1995-2014 Free Software Foundation, Inc.
This file is part of GDB.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>. */
/* Number of traps that happen between exec'ing the shell to run an
inferior, and when we finally get to the inferior code, not
counting the exec for the shell. This is 1 on most
implementations. */
#define START_INFERIOR_TRAPS_EXPECTED 2
/* Don't trace faults under OSF/1, rely on the posting of the appropriate
signal if fault tracing is disabled.
Tracing T_IFAULT under Alpha OSF/1 causes a `floating point enable'
fault from which we cannot continue (except by disabling the
tracing).
And as OSF/1 doesn't provide the standard fault definitions, the
mapping of faults to appropriate signals in procfs_wait is difficult. */
#define PROCFS_DONT_TRACE_FAULTS
/* Work around some peculiarities in the OSF/1 procfs implementation. */
#define PROCFS_NEED_CLEAR_CURSIG_FOR_KILL

3
gdb/config/djgpp/fnchange.lst
View File

@ -132,9 +132,6 @@
@V@/gdb/armnbsd-nat.c @V@/gdb/armnbd-nat.c @V@/gdb/armnbsd-nat.c @V@/gdb/armnbd-nat.c
@V@/gdb/armnbsd-tdep.c @V@/gdb/armnbd-tdep.c @V@/gdb/armnbsd-tdep.c @V@/gdb/armnbd-tdep.c
@V@/gdb/c-exp.tab.c @V@/gdb/c-exp_tab.c @V@/gdb/c-exp.tab.c @V@/gdb/c-exp_tab.c
@V@/gdb/config/alpha/alpha-osf1.mh @V@/gdb/config/alpha/alphosf1.mh
@V@/gdb/config/alpha/alpha-osf2.mh @V@/gdb/config/alpha/alphosf2.mh
@V@/gdb/config/alpha/alpha-osf3.mh @V@/gdb/config/alpha/alphosf3.mh
@V@/gdb/config/alpha/tm-alphalinux.h @V@/gdb/config/alpha/tm-alplinux.h @V@/gdb/config/alpha/tm-alphalinux.h @V@/gdb/config/alpha/tm-alplinux.h
@V@/gdb/config/i386/nm-cygwin64.h @V@/gdb/config/i386/nm-cyg64.h @V@/gdb/config/i386/nm-cygwin64.h @V@/gdb/config/i386/nm-cyg64.h
@V@/gdb/config/i386/nm-linux64.h @V@/gdb/config/i386/nm-lx64.h @V@/gdb/config/i386/nm-linux64.h @V@/gdb/config/i386/nm-lx64.h

27
gdb/configure vendored
View File

@ -7062,33 +7062,6 @@ _ACEOF
fi fi
# On alpha-osf, it appears that libtermcap and libcurses are not compatible.
# There is a very specific comment in /usr/include/curses.h explaining that
# termcap routines built into libcurses must not be used.
#
# The symptoms we observed so far is GDB unexpectedly changing
# the terminal settings when tgetent is called - this is particularly
# visible as the output is missing carriage returns, and so rapidly
# becomes very hard to read.
#
# The readline configure script has already decided that libtermcap
# was enough for its purposes, and so decided to build readline using
# libtermcap. Since the TUI mode requires curses, building GDB with
# TUI enabled results in both libraries to be used at the same time,
# which is not allowed. This basically means that GDB with TUI is
# broken on alpha-osf.
case $host_os in
osf* )
if test x"$enable_tui" = xyes; then
as_fn_error "Building GDB with TUI mode is not supported on this host" "$LINENO" 5
fi
if test x"$enable_tui" = xauto; then
enable_tui=no
fi
;;
esac
# For the TUI, we need enhanced curses functionality. # For the TUI, we need enhanced curses functionality.
if test x"$enable_tui" != xno; then if test x"$enable_tui" != xno; then
prefer_curses=yes prefer_curses=yes

27
gdb/configure.ac
View File

@ -546,33 +546,6 @@ AS_HELP_STRING([--with-iconv-bin=PATH], [specify where to find the iconv program
GDB_AC_DEFINE_RELOCATABLE(ICONV_BIN, iconv, ${iconv_bin}) GDB_AC_DEFINE_RELOCATABLE(ICONV_BIN, iconv, ${iconv_bin})
]) ])
# On alpha-osf, it appears that libtermcap and libcurses are not compatible.
# There is a very specific comment in /usr/include/curses.h explaining that
# termcap routines built into libcurses must not be used.
#
# The symptoms we observed so far is GDB unexpectedly changing
# the terminal settings when tgetent is called - this is particularly
# visible as the output is missing carriage returns, and so rapidly
# becomes very hard to read.
#
# The readline configure script has already decided that libtermcap
# was enough for its purposes, and so decided to build readline using
# libtermcap. Since the TUI mode requires curses, building GDB with
# TUI enabled results in both libraries to be used at the same time,
# which is not allowed. This basically means that GDB with TUI is
# broken on alpha-osf.
case $host_os in
osf* )
if test x"$enable_tui" = xyes; then
AC_MSG_ERROR([Building GDB with TUI mode is not supported on this host])
fi
if test x"$enable_tui" = xauto; then
enable_tui=no
fi
;;
esac
# For the TUI, we need enhanced curses functionality. # For the TUI, we need enhanced curses functionality.
if test x"$enable_tui" != xno; then if test x"$enable_tui" != xno; then
prefer_curses=yes prefer_curses=yes

4
gdb/configure.host
View File

@ -20,8 +20,7 @@ case $host in
vax-*-netbsdelf*) vax-*-netbsdelf*)
;; ;;
*-*-irix* | \ *-*-irix* | \
alpha*-*-osf1* | \ alpha*-*-osf* | \
alpha*-*-osf2* | \
arm*-*-netbsd* | \ arm*-*-netbsd* | \
hppa*-*-hiux* | \ hppa*-*-hiux* | \
i[34567]86-ncr-* | \ i[34567]86-ncr-* | \
@ -80,7 +79,6 @@ case "${host}" in
aarch64*-*-linux*) gdb_host=linux ;; aarch64*-*-linux*) gdb_host=linux ;;
alpha*-*-osf[3456789]*) gdb_host=alpha-osf3 ;;
alpha*-*-linux*) gdb_host=alpha-linux ;; alpha*-*-linux*) gdb_host=alpha-linux ;;
alpha*-*-freebsd* | alpha*-*-kfreebsd*-gnu) alpha*-*-freebsd* | alpha*-*-kfreebsd*-gnu)
gdb_host=fbsd ;; gdb_host=fbsd ;;

5
gdb/configure.tgt
View File

@ -14,6 +14,7 @@
case $targ in case $targ in
*-*-irix* | \ *-*-irix* | \
alpha*-*-osf* | \
d10v-*-* | \ d10v-*-* | \
hppa*-*-hiux* | \ hppa*-*-hiux* | \
i[34567]86-ncr-* | \ i[34567]86-ncr-* | \
@ -46,10 +47,6 @@ aarch64*-*-linux*)
build_gdbserver=yes build_gdbserver=yes
;; ;;
alpha*-*-osf*)
# Target: Little-endian Alpha running OSF/1
gdb_target_obs="alpha-tdep.o alpha-osf1-tdep.o alpha-mdebug-tdep.o"
;;
alpha*-*-linux*) alpha*-*-linux*)
# Target: Little-endian Alpha running Linux # Target: Little-endian Alpha running Linux
gdb_target_obs="alpha-tdep.o alpha-mdebug-tdep.o alpha-linux-tdep.o \ gdb_target_obs="alpha-tdep.o alpha-mdebug-tdep.o alpha-linux-tdep.o \

705
gdb/dec-thread.c
View File

@ -1,705 +0,0 @@
/* Copyright (C) 2008-2014 Free Software Foundation, Inc.
This file is part of GDB.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>. */
#include "defs.h"
#include "command.h"
#include "gdbcmd.h"
#include "target.h"
#include "observer.h"
#include <sys/procfs.h>
#include "gregset.h"
#include "regcache.h"
#include "inferior.h"
#include "gdbthread.h"
#include <pthread_debug.h>
/* Print debugging traces if set to non-zero. */
static int debug_dec_thread = 0;
/* Non-zero if the dec-thread layer is active. */
static int dec_thread_active = 0;
/* The pthread_debug context. */
pthreadDebugContext_t debug_context;
/* The dec-thread target_ops structure. */
static struct target_ops dec_thread_ops;
/* Print a debug trace if DEBUG_DEC_THREAD is set (its value is adjusted
by the user using "set debug dec-thread ..."). */
static void
debug (char *format, ...)
{
if (debug_dec_thread)
{
va_list args;
va_start (args, format);
printf_unfiltered ("DEC Threads: ");
vprintf_unfiltered (format, args);
printf_unfiltered ("\n");
va_end (args);
}
}
/* pthread debug callbacks. */
static int
suspend_clbk (void *caller_context)
{
return ESUCCESS;
}
static int
resume_clbk (void *caller_context)
{
return ESUCCESS;
}
static int
hold_clbk (void *caller_context, pthreadDebugKId_t kernel_tid)
{
return ESUCCESS;
}
static int
unhold_clbk (void *caller_context, pthreadDebugKId_t kernel_tid)
{
return ESUCCESS;
}
static int
read_clbk (void *caller_context, void *address, void *buffer,
unsigned long size)
{
int status = target_read_memory ((CORE_ADDR) address, buffer, size);
if (status != 0)
return EINVAL;
return ESUCCESS;
}
static int
write_clbk (void *caller_context, void *address, void *buffer,
unsigned long size)
{
int status = target_write_memory ((CORE_ADDR) address, buffer, size);
if (status != 0)
return EINVAL;
return ESUCCESS;
}
/* Get integer regs. */
static int
get_reg_clbk(void *caller_context, pthreadDebugGetRegRtn_t regs,
pthreadDebugKId_t kernel_tid)
{
debug ("get_reg_clbk");
/* Not sure that we actually need to do anything in this callback. */
return ESUCCESS;
}
/* Set integer regs. */
static int
set_reg_clbk(void *caller_context, const pthreadDebugRegs_t *regs,
pthreadDebugKId_t kernel_tid)
{
debug ("set_reg_clbk");
/* Not sure that we actually need to do anything in this callback. */
return ESUCCESS;
}
static int
output_clbk (void *caller_context, char *line)
{
printf_filtered ("%s\n", line);
return ESUCCESS;
}
static int
error_clbk (void *caller_context, char *line)
{
fprintf_filtered (gdb_stderr, "%s\n", line);
return ESUCCESS;
}
/* Get floating-point regs. */
static int
get_fpreg_clbk (void *caller_context, pthreadDebugFregs_p fregs,
pthreadDebugKId_t kernel_tid)
{
debug ("get_fpreg_clbk");
/* Not sure that we actually need to do anything in this callback. */
return ESUCCESS;
}
/* Set floating-point regs. */
static int
set_fpreg_clbk (void *caller_context, const pthreadDebugFregs_t *fregs,
pthreadDebugKId_t kernel_tid)
{
debug ("set_fpreg_clbk");
/* Not sure that we actually need to do anything in this callback. */
return ESUCCESS;
}
static void *
malloc_clbk (void *caller_context, size_t size)
{
return xmalloc (size);
}
static void
free_clbk (void *caller_context, void *address)
{
xfree (address);
}
static int
kthdinfo_clbk (pthreadDebugClient_t caller_context,
pthreadDebugKId_t kernel_tid,
pthreadDebugKThreadInfo_p thread_info)
{
return ENOTSUP;
}
static int
speckthd_clbk (pthreadDebugClient_t caller_context,
pthreadDebugSpecialType_t type,
pthreadDebugKId_t *kernel_tid)
{
return ENOTSUP;
}
static pthreadDebugCallbacks_t debug_callbacks =
{
PTHREAD_DEBUG_VERSION,
(pthreadDebugGetMemRtn_t) read_clbk,
(pthreadDebugSetMemRtn_t) write_clbk,
suspend_clbk,
resume_clbk,
kthdinfo_clbk,
hold_clbk,
unhold_clbk,
(pthreadDebugGetFregRtn_t) get_fpreg_clbk,
(pthreadDebugSetFregRtn_t) set_fpreg_clbk,
(pthreadDebugGetRegRtn_t) get_reg_clbk,
(pthreadDebugSetRegRtn_t) set_reg_clbk,
(pthreadDebugOutputRtn_t) output_clbk,
(pthreadDebugOutputRtn_t) error_clbk,
malloc_clbk,
free_clbk,
speckthd_clbk
};
/* Activate thread support if appropriate. Do nothing if thread
support is already active. */
static void
enable_dec_thread (void)
{
struct bound_minimal_symbol msym;
void* caller_context;
int status;
/* If already active, nothing more to do. */
if (dec_thread_active)
return;
msym = lookup_minimal_symbol ("__pthread_dbg_symtable", NULL, NULL);
if (msym.minsym == NULL)
{
debug ("enable_dec_thread: No __pthread_dbg_symtable");
return;
}
status = pthreadDebugContextInit (&caller_context, &debug_callbacks,
(void *) SYMBOL_VALUE_ADDRESS (msym.minsym),
&debug_context);
if (status != ESUCCESS)
{
debug ("enable_dec_thread: pthreadDebugContextInit -> %d",
status);
return;
}
push_target (&dec_thread_ops);
dec_thread_active = 1;
debug ("enable_dec_thread: Thread support enabled.");
}
/* Deactivate thread support. Do nothing if thread support is
already inactive. */
static void
disable_dec_thread (void)
{
if (!dec_thread_active)
return;
pthreadDebugContextDestroy (debug_context);
unpush_target (&dec_thread_ops);
dec_thread_active = 0;
}
/* A structure that contains a thread ID and is associated
pthreadDebugThreadInfo_t data. */
struct dec_thread_info
{
pthreadDebugId_t thread;
pthreadDebugThreadInfo_t info;
};
typedef struct dec_thread_info dec_thread_info_s;
/* The list of user threads. */
DEF_VEC_O (dec_thread_info_s);
VEC(dec_thread_info_s) *dec_thread_list;
/* Release the memory used by the given VECP thread list pointer.
Then set *VECP to NULL. */
static void
free_dec_thread_info_vec (VEC(dec_thread_info_s) **vecp)
{
int i;
struct dec_thread_info *item;
VEC(dec_thread_info_s) *vec = *vecp;
for (i = 0; VEC_iterate (dec_thread_info_s, vec, i, item); i++)
xfree (item);
VEC_free (dec_thread_info_s, vec);
*vecp = NULL;
}
/* Return a thread's ptid given its associated INFO. */
static ptid_t
ptid_build_from_info (struct dec_thread_info info)
{
int pid = ptid_get_pid (inferior_ptid);
return ptid_build (pid, 0, (long) info.thread);
}
/* Return non-zero if PTID is still alive.
Assumes that DEC_THREAD_LIST is up to date. */
static int
dec_thread_ptid_is_alive (ptid_t ptid)
{
pthreadDebugId_t tid = ptid_get_tid (ptid);
int i;
struct dec_thread_info *info;
if (tid == 0)
/* This is the thread corresponding to the process. This ptid
is always alive until the program exits. */
return 1;
/* Search whether an entry with the same tid exists in the dec-thread
list of threads. If it does, then the thread is still alive.
No match found means that the thread must be dead, now. */
for (i = 0; VEC_iterate (dec_thread_info_s, dec_thread_list, i, info); i++)
if (info->thread == tid)
return 1;
return 0;
}
/* Recompute the list of user threads and store the result in
DEC_THREAD_LIST. */
static void
update_dec_thread_list (void)
{
pthreadDebugId_t thread;
pthreadDebugThreadInfo_t info;
int res;
free_dec_thread_info_vec (&dec_thread_list);
res = pthreadDebugThdSeqInit (debug_context, &thread);
while (res == ESUCCESS)
{
res = pthreadDebugThdGetInfo (debug_context, thread, &info);
if (res != ESUCCESS)
warning (_("unable to get thread info, ignoring thread %ld"),
thread);
else if (info.kind == PTHREAD_DEBUG_THD_KIND_INITIAL
|| info.kind == PTHREAD_DEBUG_THD_KIND_NORMAL)
{
struct dec_thread_info *item =
xmalloc (sizeof (struct dec_thread_info));
item->thread = thread;
item->info = info;
VEC_safe_push (dec_thread_info_s, dec_thread_list, item);
}
res = pthreadDebugThdSeqNext (debug_context, &thread);
}
pthreadDebugThdSeqDestroy (debug_context);
}
/* Implement the update_thread_list target_ops method. */
static void
dec_thread_update_thread_list (struct target_ops *ops)
{
int i;
struct dec_thread_info *info;
struct thread_info *tp, *tmp;
update_dec_thread_list ();
/* Delete GDB-side threads no longer found in dec_thread_list. */
ALL_NON_EXITED_THREADS_SAFE (tp, tmp)
{
for (i = 0; VEC_iterate (dec_thread_info_s, dec_thread_list, i, info); i++)
{
if (ptid_equal (info->ptid, tp->ptid))
break;
}
if (i == VEC_length (dec_thread_info_s, dec_thread_list))
{
/* Not found. */
delete_thread (tp->ptid);
}
}
/* And now add new threads. */
for (i = 0; VEC_iterate (dec_thread_info_s, dec_thread_list, i, info); i++)
{
ptid_t ptid = ptid_build_from_info (*info);
if (!in_thread_list (ptid))
add_thread (ptid);
}
}
/* The "to_detach" method of the dec_thread_ops. */
static void
dec_thread_detach (struct target_ops *ops, const char *args, int from_tty)
{
struct target_ops *beneath = find_target_beneath (ops);
debug ("dec_thread_detach");
disable_dec_thread ();
beneath->to_detach (beneath, args, from_tty);
}
/* Return the ptid of the thread that is currently active. */
static ptid_t
get_active_ptid (void)
{
int i;
struct dec_thread_info *info;
for (i = 0; VEC_iterate (dec_thread_info_s, dec_thread_list, i, info);
i++)
if (info->info.state == PTHREAD_DEBUG_STATE_RUNNING)
return ptid_build_from_info (*info);
/* No active thread found. This can happen when the program
has just exited. */
return null_ptid;
}
/* The "to_wait" method of the dec_thread_ops. */
static ptid_t
dec_thread_wait (struct target_ops *ops,
ptid_t ptid, struct target_waitstatus *status, int options)
{
ptid_t active_ptid;
struct target_ops *beneath = find_target_beneath (ops);
debug ("dec_thread_wait");
ptid = beneath->to_wait (beneath, ptid, status, options);
/* The ptid returned by the target beneath us is the ptid of the process.
We need to find which thread is currently active and return its ptid. */
dec_thread_update_thread_list (ops);
active_ptid = get_active_ptid ();
if (ptid_equal (active_ptid, null_ptid))
return ptid;
return active_ptid;
}
/* Fetch the general purpose and floating point registers for the given
thread TID, and store the result in GREGSET and FPREGSET. Return
zero if successful. */
static int
dec_thread_get_regsets (pthreadDebugId_t tid, gdb_gregset_t *gregset,
gdb_fpregset_t *fpregset)
{
int res;
pthreadDebugRegs_t regs;
pthreadDebugFregs_t fregs;
res = pthreadDebugThdGetReg (debug_context, tid, &regs);
if (res != ESUCCESS)
{
debug ("dec_thread_get_regsets: pthreadDebugThdGetReg -> %d", res);
return -1;
}
memcpy (gregset->regs, &regs, sizeof (regs));
res = pthreadDebugThdGetFreg (debug_context, tid, &fregs);
if (res != ESUCCESS)
{
debug ("dec_thread_get_regsets: pthreadDebugThdGetFreg -> %d", res);
return -1;
}
memcpy (fpregset->regs, &fregs, sizeof (fregs));
return 0;
}
/* The "to_fetch_registers" method of the dec_thread_ops.
Because the dec-thread debug API doesn't allow us to fetch
only one register, we simply ignore regno and fetch+supply all
registers. */
static void
dec_thread_fetch_registers (struct target_ops *ops,
struct regcache *regcache, int regno)
{
pthreadDebugId_t tid = ptid_get_tid (inferior_ptid);
gregset_t gregset;
fpregset_t fpregset;
int res;
debug ("dec_thread_fetch_registers (tid=%ld, regno=%d)", tid, regno);
if (tid == 0 || ptid_equal (inferior_ptid, get_active_ptid ()))
{
struct target_ops *beneath = find_target_beneath (ops);
beneath->to_fetch_registers (beneath, regcache, regno);
return;
}
res = dec_thread_get_regsets (tid, &gregset, &fpregset);
if (res != 0)
return;
supply_gregset (regcache, &gregset);
supply_fpregset (regcache, &fpregset);
}
/* Store the registers given in GREGSET and FPREGSET into the associated
general purpose and floating point registers of thread TID. Return
zero if successful. */
static int
dec_thread_set_regsets (pthreadDebugId_t tid, gdb_gregset_t gregset,
gdb_fpregset_t fpregset)
{
int res;
pthreadDebugRegs_t regs;
pthreadDebugFregs_t fregs;
memcpy (&regs, gregset.regs, sizeof (regs));
res = pthreadDebugThdSetReg (debug_context, tid, &regs);
if (res != ESUCCESS)
{
debug ("dec_thread_set_regsets: pthreadDebugThdSetReg -> %d", res);
return -1;
}
memcpy (&fregs, fpregset.regs, sizeof (fregs));
res = pthreadDebugThdSetFreg (debug_context, tid, &fregs);
if (res != ESUCCESS)
{
debug ("dec_thread_set_regsets: pthreadDebugThdSetFreg -> %d", res);
return -1;
}
return 0;
}
/* The "to_store_registers" method of the dec_thread_ops.
Because the dec-thread debug API doesn't allow us to store
just one register, we store all the registers. */
static void
dec_thread_store_registers (struct target_ops *ops,
struct regcache *regcache, int regno)
{
pthreadDebugId_t tid = ptid_get_tid (inferior_ptid);
gregset_t gregset;
fpregset_t fpregset;
int res;
debug ("dec_thread_store_registers (tid=%ld, regno=%d)", tid, regno);
if (tid == 0 || ptid_equal (inferior_ptid, get_active_ptid ()))
{
struct target_ops *beneath = find_target_beneath (ops);
beneath->to_store_registers (beneath, regcache, regno);
return;
}
/* FIXME: brobecker/2008-05-28: I wonder if we could simply check
in which register set the register is and then only store the
registers for that register set, instead of storing both register
sets. */
fill_gregset (regcache, &gregset, -1);
fill_fpregset (regcache, &fpregset, -1);
res = dec_thread_set_regsets (tid, gregset, fpregset);
if (res != 0)
warning (_("failed to store registers."));
}
/* The "to_mourn_inferior" method of the dec_thread_ops. */
static void
dec_thread_mourn_inferior (struct target_ops *ops)
{
struct target_ops *beneath = find_target_beneath (ops);
debug ("dec_thread_mourn_inferior");
disable_dec_thread ();
beneath->to_mourn_inferior (beneath);
}
/* The "to_thread_alive" method of the dec_thread_ops. */
static int
dec_thread_thread_alive (struct target_ops *ops, ptid_t ptid)
{
debug ("dec_thread_thread_alive (tid=%ld)", ptid_get_tid (ptid));
/* The thread list maintained by GDB is up to date, since we update
it everytime we stop. So check this list. */
return in_thread_list (ptid);
}
/* The "to_pid_to_str" method of the dec_thread_ops. */
static char *
dec_thread_pid_to_str (struct target_ops *ops, ptid_t ptid)
{
static char *ret = NULL;
if (ptid_get_tid (ptid) == 0)
{
struct target_ops *beneath = find_target_beneath (ops);
return beneath->to_pid_to_str (beneath, ptid);
}
/* Free previous return value; a new one will be allocated by
xstrprintf(). */
xfree (ret);
ret = xstrprintf (_("Thread %ld"), ptid_get_tid (ptid));
return ret;
}
/* A "new-objfile" observer. Used to activate/deactivate dec-thread
support. */
static void
dec_thread_new_objfile_observer (struct objfile *objfile)
{
if (objfile != NULL)
enable_dec_thread ();
else
disable_dec_thread ();
}
/* The "to_get_ada_task_ptid" method of the dec_thread_ops. */
static ptid_t
dec_thread_get_ada_task_ptid (struct target_ops *self, long lwp, long thread)
{
int i;
struct dec_thread_info *info;
debug ("dec_thread_get_ada_task_ptid (struct target_ops *self,"
" lwp=0x%lx, thread=0x%lx)",
lwp, thread);
for (i = 0; VEC_iterate (dec_thread_info_s, dec_thread_list, i, info);
i++)
if (info->info.teb == (pthread_t) thread)
return ptid_build_from_info (*info);
warning (_("Could not find thread id from THREAD = 0x%lx"), thread);
return inferior_ptid;
}
static void
init_dec_thread_ops (void)
{
dec_thread_ops.to_shortname = "dec-threads";
dec_thread_ops.to_longname = _("DEC threads support");
dec_thread_ops.to_doc = _("DEC threads support");
dec_thread_ops.to_detach = dec_thread_detach;
dec_thread_ops.to_wait = dec_thread_wait;
dec_thread_ops.to_fetch_registers = dec_thread_fetch_registers;
dec_thread_ops.to_store_registers = dec_thread_store_registers;
dec_thread_ops.to_mourn_inferior = dec_thread_mourn_inferior;
dec_thread_ops.to_thread_alive = dec_thread_thread_alive;
dec_thread_ops.to_update_thread_list = dec_thread_update_thread_list;
dec_thread_ops.to_pid_to_str = dec_thread_pid_to_str;
dec_thread_ops.to_stratum = thread_stratum;
dec_thread_ops.to_get_ada_task_ptid = dec_thread_get_ada_task_ptid;
dec_thread_ops.to_magic = OPS_MAGIC;
}
void
_initialize_dec_thread (void)
{
init_dec_thread_ops ();
complete_target_initialization (&dec_thread_ops);
observer_attach_new_objfile (dec_thread_new_objfile_observer);
add_setshow_boolean_cmd ("dec-thread", class_maintenance, &debug_dec_thread,
_("Set debugging of DEC threads module."),
_("Show debugging of DEC threads module."),
_("Enables debugging output (used to debug GDB)."),
NULL, NULL,
&setdebuglist, &showdebuglist);
}

1
gdb/defs.h
View File

@ -514,7 +514,6 @@ enum gdb_osabi
GDB_OSABI_SVR4, GDB_OSABI_SVR4,
GDB_OSABI_HURD, GDB_OSABI_HURD,
GDB_OSABI_SOLARIS, GDB_OSABI_SOLARIS,
GDB_OSABI_OSF1,
GDB_OSABI_LINUX, GDB_OSABI_LINUX,
GDB_OSABI_FREEBSD_AOUT, GDB_OSABI_FREEBSD_AOUT,
GDB_OSABI_FREEBSD_ELF, GDB_OSABI_FREEBSD_ELF,

5
gdb/doc/ChangeLog
View File

@ -1,3 +1,8 @@
2014-10-17 Pedro Alves <palves@redhat.com>
* gdb.texinfo (Ada Tasks and Core Files): Delete mention of Tru64.
(SVR4 Process Information): Delete mention of OSF/1.
2014-10-01 Simon Marchi <simon.marchi@ericsson.com> 2014-10-01 Simon Marchi <simon.marchi@ericsson.com>
* gdb.texinfo (Miscellaneous gdb/mi Commands): Document new * gdb.texinfo (Miscellaneous gdb/mi Commands): Document new

8
gdb/doc/gdb.texinfo
View File

@ -15725,10 +15725,9 @@ When inspecting a core file, as opposed to debugging a live program,
tasking support may be limited or even unavailable, depending on tasking support may be limited or even unavailable, depending on
the platform being used. the platform being used.
For instance, on x86-linux, the list of tasks is available, but task For instance, on x86-linux, the list of tasks is available, but task
switching is not supported. On Tru64, however, task switching will work switching is not supported.
as usual.
On certain platforms, including Tru64, the debugger needs to perform some On certain platforms, the debugger needs to perform some
memory writes in order to provide Ada tasking support. When inspecting memory writes in order to provide Ada tasking support. When inspecting
a core file, this means that the core file must be opened with read-write a core file, this means that the core file must be opened with read-write
privileges, using the command @samp{"set write on"} (@pxref{Patching}). privileges, using the command @samp{"set write on"} (@pxref{Patching}).
@ -19726,8 +19725,7 @@ If @value{GDBN} is configured for an operating system with this
facility, the command @code{info proc} is available to report facility, the command @code{info proc} is available to report
information about the process running your program, or about any information about the process running your program, or about any
process running on your system. This includes, as of this writing, process running on your system. This includes, as of this writing,
@sc{gnu}/Linux, OSF/1 (Digital Unix), Solaris, and Irix, but @sc{gnu}/Linux and Solaris, but not HP-UX, for example.
not HP-UX, for example.
This command may also work on core files that were created on a system This command may also work on core files that were created on a system
that has the @samp{/proc} facility. that has the @samp{/proc} facility.

6
gdb/inferior.h
View File

@ -250,11 +250,9 @@ enum stop_kind
/* Number of traps that happen between exec'ing the shell to run an /* Number of traps that happen between exec'ing the shell to run an
inferior and when we finally get to the inferior code, not counting inferior and when we finally get to the inferior code, not counting
the exec for the shell. This is 1 on most implementations. the exec for the shell. This is 1 on all supported
Overridden in nm.h files. */ implementations. */
#if !defined(START_INFERIOR_TRAPS_EXPECTED)
#define START_INFERIOR_TRAPS_EXPECTED 1 #define START_INFERIOR_TRAPS_EXPECTED 1
#endif
struct private_inferior; struct private_inferior;

1
gdb/osabi.c
View File

@ -50,7 +50,6 @@ static const char * const gdb_osabi_names[] =
"SVR4", "SVR4",
"GNU/Hurd", "GNU/Hurd",
"Solaris", "Solaris",
"OSF/1",
"GNU/Linux", "GNU/Linux",
"FreeBSD a.out", "FreeBSD a.out",
"FreeBSD ELF", "FreeBSD ELF",

17
gdb/procfs.c
View File

@ -2917,16 +2917,9 @@ procfs_debug_inferior (procinfo *pi)
sysset_t *traced_syscall_exits; sysset_t *traced_syscall_exits;
int status; int status;
#ifdef PROCFS_DONT_TRACE_FAULTS
/* On some systems (OSF), we don't trace hardware faults.
Apparently it's enough that we catch them as signals.
Wonder why we don't just do that in general? */
premptyset (&traced_faults); /* don't trace faults. */
#else
/* Register to trace hardware faults in the child. */ /* Register to trace hardware faults in the child. */
prfillset (&traced_faults); /* trace all faults... */ prfillset (&traced_faults); /* trace all faults... */
gdb_prdelset (&traced_faults, FLTPAGE); /* except page fault. */ gdb_prdelset (&traced_faults, FLTPAGE); /* except page fault. */
#endif
if (!proc_set_traced_faults (pi, &traced_faults)) if (!proc_set_traced_faults (pi, &traced_faults))
return __LINE__; return __LINE__;
@ -4227,16 +4220,6 @@ unconditionally_kill_inferior (procinfo *pi)
int parent_pid; int parent_pid;
parent_pid = proc_parent_pid (pi); parent_pid = proc_parent_pid (pi);
#ifdef PROCFS_NEED_CLEAR_CURSIG_FOR_KILL
/* FIXME: use access functions. */
/* Alpha OSF/1-3.x procfs needs a clear of the current signal
before the PIOCKILL, otherwise it might generate a corrupted core
file for the inferior. */
if (ioctl (pi->ctl_fd, PIOCSSIG, NULL) < 0)
{
printf_filtered ("unconditionally_kill: SSIG failed!\n");
}
#endif
#ifdef PROCFS_NEED_PIOCSSIG_FOR_KILL #ifdef PROCFS_NEED_PIOCSSIG_FOR_KILL
/* Alpha OSF/1-2.x procfs needs a PIOCSSIG call with a SIGKILL signal /* Alpha OSF/1-2.x procfs needs a PIOCSSIG call with a SIGKILL signal
to kill the inferior, otherwise it might remain stopped with a to kill the inferior, otherwise it might remain stopped with a

638
gdb/solib-osf.c
View File

@ -1,638 +0,0 @@
/* Handle OSF/1, Digital UNIX, and Tru64 shared libraries
for GDB, the GNU Debugger.
Copyright (C) 1993-2014 Free Software Foundation, Inc.
This file is part of GDB.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>. */
/* When handling shared libraries, GDB has to find out the pathnames
of all shared libraries that are currently loaded (to read in their
symbols) and where the shared libraries are loaded in memory
(to relocate them properly from their prelinked addresses to the
current load address).
Under OSF/1 there are two possibilities to get at this information:
1) Peek around in the runtime loader structures.
These are not documented, and they are not defined in the system
header files. The definitions below were obtained by experimentation,
but they seem stable enough.
2) Use the libxproc.a library, which contains the equivalent ldr_*
routines. The library is documented in Tru64 5.x, but as of 5.1, it
only allows a process to examine itself. On earlier versions, it
may require that the GDB executable be dynamically linked and that
NAT_CLIBS include -lxproc -Wl,-expect_unresolved,ldr_process_context
for GDB and all applications that are using libgdb.
We will use the peeking approach until libxproc.a works for other
processes. */
#include "defs.h"
#include <sys/types.h>
#include <signal.h>
#include "bfd.h"
#include "symtab.h"
#include "symfile.h"
#include "objfiles.h"
#include "target.h"
#include "inferior.h"
#include "infrun.h"
#include "gdbthread.h"
#include "solist.h"
#include "solib.h"
#ifdef USE_LDR_ROUTINES
# include <loader.h>
#endif
#ifndef USE_LDR_ROUTINES
/* Definition of runtime loader structures, found by experimentation. */
#define RLD_CONTEXT_ADDRESS 0x3ffc0000000
/* Per-module information structure referenced by ldr_context_t.head. */
typedef struct
{
CORE_ADDR next;
CORE_ADDR previous;
CORE_ADDR unknown1;
CORE_ADDR module_name;
CORE_ADDR modinfo_addr; /* Used by next_link_map_member() to detect
the end of the shared module list. */
long module_id;
CORE_ADDR unknown2;
CORE_ADDR unknown3;
long region_count;
CORE_ADDR regioninfo_addr;
}
ldr_module_info_t;
/* Per-region structure referenced by ldr_module_info_t.regioninfo_addr. */
typedef struct
{
long unknown1;
CORE_ADDR regionname_addr;
long protection;
CORE_ADDR vaddr;
CORE_ADDR mapaddr;
long size;
long unknown2[5];
}
ldr_region_info_t;
/* Structure at RLD_CONTEXT_ADDRESS specifying the start and finish addresses
of the shared module list. */
typedef struct
{
CORE_ADDR unknown1;
CORE_ADDR unknown2;
CORE_ADDR head;
CORE_ADDR tail;
}
ldr_context_t;
#endif /* !USE_LDR_ROUTINES */
/* Per-section information, stored in struct lm_info.secs. */
struct lm_sec
{
CORE_ADDR offset; /* difference between default and actual
virtual addresses of section .name */
CORE_ADDR nameaddr; /* address in inferior of section name */
const char *name; /* name of section, null if not fetched */
};
/* Per-module information, stored in struct so_list.lm_info. */
struct lm_info
{
int isloader; /* whether the module is /sbin/loader */
int nsecs; /* length of .secs */
struct lm_sec secs[1]; /* variable-length array of sections, sorted
by name */
};
/* Context for iterating through the inferior's shared module list. */
struct read_map_ctxt
{
#ifdef USE_LDR_ROUTINES
ldr_process_t proc;
ldr_module_t next;
#else
CORE_ADDR next; /* next element in module list */
CORE_ADDR tail; /* last element in module list */
#endif
};
/* Forward declaration for this module's autoinit function. */
extern void _initialize_osf_solib (void);
#ifdef USE_LDR_ROUTINES
# if 0
/* This routine is intended to be called by ldr_* routines to read memory from
the current target. Usage:
ldr_process = ldr_core_process ();
ldr_set_core_reader (ldr_read_memory);
ldr_xdetach (ldr_process);
ldr_xattach (ldr_process);
ldr_core_process() and ldr_read_memory() are neither documented nor
declared in system header files. They work with OSF/1 2.x, and they might
work with later versions as well. */
static int
ldr_read_memory (CORE_ADDR memaddr, char *myaddr, int len, int readstring)
{
int result;
char *buffer;
if (readstring)
{
target_read_string (memaddr, &buffer, len, &result);
if (result == 0)
strcpy (myaddr, buffer);
xfree (buffer);
}
else
result = target_read_memory (memaddr, myaddr, len);
if (result != 0)
result = -result;
return result;
}
# endif /* 0 */
#endif /* USE_LDR_ROUTINES */
/* Comparison for qsort() and bsearch(): return -1, 0, or 1 according to
whether lm_sec *P1's name is lexically less than, equal to, or greater
than that of *P2. */
static int
lm_sec_cmp (const void *p1, const void *p2)
{
const struct lm_sec *lms1 = p1, *lms2 = p2;
return strcmp (lms1->name, lms2->name);
}
/* Sort LMI->secs so that osf_relocate_section_addresses() can binary-search
it. */
static void
lm_secs_sort (struct lm_info *lmi)
{
qsort (lmi->secs, lmi->nsecs, sizeof *lmi->secs, lm_sec_cmp);
}
/* Populate name fields of LMI->secs. */
static void
fetch_sec_names (struct lm_info *lmi)
{
#ifndef USE_LDR_ROUTINES
int i, errcode;
struct lm_sec *lms;
char *name;
for (i = 0; i < lmi->nsecs; i++)
{
lms = lmi->secs + i;
target_read_string (lms->nameaddr, &name, PATH_MAX, &errcode);
if (errcode != 0)
{
warning (_("unable to read shared sec name at 0x%lx"),
lms->nameaddr);
name = xstrdup ("");
}
lms->name = name;
}
lm_secs_sort (lmi);
#endif
}
/* target_so_ops callback. Adjust SEC's addresses after it's been mapped into
the process. */
static void
osf_relocate_section_addresses (struct so_list *so,
struct target_section *sec)
{
struct lm_info *lmi;
struct lm_sec lms_key, *lms;
/* Fetch SO's section names if we haven't done so already. */
lmi = so->lm_info;
if (lmi->nsecs && !lmi->secs[0].name)
fetch_sec_names (lmi);
/* Binary-search for offset information corresponding to SEC. */
lms_key.name = sec->the_bfd_section->name;
lms = bsearch (&lms_key, lmi->secs, lmi->nsecs, sizeof *lms, lm_sec_cmp);
if (lms)
{
sec->addr += lms->offset;
sec->endaddr += lms->offset;
}
}
/* target_so_ops callback. Free parts of SO allocated by this file. */
static void
osf_free_so (struct so_list *so)
{
int i;
const char *name;
for (i = 0; i < so->lm_info->nsecs; i++)
{
name = so->lm_info->secs[i].name;
if (name)
xfree ((void *) name);
}
xfree (so->lm_info);
}
/* target_so_ops callback. Discard information accumulated by this file and
not freed by osf_free_so(). */
static void
osf_clear_solib (void)
{
return;
}
/* target_so_ops callback. Prepare to handle shared libraries after the
inferior process has been created but before it's executed any
instructions.
For a statically bound executable, the inferior's first instruction is the
one at "_start", or a similar text label. No further processing is needed
in that case.
For a dynamically bound executable, this first instruction is somewhere
in the rld, and the actual user executable is not yet mapped in.
We continue the inferior again, rld then maps in the actual user
executable and any needed shared libraries and then sends
itself a SIGTRAP.
At that point we discover the names of all shared libraries and
read their symbols in.
FIXME
This code does not properly handle hitting breakpoints which the
user might have set in the rld itself. Proper handling would have
to check if the SIGTRAP happened due to a kill call.
Also, what if child has exit()ed? Must exit loop somehow. */
static void
osf_solib_create_inferior_hook (int from_tty)
{
struct inferior *inf;
struct thread_info *tp;
inf = current_inferior ();
/* If we are attaching to the inferior, the shared libraries
have already been mapped, so nothing more to do. */
if (inf->attach_flag)
return;
/* Nothing to do for statically bound executables. */
if (symfile_objfile == NULL
|| symfile_objfile->obfd == NULL
|| ((bfd_get_file_flags (symfile_objfile->obfd) & DYNAMIC) == 0))
return;
/* Now run the target. It will eventually get a SIGTRAP, at
which point all of the libraries will have been mapped in and we
can go groveling around in the rld structures to find
out what we need to know about them.
If debugging from a core file, we cannot resume the execution
of the inferior. But this is actually not an issue, because
shared libraries have already been mapped anyways, which means
we have nothing more to do. */
if (!target_can_run (&current_target))
return;
tp = inferior_thread ();
clear_proceed_status (0);
inf->control.stop_soon = STOP_QUIETLY;
tp->suspend.stop_signal = GDB_SIGNAL_0;
do
{
target_resume (minus_one_ptid, 0, tp->suspend.stop_signal);
wait_for_inferior ();
}
while (tp->suspend.stop_signal != GDB_SIGNAL_TRAP);
/* solib_add will call reinit_frame_cache.
But we are stopped in the runtime loader and we do not have symbols
for the runtime loader. So heuristic_proc_start will be called
and will put out an annoying warning.
Delaying the resetting of stop_soon until after symbol loading
suppresses the warning. */
solib_add ((char *) 0, 0, (struct target_ops *) 0, auto_solib_add);
inf->control.stop_soon = NO_STOP_QUIETLY;
}
/* target_so_ops callback. Do additional symbol handling, lookup, etc. after
symbols for a shared object have been loaded. */
static void
osf_special_symbol_handling (void)
{
return;
}
/* Initialize CTXT in preparation for iterating through the inferior's module
list using read_map(). Return success. */
static int
open_map (struct read_map_ctxt *ctxt)
{
#ifdef USE_LDR_ROUTINES
/* Note: As originally written, ldr_my_process() was used to obtain
the value for ctxt->proc. This is incorrect, however, since
ldr_my_process() retrieves the "unique identifier" associated
with the current process (i.e. GDB) and not the one being
debugged. Presumably, the pid of the process being debugged is
compatible with the "unique identifier" used by the ldr_
routines, so we use that. */
ctxt->proc = ptid_get_pid (inferior_ptid);
if (ldr_xattach (ctxt->proc) != 0)
return 0;
ctxt->next = LDR_NULL_MODULE;
#else
CORE_ADDR ldr_context_addr, prev, next;
ldr_context_t ldr_context;
if (target_read_memory ((CORE_ADDR) RLD_CONTEXT_ADDRESS,
(char *) &ldr_context_addr,
sizeof (CORE_ADDR)) != 0)
return 0;
if (target_read_memory (ldr_context_addr,
(char *) &ldr_context,
sizeof (ldr_context_t)) != 0)
return 0;
ctxt->next = ldr_context.head;
ctxt->tail = ldr_context.tail;
#endif
return 1;
}
/* Initialize SO to have module NAME, /sbin/loader indicator ISLOADR, and
space for NSECS sections. */
static void
init_so (struct so_list *so, char *name, int isloader, int nsecs)
{
int namelen, i;
/* solib.c requires various fields to be initialized to 0. */
memset (so, 0, sizeof *so);
/* Copy the name. */
namelen = strlen (name);
if (namelen >= SO_NAME_MAX_PATH_SIZE)
namelen = SO_NAME_MAX_PATH_SIZE - 1;
memcpy (so->so_original_name, name, namelen);
so->so_original_name[namelen] = '\0';
memcpy (so->so_name, so->so_original_name, namelen + 1);
/* Allocate section space. */
so->lm_info = xmalloc (sizeof (struct lm_info)
+ (nsecs - 1) * sizeof (struct lm_sec));
so->lm_info->isloader = isloader;
so->lm_info->nsecs = nsecs;
for (i = 0; i < nsecs; i++)
so->lm_info->secs[i].name = NULL;
}
/* Initialize SO's section SECIDX with name address NAMEADDR, name string
NAME, default virtual address VADDR, and actual virtual address
MAPADDR. */
static void
init_sec (struct so_list *so, int secidx, CORE_ADDR nameaddr,
const char *name, CORE_ADDR vaddr, CORE_ADDR mapaddr)
{
struct lm_sec *lms;
lms = so->lm_info->secs + secidx;
lms->nameaddr = nameaddr;
lms->name = name;
lms->offset = mapaddr - vaddr;
}
/* If there are more elements starting at CTXT in inferior's module list,
store the next element in SO, advance CTXT to the next element, and return
1, else return 0. */
static int
read_map (struct read_map_ctxt *ctxt, struct so_list *so)
{
ldr_module_info_t minf;
ldr_region_info_t rinf;
#ifdef USE_LDR_ROUTINES
size_t size;
ldr_region_t i;
/* Retrieve the next element. */
if (ldr_next_module (ctxt->proc, &ctxt->next) != 0)
return 0;
if (ctxt->next == LDR_NULL_MODULE)
return 0;
if (ldr_inq_module (ctxt->proc, ctxt->next, &minf, sizeof minf, &size) != 0)
return 0;
/* Initialize the module name and section count. */
init_so (so, minf.lmi_name, 0, minf.lmi_nregion);
/* Retrieve section names and offsets. */
for (i = 0; i < minf.lmi_nregion; i++)
{
if (ldr_inq_region (ctxt->proc, ctxt->next, i, &rinf,
sizeof rinf, &size) != 0)
goto err;
init_sec (so, (int) i, 0, xstrdup (rinf.lri_name),
(CORE_ADDR) rinf.lri_vaddr, (CORE_ADDR) rinf.lri_mapaddr);
}
lm_secs_sort (so->lm_info);
#else
char *name;
int errcode, i;
/* Retrieve the next element. */
if (!ctxt->next)
return 0;
if (target_read_memory (ctxt->next, (char *) &minf, sizeof minf) != 0)
return 0;
if (ctxt->next == ctxt->tail)
ctxt->next = 0;
else
ctxt->next = minf.next;
/* Initialize the module name and section count. */
target_read_string (minf.module_name, &name, PATH_MAX, &errcode);
if (errcode != 0)
return 0;
init_so (so, name, !minf.modinfo_addr, minf.region_count);
xfree (name);
/* Retrieve section names and offsets. */
for (i = 0; i < minf.region_count; i++)
{
if (target_read_memory (minf.regioninfo_addr + i * sizeof rinf,
(char *) &rinf, sizeof rinf) != 0)
goto err;
init_sec (so, i, rinf.regionname_addr, NULL, rinf.vaddr, rinf.mapaddr);
}
#endif /* !USE_LDR_ROUTINES */
return 1;
err:
osf_free_so (so);
return 0;
}
/* Free resources allocated by open_map (CTXT). */
static void
close_map (struct read_map_ctxt *ctxt)
{
#ifdef USE_LDR_ROUTINES
ldr_xdetach (ctxt->proc);
#endif
}
/* target_so_ops callback. Return a list of shared objects currently loaded
in the inferior. */
static struct so_list *
osf_current_sos (void)
{
struct so_list *head = NULL, *tail = NULL, *newtail, so;
struct read_map_ctxt ctxt;
int skipped_main;
if (!open_map (&ctxt))
return NULL;
/* Read subsequent elements. */
for (skipped_main = 0;;)
{
if (!read_map (&ctxt, &so))
break;
/* Skip the main program module, which is first in the list after
/sbin/loader. */
if (!so.lm_info->isloader && !skipped_main)
{
osf_free_so (&so);
skipped_main = 1;
continue;
}
newtail = xmalloc (sizeof *newtail);
if (!head)
head = newtail;
else
tail->next = newtail;
tail = newtail;
memcpy (tail, &so, sizeof so);
tail->next = NULL;
}
close_map (&ctxt);
return head;
}
/* target_so_ops callback. Attempt to locate and open the main symbol
file. */
static int
osf_open_symbol_file_object (void *from_ttyp)
{
struct read_map_ctxt ctxt;
struct so_list so;
int found;
if (symfile_objfile)
if (!query (_("Attempt to reload symbols from process? ")))
return 0;
/* The first module after /sbin/loader is the main program. */
if (!open_map (&ctxt))
return 0;
for (found = 0; !found;)
{
if (!read_map (&ctxt, &so))
break;
found = !so.lm_info->isloader;
osf_free_so (&so);
}
close_map (&ctxt);
if (found)
symbol_file_add_main (so.so_name, *(int *) from_ttyp);
return found;
}
/* target_so_ops callback. Return whether PC is in the dynamic linker. */
static int
osf_in_dynsym_resolve_code (CORE_ADDR pc)
{
/* This function currently always return False. This is a temporary
solution which only consequence is to introduce a minor incovenience
for the user: When stepping inside a subprogram located in a shared
library, gdb might stop inside the dynamic loader code instead of
inside the subprogram itself. See the explanations in infrun.c about
the in_solib_dynsym_resolve_code() function for more details. */
return 0;
}
static struct target_so_ops osf_so_ops;
void
_initialize_osf_solib (void)
{
osf_so_ops.relocate_section_addresses = osf_relocate_section_addresses;
osf_so_ops.free_so = osf_free_so;
osf_so_ops.clear_solib = osf_clear_solib;
osf_so_ops.solib_create_inferior_hook = osf_solib_create_inferior_hook;
osf_so_ops.special_symbol_handling = osf_special_symbol_handling;
osf_so_ops.current_sos = osf_current_sos;
osf_so_ops.open_symbol_file_object = osf_open_symbol_file_object;
osf_so_ops.in_dynsym_resolve_code = osf_in_dynsym_resolve_code;
osf_so_ops.bfd_open = solib_bfd_open;
/* FIXME: Don't do this here. *_gdbarch_init() should set so_ops. */
current_target_so_ops = &osf_so_ops;
}

13
gdb/testsuite/ChangeLog
View File

@ -1,3 +1,16 @@
2014-10-17 Pedro Alves <palves@redhat.com>
* gdb.base/callfuncs.exp: emove references to osf.
* gdb.base/sigall.exp: Likewise.
* gdb.gdb/selftest.exp: Likewise.
* gdb.hp/gdb.base-hp/callfwmall.exp: Likewise.
* gdb.mi/non-stop.c: Likewise.
* gdb.mi/pthreads.c: Likewise.
* gdb.reverse/sigall-precsave.exp: Likewise.
* gdb.reverse/sigall-reverse.exp: Likewise.
* gdb.threads/pthreads.c: Likewise.
* gdb.threads/pthreads.exp: Likewise.
2014-10-17 Yao Qi <yao@codesourcery.com> 2014-10-17 Yao Qi <yao@codesourcery.com>
* gdb.base/commands.exp (gdbvar_complex_if_while_test): Don't * gdb.base/commands.exp (gdbvar_complex_if_while_test): Don't

2
gdb/testsuite/gdb.base/callfuncs.exp
View File

@ -122,7 +122,7 @@ proc do_function_calls {} {
if $prototypes then { if $prototypes then {
setup_xfail "sparc-*-*" "mips*-*-*" 5318 setup_xfail "sparc-*-*" "mips*-*-*" 5318
if { ! [test_compiler_info gcc-*-*] } then { if { ! [test_compiler_info gcc-*-*] } then {
setup_xfail "alpha-dec-osf2*" "i*86-*-sysv4*" 5318 setup_xfail "i*86-*-sysv4*" 5318
} }
} }

11
gdb/testsuite/gdb.base/sigall.exp
View File

@ -54,17 +54,6 @@ proc test_one_sig {nextsig} {
"Continuing.*Program received signal SIG$esig.*" \ "Continuing.*Program received signal SIG$esig.*" \
"get signal $esig" "get signal $esig"
} }
if [ istarget "alpha-dec-osf3*" ] then {
# OSF/1-3.x is unable to continue with a job control stop signal.
# The inferior remains stopped without an event of interest
# and GDB waits forever for the inferior to stop on an event
# of interest. Work around the kernel bug.
if { $thissig == "TSTP" || $thissig == "TTIN" || $thissig == "TTOU" } {
setup_xfail "alpha-dec-osf3*"
fail "cannot continue from signal $thissig"
set need_another_continue 0
}
}
if $need_another_continue then { if $need_another_continue then {
if { $thissig == "URG" } { if { $thissig == "URG" } {

9
gdb/testsuite/gdb.gdb/selftest.exp
View File

@ -459,15 +459,6 @@ proc test_with_self { executable } {
-re "#0.*(read|poll).*in main \\(.*\\) at .*gdb\\.c.*$gdb_prompt $" { -re "#0.*(read|poll).*in main \\(.*\\) at .*gdb\\.c.*$gdb_prompt $" {
pass "$description" pass "$description"
} }
-re ".*$gdb_prompt $" {
# On the alpha, we hit the infamous problem about gdb
# being unable to get the frame pointer (mentioned in
# gdb/README). As it is intermittent, there is no way to
# XFAIL it which will give us an XPASS if the problem goes
# away.
setup_xfail "alpha*-*-osf*"
fail "$description"
}
} }

2
gdb/testsuite/gdb.hp/gdb.base-hp/callfwmall.exp
View File

@ -208,7 +208,7 @@ proc do_function_calls {} {
if $prototypes then { if $prototypes then {
setup_xfail "sparc-*-*" "mips*-*-*" 5318 setup_xfail "sparc-*-*" "mips*-*-*" 5318
if {!$gcc_compiled} then { if {!$gcc_compiled} then {
setup_xfail "alpha-dec-osf2*" "i*86-*-sysv4*" 5318 setup_xfail "i*86-*-sysv4*" 5318
} }
} }
gdb_test "p t_float_values2(3.14159,float_val2)" " = 1" gdb_test "p t_float_values2(3.14159,float_val2)" " = 1"

4
gdb/testsuite/gdb.mi/non-stop.c
View File

@ -20,11 +20,11 @@
#include <stdlib.h> #include <stdlib.h>
#include <pthread.h> #include <pthread.h>
/* Under OSF 2.0 & 3.0 and HPUX 10, the second arg of pthread_create /* Under HPUX 10, the second arg of pthread_create
is prototyped to be just a "pthread_attr_t", while under Solaris it is prototyped to be just a "pthread_attr_t", while under Solaris it
is a "pthread_attr_t *". Arg! */ is a "pthread_attr_t *". Arg! */
#if defined (__osf__) || defined (__hpux__) #if defined (__hpux__)
#define PTHREAD_CREATE_ARG2(arg) arg #define PTHREAD_CREATE_ARG2(arg) arg
#define PTHREAD_CREATE_NULL_ARG2 null_attr #define PTHREAD_CREATE_NULL_ARG2 null_attr
static pthread_attr_t null_attr; static pthread_attr_t null_attr;

4
gdb/testsuite/gdb.mi/pthreads.c
View File

@ -24,11 +24,11 @@
#include <stdlib.h> #include <stdlib.h>
#include <pthread.h> #include <pthread.h>
/* Under OSF 2.0 & 3.0 and HPUX 10, the second arg of pthread_create /* Under HPUX 10, the second arg of pthread_create
is prototyped to be just a "pthread_attr_t", while under Solaris it is prototyped to be just a "pthread_attr_t", while under Solaris it
is a "pthread_attr_t *". Arg! */ is a "pthread_attr_t *". Arg! */
#if defined (__osf__) || defined (__hpux__) #if defined (__hpux__)
#define PTHREAD_CREATE_ARG2(arg) arg #define PTHREAD_CREATE_ARG2(arg) arg
#define PTHREAD_CREATE_NULL_ARG2 null_attr #define PTHREAD_CREATE_NULL_ARG2 null_attr
static pthread_attr_t null_attr; static pthread_attr_t null_attr;

11
gdb/testsuite/gdb.reverse/sigall-precsave.exp
View File

@ -65,17 +65,6 @@ proc test_one_sig {nextsig} {
} }
} }
} }
if [ istarget "alpha-dec-osf3*" ] then {
# OSF/1-3.x is unable to continue with a job control stop signal.
# The inferior remains stopped without an event of interest
# and GDB waits forever for the inferior to stop on an event
# of interest. Work around the kernel bug.
if { $thissig == "TSTP" || $thissig == "TTIN" || $thissig == "TTOU" } {
setup_xfail "alpha-dec-osf3*"
fail "cannot continue from signal $thissig"
set need_another_continue 0
}
}
if $need_another_continue then { if $need_another_continue then {
if { $thissig == "URG" } { if { $thissig == "URG" } {

11
gdb/testsuite/gdb.reverse/sigall-reverse.exp
View File

@ -64,17 +64,6 @@ proc test_one_sig {nextsig} {
} }
} }
} }
if [ istarget "alpha-dec-osf3*" ] then {
# OSF/1-3.x is unable to continue with a job control stop signal.
# The inferior remains stopped without an event of interest
# and GDB waits forever for the inferior to stop on an event
# of interest. Work around the kernel bug.
if { $thissig == "TSTP" || $thissig == "TTIN" || $thissig == "TTOU" } {
setup_xfail "alpha-dec-osf3*"
fail "cannot continue from signal $thissig"
set need_another_continue 0
}
}
if $need_another_continue then { if $need_another_continue then {
if { $thissig == "URG" } { if { $thissig == "URG" } {

6
gdb/testsuite/gdb.threads/pthreads.c
View File

@ -23,11 +23,11 @@
#include <stdlib.h> #include <stdlib.h>
#include <pthread.h> #include <pthread.h>
/* Under OSF 2.0 & 3.0 and HPUX 10, the second arg of pthread_create /* Under HPUX 10, the second arg of pthread_create
is prototyped to be just a "pthread_attr_t", while under Solaris it is prototyped to be just a "pthread_attr_t", while under Solaris it
is a "pthread_attr_t *". Arg! */ is a "pthread_attr_t *". Arg! */
#if defined (__osf__) || defined (__hpux__) #if defined (__hpux__)
#define PTHREAD_CREATE_ARG2(arg) arg #define PTHREAD_CREATE_ARG2(arg) arg
#define PTHREAD_CREATE_NULL_ARG2 null_attr #define PTHREAD_CREATE_NULL_ARG2 null_attr
static pthread_attr_t null_attr; static pthread_attr_t null_attr;
@ -124,13 +124,11 @@ main(argc, argv)
foo (1, 2, 3); foo (1, 2, 3);
#ifndef __osf__
if (pthread_attr_init (&attr)) if (pthread_attr_init (&attr))
{ {
perror ("pthread_attr_init 1"); perror ("pthread_attr_init 1");
exit (1); exit (1);
} }
#endif
#ifdef PTHREAD_SCOPE_SYSTEM #ifdef PTHREAD_SCOPE_SYSTEM
if (pthread_attr_setscope (&attr, PTHREAD_SCOPE_SYSTEM)) if (pthread_attr_setscope (&attr, PTHREAD_SCOPE_SYSTEM))

3
gdb/testsuite/gdb.threads/pthreads.exp
View File

@ -266,9 +266,7 @@ proc check_backtraces {} {
} }
} }
setup_xfail "alpha-*-osf*"
if [runto_main] then { if [runto_main] then {
clear_xfail "alpha-*-osf*"
if [test_startup] then { if [test_startup] then {
if [check_control_c] then { if [check_control_c] then {
warning "Could not stop child with ^C; skipping rest of tests.\n" warning "Could not stop child with ^C; skipping rest of tests.\n"
@ -277,4 +275,3 @@ if [runto_main] then {
check_backtraces check_backtraces
} }
} }
clear_xfail "alpha-*-osf*"