mirror/freebsd-ports
1
0
Fork 0
mirror of https://git.FreeBSD.org/ports.git synced 2024-10-22 20:41:26 +00:00
Code Issues Releases Activity

Add fpc-gdb, a GNU GDB 5.2.1 modified for use with Free Pascal and to provide

Browse Source 
static libraries for linking with fpc-ide.

PR:		62570
Submitted by:	John Merryweather Cooper <coop9211@uidaho.edu>
This commit is contained in:
Joe Marcus Clarke 2004-02-22 01:52:20 +00:00
parent 805608ac9a
commit 95c01a7ffa
Notes: svn2git 2021-03-31 03:12:20 +00:00 
svn path=/head/; revision=101648
16 changed files with 2253 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
devel/Makefile
View File

@ -226,6 +226,7 @@
SUBDIR += fnccheck
SUBDIR += fnorb
SUBDIR += fortran-utils
SUBDIR += fpc-gdb
SUBDIR += fpc-gdbint
SUBDIR += fpc-regexpr
SUBDIR += fpp

66
devel/fpc-gdb/Makefile Normal file
View File

@ -0,0 +1,66 @@
# ex:ts=8
# Ports collection makefile for: FPC-GDB 5.2.1
# Date created: 8 February 2004
# Whom: John Merryweather Cooper <coop9211@uidaho.edu>
#
# $FreeBSD$
#
PORTNAME= gdb
PORTVERSION= 5.2.1
CATEGORIES= devel lang
MASTER_SITES= ${MASTER_SITE_SOURCEWARE}
MASTER_SITE_SUBDIR= gdb/releases
PKGNAMEPREFIX= fpc-
PATCH_SITES= ftp://ftp.freepascal.org/fpc/contrib/libgdb/v5.2.1 \
http://planetmirror.com/pub/fpc/contrib/libgdb/v5.2.1/ \
ftp://ftp.jp.freepascal.org/mirror/fpc/contrib/libgdb/v5.2.1/ \
ftp://freepascal.stack.nl/pub/fpc/contrib/libgdb/v5.2.1/ \
ftp://ftp.no.freepascal.org/pub/fpc/contrib/libgdb/v5.2.1/ \
ftp://ftp.us.freepascal.org/pub/fpc/contrib/libgdb/v5.2.1/ \
${MASTER_SITE_LOCAL}
PATCH_SITE_SUBDIR= obrien
PATCHFILES= gdb521.dif gdb521_xfree-loadmod.diff
MAINTAINER= coop9211@uidaho.edu
COMMENT= GNU GDB 5.2.1 modified for Free Pascal
.include <bsd.port.pre.mk>
NO_LATEST_LINK= yes
USE_GMAKE= yes
GNU_CONFIGURE= yes
USE_REINPLACE= yes
CONFIGURE_ARGS= --program-suffix=fpc
AR?= /usr/bin/ar
pre-configure:
cd ${WRKSRC} ; ${RM} -rf dejagnu expect sim tcl texinfo
post-configure:
# if devel/bison is installed, build will fail --> force yacc
@${FIND} ${WRKSRC} -name "Makefile*" | ${XARGS} \
${REINPLACE_CMD} 's|bison -y|yacc|g'
do-install:
@${INSTALL_PROGRAM} ${WRKSRC}/gdb/gdb \
${PREFIX}/bin/gdbfpc
cd ${WRKSRC}/gdb && ${AR} -rs libgdb.a cli*.o mi*.o
cd ${WRKSRC}/bfd && ${AR} -rs libbfd.a *.o
cd ${WRKSRC}/opcodes && ${AR} -rs libopcodes.a *.o
@${MKDIR} ${PREFIX}/lib/fpc/1.0.10/units/freebsd/gdbint/libgdb
@${INSTALL_DATA} \
${WRKSRC}/gdb/libgdb.a \
${WRKSRC}/bfd/libbfd.a \
${WRKSRC}/opcodes/libopcodes.a \
${WRKSRC}/libiberty/libiberty.a \
${WRKSRC}/intl/libintl.a \
${PREFIX}/lib/fpc/1.0.10/units/freebsd/gdbint/libgdb
cklatest:
ncftpls \
ftp://mirrors.rcn.net/mirrors/sources.redhat.com/${MASTER_SITE_SUBDIR}/ \
| ${GREP} gdb+dejagnu-
.include <bsd.port.post.mk>

6
devel/fpc-gdb/distinfo Normal file
View File

@ -0,0 +1,6 @@
MD5 (gdb-5.2.1.tar.gz) = e9766842f1bbc6c2353de1410d8c0de0
SIZE (gdb-5.2.1.tar.gz) = 14715792
MD5 (gdb521.dif) = a83edfef16ee5b78c97517588459bbe2
SIZE (gdb521.dif) = 19633
MD5 (gdb521_xfree-loadmod.diff) = 0cafd6520d86caa207a2f7a54f981d06
SIZE (gdb521_xfree-loadmod.diff) = 29594

9
devel/fpc-gdb/files/patch-gdb_config_alpha_fbsd.mh Normal file
View File

@ -0,0 +1,9 @@
--- gdb/config/alpha/fbsd.mh Sat Jan 19 17:12:50 2002
+++ gdb/config/alpha/fbsd.mh Mon Jun 3 08:03:39 2002
@@ -1,5 +1,5 @@
# Host: FreeBSD/Alpha
NATDEPFILES= fork-child.o infptrace.o inftarg.o \
solib.o solib-svr4.o solib-legacy.o \
- corelow.o core-regset.o alphabsd-nat.o
+ corelow.o core-regset.o alphabsd-nat.o freebsd-uthread.o
NAT_FILE= nm-fbsd.h

8
devel/fpc-gdb/files/patch-gdb_config_i386_fbsd.mh Normal file
View File

@ -0,0 +1,8 @@
--- gdb/config/i386/fbsd.mh Thu Jan 17 20:50:59 2002
+++ gdb/config/i386/fbsd.mh Mon May 27 18:36:20 2002
@@ -4,4 +4,4 @@
NAT_FILE= nm-fbsd.h
# NOTE: Do not spread NATDEPFILES over several lines - it hurts BSD make.
-NATDEPFILES= fork-child.o infptrace.o inftarg.o solib.o solib-svr4.o solib-legacy.o corelow.o core-aout.o core-regset.o i386-nat.o i387-nat.o i386bsd-nat.o i386fbsd-nat.o
+NATDEPFILES= fork-child.o infptrace.o inftarg.o solib.o solib-svr4.o solib-legacy.o corelow.o core-aout.o core-regset.o i386-nat.o i387-nat.o i386bsd-nat.o i386fbsd-nat.o kvm-fbsd.o freebsd-uthread.o xfreemod.o

35
devel/fpc-gdb/files/patch-gdb_config_i386_nm-fbsd.h Normal file
View File

@ -0,0 +1,35 @@
--- gdb/config/i386/nm-fbsd.h Sat Jul 21 13:16:44 2001
+++ gdb/config/i386/nm-fbsd.h Mon Jun 3 10:04:54 2002
@@ -148,5 +152,32 @@
#define ld_2 d_sdt
#endif /* !SVR4_SHARED_LIBS */
+
+extern int kernel_debugging;
+extern int kernel_writablecore;
+
+#if __FreeBSD_version >= 500032
+#define ADDITIONAL_OPTIONS \
+ {"kernel", no_argument, &kernel_debugging, 1}, \
+ {"k", no_argument, &kernel_debugging, 1}, \
+ {"wcore", no_argument, &kernel_writablecore, 1}, \
+ {"w", no_argument, &kernel_writablecore, 1},
+
+#define ADDITIONAL_OPTION_HELP \
+ "\
+ --kernel Enable kernel debugging.\n\
+ --wcore Make core file writable (only works for /dev/mem).\n\
+ This option only works while debugging a kernel !!\n\
+"
+
+#define DEFAULT_PROMPT kernel_debugging?"(kgdb) ":"(gdb) "
+
+/* misuse START_PROGRESS to test whether we're running as kgdb */
+/* START_PROGRESS is called at the top of main */
+#undef START_PROGRESS
+#define START_PROGRESS(STR,N) \
+ if (!strcmp(STR, "kgdb")) \
+ kernel_debugging = 1;
+#endif
#endif /* NM_FBSD_H */

67
devel/fpc-gdb/files/patch-gdb_config_i386_tm-fbsd.h Normal file
View File

@ -0,0 +1,67 @@
--- gdb/config/i386/tm-fbsd.h Sat Jul 28 10:03:38 2001
+++ gdb/config/i386/tm-fbsd.h Fri Jun 7 08:32:14 2002
@@ -41,38 +45,42 @@
/* Support for longjmp. */
/* Details about jmp_buf. It's supposed to be an array of integers. */
-
-#define JB_ELEMENT_SIZE 4 /* Size of elements in jmp_buf. */
-#define JB_PC 0 /* Array index of saved PC. */
-
-/* Figure out where the longjmp will land. Store the address that
- longjmp will jump to in *ADDR, and return non-zero if successful. */
-
#define GET_LONGJMP_TARGET(addr) get_longjmp_target (addr)
-extern int get_longjmp_target (CORE_ADDR *addr);
-/* Support for signal handlers. */
+/* On FreeBSD, sigtramp has size 0x18 and is immediately below the
+ ps_strings struct which has size 0x10 and is at the top of the
+ user stack. */
+
+#undef SIGTRAMP_START
+#undef SIGTRAMP_END
+#define SIGTRAMP_START(pc) 0xbfbfdfd8
+#define SIGTRAMP_END(pc) 0xbfbfdff0
-#define IN_SIGTRAMP(pc, name) i386bsd_in_sigtramp (pc, name)
-extern int i386bsd_in_sigtramp (CORE_ADDR pc, char *name);
-
-/* These defines allow the recognition of sigtramps as a function name
- <sigtramp>.
-
- FIXME: kettenis/2001-07-13: These should be added to the target
- vector and turned into functions when we go "multi-arch". */
-
-#define SIGTRAMP_START(pc) i386bsd_sigtramp_start
-#define SIGTRAMP_END(pc) i386bsd_sigtramp_end
extern CORE_ADDR i386bsd_sigtramp_start;
extern CORE_ADDR i386bsd_sigtramp_end;
+extern CORE_ADDR fbsd_kern_frame_saved_pc(struct frame_info *fr);
/* Override FRAME_SAVED_PC to enable the recognition of signal handlers. */
#undef FRAME_SAVED_PC
-#define FRAME_SAVED_PC(frame) i386bsd_frame_saved_pc (frame)
-extern CORE_ADDR i386bsd_frame_saved_pc (struct frame_info *frame);
+#if __FreeBSD_version >= 500032
+#define FRAME_SAVED_PC(FRAME) \
+ (kernel_debugging ? fbsd_kern_frame_saved_pc(FRAME) : \
+ (((FRAME)->signal_handler_caller \
+ ? sigtramp_saved_pc (FRAME) \
+ : read_memory_integer ((FRAME)->frame + 4, 4)) \
+ ))
+#else
+#define FRAME_SAVED_PC(FRAME) \
+ (((FRAME)->signal_handler_caller \
+ ? sigtramp_saved_pc (FRAME) \
+ : read_memory_integer ((FRAME)->frame + 4, 4)) \
+ )
+#endif
+
+/* Offset to saved PC in sigcontext, from <sys/signal.h>. */
+#define SIGCONTEXT_PC_OFFSET 20
/* Shared library support. */

921
devel/fpc-gdb/files/patch-gdb_freebsd-uthread.c Normal file
View File

@ -0,0 +1,921 @@
$FreeBSD: /tmp/pcvs/ports/devel/fpc-gdb/files/Attic/patch-gdb_freebsd-uthread.c,v 1.1 2004-02-22 01:52:20 marcus Exp $
--- gdb/freebsd-uthread.c.orig Sat May 25 13:05:56 2002
+++ gdb/freebsd-uthread.c Sat May 25 13:09:09 2002
@@ -0,0 +1,915 @@
+/* $FreeBSD: /tmp/pcvs/ports/devel/fpc-gdb/files/Attic/patch-gdb_freebsd-uthread.c,v 1.1 2004-02-22 01:52:20 marcus Exp $ */
+/* Low level interface for debugging FreeBSD user threads for GDB, the GNU debugger.
+ Copyright 1996, 1999 Free Software Foundation, Inc.
+
+This file is part of GDB.
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
+
+/* This module implements a sort of half target that sits between the
+ machine-independent parts of GDB and the ptrace interface (infptrace.c) to
+ provide access to the FreeBSD user-mode thread implementation.
+
+ FreeBSD threads are true user-mode threads, which are invoked via
+ the pthread_* interfaces. These are mostly implemented in
+ user-space, with all thread context kept in various structures that
+ live in the user's heap. For the most part, the kernel has no
+ knowlege of these threads.
+
+ Based largely on hpux-thread.c
+
+ */
+
+
+#include "defs.h"
+#include <sys/queue.h>
+#include <signal.h>
+#include <setjmp.h>
+#include "gdbthread.h"
+#include "target.h"
+#include "inferior.h"
+#include <fcntl.h>
+#include <ucontext.h>
+#include <unistd.h>
+#include <sys/stat.h>
+#include "gdbcore.h"
+
+extern int child_suppress_run;
+extern struct target_ops child_ops; /* target vector for inftarg.c */
+
+extern void _initialize_freebsd_uthread PARAMS ((void));
+
+/* Set to true while we are part-way through attaching */
+static int freebsd_uthread_attaching;
+
+static int freebsd_uthread_active = 0;
+static CORE_ADDR P_thread_list;
+static CORE_ADDR P_thread_run;
+
+/* Pointer to the next function on the objfile event chain. */
+static void (*target_new_objfile_chain) (struct objfile *objfile);
+
+static void freebsd_uthread_resume PARAMS ((ptid_t pid, int step,
+ enum target_signal signo));
+
+static void init_freebsd_uthread_ops PARAMS ((void));
+
+static struct target_ops freebsd_uthread_ops;
+
+static ptid_t find_active_ptid PARAMS ((void));
+
+struct cached_pthread {
+ u_int64_t uniqueid;
+ int state;
+ CORE_ADDR name;
+ union {
+ ucontext_t uc;
+ jmp_buf jb;
+ } ctx;
+};
+
+static ptid_t cached_ptid;
+static struct cached_pthread cached_pthread;
+static CORE_ADDR cached_pthread_addr;
+
+LIST_HEAD(idmaplist, idmap);
+
+struct idmap {
+ LIST_ENTRY(idmap) link;
+ u_int64_t uniqueid;
+ int tid;
+};
+
+#define MAPHASH_SIZE 257
+#define TID_MIN 1
+#define TID_MAX 16383
+
+static int tid_to_hash[TID_MAX + 1]; /* set to map_hash index */
+static struct idmaplist map_hash[MAPHASH_SIZE];
+static int next_free_tid = TID_MIN; /* first available tid */
+static int last_free_tid = TID_MIN; /* first unavailable */
+
+static CORE_ADDR P_thread_next_offset;
+static CORE_ADDR P_thread_uniqueid_offset;
+static CORE_ADDR P_thread_state_offset;
+static CORE_ADDR P_thread_name_offset;
+static CORE_ADDR P_thread_ctx_offset;
+static CORE_ADDR P_thread_PS_RUNNING_value;
+static CORE_ADDR P_thread_PS_DEAD_value;
+
+static int next_offset;
+static int uniqueid_offset;
+static int state_offset;
+static int name_offset;
+static int ctx_offset;
+static int PS_RUNNING_value;
+static int PS_DEAD_value;
+
+#define UNIQUEID_HASH(id) (id % MAPHASH_SIZE)
+#define TID_ADD1(tid) (((tid) + 1) == TID_MAX + 1 \
+ ? TID_MIN : (tid) + 1)
+#define IS_TID_FREE(tid) (tid_to_hash[tid] == -1)
+
+static int
+get_new_tid(int h)
+{
+ int tid = next_free_tid;
+
+ tid_to_hash[tid] = h;
+ next_free_tid = TID_ADD1(next_free_tid);
+ if (next_free_tid == last_free_tid)
+ {
+ int i;
+
+ for (i = last_free_tid; TID_ADD1(i) != last_free_tid; i = TID_ADD1(i))
+ if (IS_TID_FREE(i))
+ break;
+ if (TID_ADD1(i) == last_free_tid)
+ {
+ error("too many threads");
+ return 0;
+ }
+ next_free_tid = i;
+ for (i = TID_ADD1(i); IS_TID_FREE(i); i = TID_ADD1(i))
+ ;
+ last_free_tid = i;
+ }
+
+ return tid;
+}
+
+static ptid_t
+find_ptid(u_int64_t uniqueid)
+{
+ int h = UNIQUEID_HASH(uniqueid);
+ struct idmap *im;
+
+ LIST_FOREACH(im, &map_hash[h], link)
+ if (im->uniqueid == uniqueid)
+ return MERGEPID(PIDGET(inferior_ptid), im->tid);
+
+ im = xmalloc(sizeof(struct idmap));
+ im->uniqueid = uniqueid;
+ im->tid = get_new_tid(h);
+ LIST_INSERT_HEAD(&map_hash[h], im, link);
+
+ return MERGEPID(PIDGET(inferior_ptid), im->tid);
+}
+
+static void
+free_ptid(ptid_t ptid)
+{
+ int tid = TIDGET(ptid);
+ int h = tid_to_hash[tid];
+ struct idmap *im;
+
+ if (!tid) return;
+
+ LIST_FOREACH(im, &map_hash[h], link)
+ if (im->tid == tid)
+ break;
+
+ if (!im) return;
+
+ LIST_REMOVE(im, link);
+ tid_to_hash[tid] = -1;
+ free(im);
+}
+
+#define READ_OFFSET(field) read_memory(P_thread_##field##_offset, \
+ (char *) &field##_offset, \
+ sizeof(field##_offset))
+
+#define READ_VALUE(name) read_memory(P_thread_##name##_value, \
+ (char *) &name##_value, \
+ sizeof(name##_value))
+
+static void
+read_thread_offsets (void)
+{
+ READ_OFFSET(next);
+ READ_OFFSET(uniqueid);
+ READ_OFFSET(state);
+ READ_OFFSET(name);
+ READ_OFFSET(ctx);
+
+ READ_VALUE(PS_RUNNING);
+ READ_VALUE(PS_DEAD);
+}
+
+#define READ_FIELD(ptr, T, field, result) \
+ read_memory ((ptr) + field##_offset, (char *) &(result), sizeof result)
+
+static u_int64_t
+read_pthread_uniqueid (CORE_ADDR ptr)
+{
+ u_int64_t uniqueid;
+ READ_FIELD(ptr, u_int64_t, uniqueid, uniqueid);
+ return uniqueid;
+}
+
+static CORE_ADDR
+read_pthread_next (CORE_ADDR ptr)
+{
+ CORE_ADDR next;
+ READ_FIELD(ptr, CORE_ADDR, next, next);
+ return next;
+}
+
+static void
+read_cached_pthread (CORE_ADDR ptr, struct cached_pthread *cache)
+{
+ READ_FIELD(ptr, u_int64_t, uniqueid, cache->uniqueid);
+ READ_FIELD(ptr, int, state, cache->state);
+ READ_FIELD(ptr, CORE_ADDR, name, cache->name);
+ READ_FIELD(ptr, ucontext_t, ctx, cache->ctx);
+}
+
+static ptid_t
+find_active_ptid (void)
+{
+ CORE_ADDR ptr;
+
+ read_memory ((CORE_ADDR)P_thread_run,
+ (char *)&ptr,
+ sizeof ptr);
+
+ return find_ptid(read_pthread_uniqueid(ptr));
+}
+
+static CORE_ADDR find_pthread_addr PARAMS ((ptid_t ptid));
+static struct cached_pthread * find_pthread PARAMS ((ptid_t ptid));
+
+static CORE_ADDR
+find_pthread_addr (ptid_t ptid)
+{
+ CORE_ADDR ptr;
+
+ if (ptid_equal(ptid, cached_ptid))
+ return cached_pthread_addr;
+
+ read_memory ((CORE_ADDR)P_thread_list,
+ (char *)&ptr,
+ sizeof ptr);
+
+ while (ptr != 0)
+ {
+ if (ptid_equal(find_ptid(read_pthread_uniqueid(ptr)), ptid))
+ {
+ cached_ptid = ptid;
+ cached_pthread_addr = ptr;
+ read_cached_pthread(ptr, &cached_pthread);
+ return ptr;
+ }
+ ptr = read_pthread_next(ptr);
+ }
+
+ return NULL;
+}
+
+static struct cached_pthread *
+find_pthread (ptid_t ptid)
+{
+ CORE_ADDR ptr;
+
+ if (ptid_equal(ptid, cached_ptid))
+ return &cached_pthread;
+
+ read_memory ((CORE_ADDR)P_thread_list,
+ (char *)&ptr,
+ sizeof ptr);
+
+ while (ptr != 0)
+ {
+ if (ptid_equal(find_ptid(read_pthread_uniqueid(ptr)), ptid))
+ {
+ cached_ptid = ptid;
+ cached_pthread_addr = ptr;
+ read_cached_pthread(ptr, &cached_pthread);
+ return &cached_pthread;
+ }
+ ptr = read_pthread_next(ptr);
+ }
+
+#if 0
+ error ("Can't find pthread %d,%d", PIDGET(ptid), TIDGET(ptid));
+#endif
+ return NULL;
+}
+
+
+/* Most target vector functions from here on actually just pass through to
+ inftarg.c, as they don't need to do anything specific for threads. */
+
+/* ARGSUSED */
+static void
+freebsd_uthread_open (char *arg, int from_tty)
+{
+ child_ops.to_open (arg, from_tty);
+}
+
+/* Attach to process PID, then initialize for debugging it
+ and wait for the trace-trap that results from attaching. */
+
+static void
+freebsd_uthread_attach (char *args, int from_tty)
+{
+ child_ops.to_attach (args, from_tty);
+ push_target (&freebsd_uthread_ops);
+ freebsd_uthread_attaching = 1;
+}
+
+/* After an attach, see if the target is threaded */
+
+static void
+freebsd_uthread_post_attach (int pid)
+{
+ if (freebsd_uthread_active)
+ {
+ read_thread_offsets ();
+ inferior_ptid = find_active_ptid ();
+ add_thread (inferior_ptid);
+ }
+ else
+ {
+ unpush_target (&freebsd_uthread_ops);
+ push_target (&child_ops);
+ }
+
+ freebsd_uthread_attaching = 0;
+}
+
+/* Take a program previously attached to and detaches it.
+ The program resumes execution and will no longer stop
+ on signals, etc. We'd better not have left any breakpoints
+ in the program or it'll die when it hits one. For this
+ to work, it may be necessary for the process to have been
+ previously attached. It *might* work if the program was
+ started via the normal ptrace (PTRACE_TRACEME). */
+
+static void
+freebsd_uthread_detach (char *args, int from_tty)
+{
+ child_ops.to_detach (args, from_tty);
+}
+
+/* Resume execution of process PID. If STEP is nozero, then
+ just single step it. If SIGNAL is nonzero, restart it with that
+ signal activated. We may have to convert pid from a thread-id to an LWP id
+ for procfs. */
+
+static void
+freebsd_uthread_resume (ptid_t ptid, int step, enum target_signal signo)
+{
+ if (freebsd_uthread_attaching)
+ {
+ child_ops.to_resume (ptid, step, signo);
+ return;
+ }
+
+ child_ops.to_resume (ptid, step, signo);
+ cached_ptid = MERGEPID(0, 0);
+}
+
+/* Wait for any threads to stop. We may have to convert PID from a thread id
+ to a LWP id, and vice versa on the way out. */
+
+static ptid_t
+freebsd_uthread_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
+{
+ ptid_t rtnval;
+
+ if (freebsd_uthread_attaching)
+ {
+ return child_ops.to_wait (ptid, ourstatus);
+ }
+
+ rtnval = child_ops.to_wait (ptid, ourstatus);
+
+ if (PIDGET(rtnval) >= 0)
+ {
+ rtnval = find_active_ptid ();
+ if (!in_thread_list (rtnval))
+ add_thread (rtnval);
+ }
+
+ return rtnval;
+}
+
+#ifdef __i386__
+
+static char sigmap[MAX_NUM_REGS] = /* map reg to sigcontext */
+{
+ 12, /* eax */
+ 11, /* ecx */
+ 10, /* edx */
+ 9, /* ebx */
+ 8, /* esp */
+ 7, /* ebp */
+ 6, /* esi */
+ 5, /* edi */
+ 15, /* eip */
+ 17, /* eflags */
+ 16, /* cs */
+ 19, /* ss */
+ 4, /* ds */
+ 3, /* es */
+ 2, /* fs */
+ 1, /* gs */
+ -1, -1, -1, -1, -1, -1, -1, /* st0-st7 */
+ -1, -1, -1, -1, -1, -1, -1, /* fctrl-fop */
+ -1, -1, -1, -1, -1, -1, -1, /* xmm0-xmm7 */
+ -1, /* mxcsr */
+};
+
+static char jmpmap[MAX_NUM_REGS] = /* map reg to jmp_buf */
+{
+ 6, /* eax */
+ -1, /* ecx */
+ -1, /* edx */
+ 1, /* ebx */
+ 2, /* esp */
+ 3, /* ebp */
+ 4, /* esi */
+ 5, /* edi */
+ 0, /* eip */
+ -1, /* eflags */
+ -1, /* cs */
+ -1, /* ss */
+ -1, /* ds */
+ -1, /* es */
+ -1, /* fs */
+ -1, /* gs */
+ -1, -1, -1, -1, -1, -1, -1, /* st0-st7 */
+ -1, -1, -1, -1, -1, -1, -1, /* fctrl-fop */
+ -1, -1, -1, -1, -1, -1, -1, /* xmm0-xmm7 */
+ -1, /* mxcsr */
+};
+
+#endif
+
+#ifdef __alpha__
+
+static char sigmap[NUM_REGS] = /* map reg to sigcontext */
+{
+ 1, 2, 3, 4, 5, 6, 7, 8, /* v0 - t6 */
+ 9, 10, 11, 12, 13, 14, 15, 16, /* t7 - fp */
+ 17, 18, 19, 20, 21, 22, 23, 24, /* a0 - t9 */
+ 25, 26, 27, 28, 29, 30, 31, 32, /* t10 - zero */
+ 38, 39, 40, 41, 42, 43, 44, 45, /* f0 - f7 */
+ 46, 47, 48, 49, 50, 51, 52, 53, /* f8 - f15 */
+ 54, 55, 56, 57, 58, 59, 60, 61, /* f16 - f23 */
+ 62, 63, 64, 65, 66, 67, 68, 69, /* f24 - f31 */
+ 33, -1 /* pc, vfp */
+};
+static char jmpmap[NUM_REGS] = {
+ 4, 5, 6, 7, 8, 9, 10, 11, /* v0 - t6 */
+ 12, 13, 14, 15, 16, 17, 18, 19, /* t7 - fp */
+ 20, 21, 22, 23, 24, 25, 26, 27, /* a0 - t9 */
+ 28, 29, 30, 31, 32, 33, 34, 35, /* t10 - zero */
+ 37, 38, 39, 40, 41, 42, 43, 44, /* f0 - f7 */
+ 45, 46, 47, 48, 49, 50, 51, 52, /* f8 - f15 */
+ 53, 54, 55, 56, 57, 58, 59, 60, /* f16 - f23 */
+ 61, 62, 63, 64, 65, 66, 67, 68, /* f24 - f31 */
+ 2, -1, /* pc, vfp */
+};
+
+#endif
+
+static void
+freebsd_uthread_fetch_registers (int regno)
+{
+ struct cached_pthread *thread;
+ int active;
+ int first_regno, last_regno;
+ register_t *regbase;
+ char *regmap;
+
+ if (freebsd_uthread_attaching || TIDGET(inferior_ptid) == 0)
+ {
+ child_ops.to_fetch_registers (regno);
+ return;
+ }
+
+ thread = find_pthread (inferior_ptid);
+ active = (ptid_equal(inferior_ptid, find_active_ptid()));
+
+ if (active)
+ {
+ child_ops.to_fetch_registers (regno);
+ return;
+ }
+
+ if (regno == -1)
+ {
+ first_regno = 0;
+ last_regno = NUM_REGS - 1;
+ }
+ else
+ {
+ first_regno = regno;
+ last_regno = regno;
+ }
+
+ regbase = (register_t*) &thread->ctx.jb[0];
+ regmap = jmpmap;
+
+ for (regno = first_regno; regno <= last_regno; regno++)
+ {
+ if (regmap[regno] == -1)
+ child_ops.to_fetch_registers (regno);
+ else
+ if (thread)
+ supply_register (regno, (char*) &regbase[regmap[regno]]);
+ else
+ supply_register (regno, NULL);
+ }
+}
+
+static void
+freebsd_uthread_store_registers (int regno)
+{
+ struct cached_pthread *thread;
+ CORE_ADDR ptr;
+ int first_regno, last_regno;
+ u_int32_t *regbase;
+ char *regmap;
+
+ if (freebsd_uthread_attaching)
+ {
+ child_ops.to_store_registers (regno);
+ return;
+ }
+
+ thread = find_pthread (inferior_ptid);
+
+ if (thread->state == PS_RUNNING_value)
+ {
+ child_ops.to_store_registers (regno);
+ return;
+ }
+
+ if (regno == -1)
+ {
+ first_regno = 0;
+ last_regno = NUM_REGS - 1;
+ }
+ else
+ {
+ first_regno = regno;
+ last_regno = regno;
+ }
+
+ regbase = (u_int32_t*) &thread->ctx.jb[0];
+ regmap = jmpmap;
+
+ ptr = find_pthread_addr (inferior_ptid);
+ for (regno = first_regno; regno <= last_regno; regno++)
+ {
+ if (regmap[regno] == -1)
+ child_ops.to_store_registers (regno);
+ else
+ {
+ u_int32_t *reg = &regbase[regmap[regno]];
+ int off;
+
+ /* Hang onto cached value */
+ memcpy(reg, registers + REGISTER_BYTE (regno),
+ REGISTER_RAW_SIZE (regno));
+
+ /* And push out to inferior */
+ off = (char *) reg - (char *) thread;
+ write_memory (ptr + off,
+ registers + REGISTER_BYTE (regno),
+ REGISTER_RAW_SIZE (regno));
+ }
+ }
+}
+
+/* Get ready to modify the registers array. On machines which store
+ individual registers, this doesn't need to do anything. On machines
+ which store all the registers in one fell swoop, this makes sure
+ that registers contains all the registers from the program being
+ debugged. */
+
+static void
+freebsd_uthread_prepare_to_store (void)
+{
+ child_ops.to_prepare_to_store ();
+}
+
+static int
+freebsd_uthread_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len,
+ int dowrite, struct mem_attrib *attrib,
+ struct target_ops *target)
+{
+ return child_ops.to_xfer_memory (memaddr, myaddr, len, dowrite,
+ attrib, target);
+}
+
+/* Print status information about what we're accessing. */
+
+static void
+freebsd_uthread_files_info (struct target_ops *ignore)
+{
+ child_ops.to_files_info (ignore);
+}
+
+static void
+freebsd_uthread_kill_inferior (void)
+{
+ child_ops.to_kill ();
+}
+
+static void
+freebsd_uthread_notice_signals (ptid_t ptid)
+{
+ child_ops.to_notice_signals (ptid);
+}
+
+/* Fork an inferior process, and start debugging it with /proc. */
+
+static void
+freebsd_uthread_create_inferior (char *exec_file, char *allargs, char **env)
+{
+ child_ops.to_create_inferior (exec_file, allargs, env);
+
+ if (PIDGET(inferior_ptid) && freebsd_uthread_active)
+ {
+ read_thread_offsets ();
+ push_target (&freebsd_uthread_ops);
+ inferior_ptid = find_active_ptid ();
+ add_thread (inferior_ptid);
+ }
+}
+
+/* This routine is called to find out if the inferior is using threads.
+ We check for the _thread_run and _thread_list globals. */
+
+void
+freebsd_uthread_new_objfile (struct objfile *objfile)
+{
+ struct minimal_symbol *ms;
+
+ if (!objfile)
+ {
+ freebsd_uthread_active = 0;
+ return;
+ }
+
+ ms = lookup_minimal_symbol ("_thread_run", NULL, objfile);
+
+ if (!ms)
+ return;
+
+ P_thread_run = SYMBOL_VALUE_ADDRESS (ms);
+
+ ms = lookup_minimal_symbol ("_thread_list", NULL, objfile);
+
+ if (!ms)
+ return;
+
+ P_thread_list = SYMBOL_VALUE_ADDRESS (ms);
+
+#define OFFSET_SYM(field) "_thread_" #field "_offset"
+#define LOOKUP_OFFSET(field) \
+ do { \
+ ms = lookup_minimal_symbol (OFFSET_SYM(field), NULL, objfile); \
+ if (!ms) \
+ return; \
+ P_thread_##field##_offset = SYMBOL_VALUE_ADDRESS (ms); \
+ } while (0);
+
+#define VALUE_SYM(name) "_thread_" #name "_value"
+#define LOOKUP_VALUE(name) \
+ do { \
+ ms = lookup_minimal_symbol (VALUE_SYM(name), NULL, objfile); \
+ if (!ms) \
+ return; \
+ P_thread_##name##_value = SYMBOL_VALUE_ADDRESS (ms); \
+ } while (0);
+
+ LOOKUP_OFFSET(next);
+ LOOKUP_OFFSET(uniqueid);
+ LOOKUP_OFFSET(state);
+ LOOKUP_OFFSET(name);
+ LOOKUP_OFFSET(ctx);
+
+ LOOKUP_VALUE(PS_RUNNING);
+ LOOKUP_VALUE(PS_DEAD);
+
+ freebsd_uthread_active = 1;
+}
+
+/* Clean up after the inferior dies. */
+
+static void
+freebsd_uthread_mourn_inferior ()
+{
+ child_ops.to_mourn_inferior ();
+ unpush_target (&freebsd_uthread_ops);
+}
+
+/* Mark our target-struct as eligible for stray "run" and "attach" commands. */
+
+static int
+freebsd_uthread_can_run ()
+{
+ return child_suppress_run;
+}
+
+static int
+freebsd_uthread_thread_alive (ptid_t ptid)
+{
+ struct cached_pthread *thread;
+ int ret = 0;
+
+ if (freebsd_uthread_attaching)
+ return 1;
+
+ /*
+ * We can get called from child_ops.to_wait() which passes the underlying
+ * pid (without a thread number).
+ */
+ if (TIDGET(ptid) == 0)
+ return 1;
+
+ if (find_pthread_addr (ptid) != 0)
+ {
+ thread = find_pthread (ptid);
+ ret = (thread->state != PS_DEAD_value);
+ }
+
+ if (!ret)
+ free_ptid(ptid);
+
+ return ret;
+}
+
+static void
+freebsd_uthread_stop (void)
+{
+ child_ops.to_stop ();
+}
+
+static void
+freebsd_uthread_find_new_threads (void)
+{
+ CORE_ADDR ptr;
+ int state;
+ u_int64_t uniqueid;
+
+ read_memory ((CORE_ADDR)P_thread_list,
+ (char *)&ptr,
+ sizeof ptr);
+
+ while (ptr != 0)
+ {
+ READ_FIELD(ptr, int, state, state);
+ READ_FIELD(ptr, u_int64_t, uniqueid, uniqueid);
+ if (state != PS_DEAD_value &&
+ !in_thread_list (find_ptid(uniqueid)))
+ add_thread (find_ptid(uniqueid));
+ ptr = read_pthread_next(ptr);
+ }
+}
+
+/* MUST MATCH enum pthread_state */
+static const char *statenames[] = {
+ "RUNNING",
+ "SIGTHREAD",
+ "MUTEX_WAIT",
+ "COND_WAIT",
+ "FDLR_WAIT",
+ "FDLW_WAIT",
+ "FDR_WAIT",
+ "FDW_WAIT",
+ "POLL_WAIT",
+ "FILE_WAIT",
+ "SELECT_WAIT",
+ "SLEEP_WAIT",
+ "WAIT_WAIT",
+ "SIGSUSPEND",
+ "SIGWAIT",
+ "SPINBLOCK",
+ "JOIN",
+ "SUSPENDED",
+ "DEAD",
+ "DEADLOCK",
+};
+
+#if 0
+
+static int
+freebsd_uthread_get_thread_info (ref, selection, info)
+ gdb_threadref *ref;
+ int selection;
+ struct gdb_ext_thread_info *info;
+{
+ int pid = *ref;
+ struct cached_pthread *thread = find_pthread (pid);
+ struct cleanup *old_chain;
+
+ old_chain = save_inferior_pid ();
+ inferior_pid = main_pid;
+
+ memset(&info->threadid, 0, OPAQUETHREADBYTES);
+
+ memcpy(&info->threadid, ref, sizeof *ref);
+ info->active = thread->state == PS_RUNNING_value;
+ strcpy(info->display, statenames[thread->state]);
+ if (thread->name)
+ read_memory ((CORE_ADDR) thread->name, info->shortname, 32);
+ else
+ strcpy(info->shortname, "");
+
+ do_cleanups (old_chain);
+ return (0);
+}
+
+#endif
+
+char *
+freebsd_uthread_pid_to_str (ptid_t ptid)
+{
+ static char buf[30];
+
+ if (STREQ (current_target.to_shortname, "freebsd-uthreads"))
+ sprintf (buf, "Process %d, Thread %ld",
+ PIDGET(ptid), TIDGET(ptid));
+ else
+ sprintf (buf, "Process %d", PIDGET(ptid));
+
+ return buf;
+}
+
+
+static void
+init_freebsd_uthread_ops ()
+{
+ freebsd_uthread_ops.to_shortname = "freebsd-uthreads";
+ freebsd_uthread_ops.to_longname = "FreeBSD uthreads";
+ freebsd_uthread_ops.to_doc = "FreeBSD user threads support.";
+ freebsd_uthread_ops.to_open = freebsd_uthread_open;
+ freebsd_uthread_ops.to_attach = freebsd_uthread_attach;
+ freebsd_uthread_ops.to_post_attach = freebsd_uthread_post_attach;
+ freebsd_uthread_ops.to_detach = freebsd_uthread_detach;
+ freebsd_uthread_ops.to_resume = freebsd_uthread_resume;
+ freebsd_uthread_ops.to_wait = freebsd_uthread_wait;
+ freebsd_uthread_ops.to_fetch_registers = freebsd_uthread_fetch_registers;
+ freebsd_uthread_ops.to_store_registers = freebsd_uthread_store_registers;
+ freebsd_uthread_ops.to_prepare_to_store = freebsd_uthread_prepare_to_store;
+ freebsd_uthread_ops.to_xfer_memory = freebsd_uthread_xfer_memory;
+ freebsd_uthread_ops.to_files_info = freebsd_uthread_files_info;
+ freebsd_uthread_ops.to_insert_breakpoint = memory_insert_breakpoint;
+ freebsd_uthread_ops.to_remove_breakpoint = memory_remove_breakpoint;
+ freebsd_uthread_ops.to_terminal_init = terminal_init_inferior;
+ freebsd_uthread_ops.to_terminal_inferior = terminal_inferior;
+ freebsd_uthread_ops.to_terminal_ours_for_output = terminal_ours_for_output;
+ freebsd_uthread_ops.to_terminal_ours = terminal_ours;
+ freebsd_uthread_ops.to_terminal_info = child_terminal_info;
+ freebsd_uthread_ops.to_kill = freebsd_uthread_kill_inferior;
+ freebsd_uthread_ops.to_create_inferior = freebsd_uthread_create_inferior;
+ freebsd_uthread_ops.to_mourn_inferior = freebsd_uthread_mourn_inferior;
+ freebsd_uthread_ops.to_can_run = freebsd_uthread_can_run;
+ freebsd_uthread_ops.to_notice_signals = freebsd_uthread_notice_signals;
+ freebsd_uthread_ops.to_thread_alive = freebsd_uthread_thread_alive;
+ freebsd_uthread_ops.to_stop = freebsd_uthread_stop;
+ freebsd_uthread_ops.to_stratum = process_stratum;
+ freebsd_uthread_ops.to_has_all_memory = 1;
+ freebsd_uthread_ops.to_has_memory = 1;
+ freebsd_uthread_ops.to_has_stack = 1;
+ freebsd_uthread_ops.to_has_registers = 1;
+ freebsd_uthread_ops.to_has_execution = 1;
+ freebsd_uthread_ops.to_has_thread_control = 0;
+ freebsd_uthread_ops.to_magic = OPS_MAGIC;
+ freebsd_uthread_ops.to_find_new_threads = freebsd_uthread_find_new_threads;
+ freebsd_uthread_ops.to_pid_to_str = freebsd_uthread_pid_to_str;
+#if 0
+ freebsd_uthread_vec.get_thread_info = freebsd_uthread_get_thread_info;
+#endif
+}
+
+void
+_initialize_freebsd_uthread ()
+{
+ init_freebsd_uthread_ops ();
+ add_target (&freebsd_uthread_ops);
+
+ target_new_objfile_chain = target_new_objfile_hook;
+ target_new_objfile_hook = freebsd_uthread_new_objfile;
+
+ child_suppress_run = 1;
+}

20
devel/fpc-gdb/files/patch-gdb_i386bsd-nat.c Normal file
View File

@ -0,0 +1,20 @@
--- gdb/i386bsd-nat.c 2003/05/19 07:22:00 1.1
+++ gdb/i386bsd-nat.c 2003/05/19 07:22:35
@@ -305,7 +305,7 @@
/* For some mysterious reason, some of the reserved bits in the
debug control register get set. Mask these off, otherwise the
ptrace call below will fail. */
- dbregs.dr7 &= ~(0x0000fc00);
+ DBREG_DRX ((&dbregs), 7) = ~(0x0000fc00);
DBREG_DRX ((&dbregs), regnum) = value;
@@ -354,7 +354,7 @@
return 0;
#endif
- return dbregs.dr6;
+ return DBREG_DRX ((&dbregs), 6);
}
#endif /* PT_GETDBREGS */

1058
devel/fpc-gdb/files/patch-gdb_kvm-fbsd.c Normal file
View File

File diff suppressed because it is too large Load Diff

15
devel/fpc-gdb/files/patch-gdb_symfile.c Normal file
View File

@ -0,0 +1,15 @@
--- gdb/symfile.c Tue Feb 26 17:40:36 2002
+++ gdb/symfile.c Wed May 29 11:10:17 2002
@@ -1546,11 +1546,7 @@
char *val = sect_opts[i].value;
char *sec = sect_opts[i].name;
- val = sect_opts[i].value;
- if (val[0] == '0' && val[1] == 'x')
- addr = strtoul (val+2, NULL, 16);
- else
- addr = strtoul (val, NULL, 10);
+ addr = parse_and_eval_address(val);
/* Here we store the section offsets in the order they were
entered on the command line. */

14
devel/fpc-gdb/files/patch-gdb_target.c Normal file
View File

@ -0,0 +1,14 @@
--- gdb/target.c.orig Thu Jan 31 17:01:21 2002
+++ gdb/target.c Fri Jun 7 16:36:06 2002
@@ -1361,7 +1361,11 @@
for (t = target_structs; t < target_structs + target_struct_size;
++t)
{
+#if defined(__FreeBSD__) && defined(__i386__)
+ if ((*t)->to_stratum == (kernel_debugging ? kcore_stratum : core_stratum))
+#else
if ((*t)->to_stratum == core_stratum)
+#endif
{
runable = *t;
++count;

10
devel/fpc-gdb/files/patch-gdb_target.h Normal file
View File

@ -0,0 +1,10 @@
--- gdb/target.h Sat Feb 9 20:08:42 2002
+++ gdb/target.h Fri May 24 08:38:31 2002
@@ -52,6 +52,7 @@
dummy_stratum, /* The lowest of the low */
file_stratum, /* Executable files, etc */
core_stratum, /* Core dump files */
+ kcore_stratum, /* Kernel core files */
download_stratum, /* Downloading of remote targets */
process_stratum, /* Executing processes */
thread_stratum /* Executing threads */

5
devel/fpc-gdb/files/patch-gdb_version.in Normal file
View File

@ -0,0 +1,5 @@
--- gdb/version.in Fri Apr 26 18:04:22 2002
+++ gdb/version.in Mon Jun 3 08:14:54 2002
@@ -1 +1 @@
-5.2
+5.2 (FreeBSD)

6
devel/fpc-gdb/pkg-descr Normal file
View File

@ -0,0 +1,6 @@
GNU GDB 5.2.1 modified to work with Free Pascal.
WWW: http://www.freepascal.org/
--
John Merryweather Cooper <coop9211@uidaho.edu>

12
devel/fpc-gdb/pkg-plist Normal file
View File

@ -0,0 +1,12 @@
bin/gdbfpc
lib/fpc/1.0.10/units/freebsd/gdbint/libgdb/libbfd.a
lib/fpc/1.0.10/units/freebsd/gdbint/libgdb/libgdb.a
lib/fpc/1.0.10/units/freebsd/gdbint/libgdb/libiberty.a
lib/fpc/1.0.10/units/freebsd/gdbint/libgdb/libintl.a
lib/fpc/1.0.10/units/freebsd/gdbint/libgdb/libopcodes.a
@dirrm lib/fpc/1.0.10/units/freebsd/gdbint/libgdb
@dirrm lib/fpc/1.0.10/units/freebsd/gdbint
@dirrm lib/fpc/1.0.10/units/freebsd
@dirrm lib/fpc/1.0.10/units
@dirrm lib/fpc/1.0.10
@dirrm lib/fpc