Revert "devel/gdb: sync with upstream"

This reverts commit 3ca5c0f415.
2020-03-27 07:25:06 +01:00 · 2020-03-27 07:25:06 +01:00 · 58819c7d28
parent b0021c175f
commit 58819c7d28
27 changed files with 1810 additions and 241 deletions
--- a/devel/gdb/Makefile
+++ b/devel/gdb/Makefile
@ -2,7 +2,8 @@
 # $FreeBSD$

 PORTNAME=	gdb
-PORTVERSION=	9.1
+PORTVERSION=	8.3.1
+PORTREVISION=	1
 CATEGORIES=	devel
 MASTER_SITES=	GNU

@ -18,7 +19,7 @@ NOT_FOR_ARCHS=	sparc64
 LIB_DEPENDS=	libmpfr.so:math/mpfr
 TEST_DEPENDS=	runtest:misc/dejagnu

-USES=		compiler:c++11-lang cpe gmake libtool makeinfo pkgconfig tar:xz
+USES=		compiler:c++11-lang cpe gmake libtool pkgconfig tar:xz
 USE_PYTHON=	flavors py3kplist

 TEST_TARGET=	check
@ -33,12 +34,20 @@ CONFIGURE_ARGS=	--program-suffix=${PORTVERSION:S/.//g} \
 		${ICONV_CONFIGURE_ARG} \
 		--with-expat=yes --with-libexpat-prefix=${LOCALBASE} \
 		--without-libunwind-ia64 --with-system-zlib
-CONFIGURE_OUTSOURCE=	yes
 CFLAGS:=	${CFLAGS:C/ +$//}	# blanks at EOL creep in sometimes
 CFLAGS+=	-DRL_NO_COMPAT -Wno-unused-function -Wno-unused-variable
 CFLAGS+=	-Wno-unknown-warning-option
 EXCLUDE=	dejagnu expect sim texinfo intl
 EXTRACT_AFTER_ARGS=	${EXCLUDE:S/^/--exclude /}
+EXTRA_PATCHES=	${FILESDIR}/commit-1163a4b7a3 \
+		${FILESDIR}/commit-dd6876c91c \
+		${FILESDIR}/commit-6e056c8178 \
+		${FILESDIR}/commit-36c53a0262 \
+		${FILESDIR}/commit-ef0bd2046f \
+		${FILESDIR}/commit-945f3901b5 \
+		${FILESDIR}/commit-f5424cfa7e \
+		${FILESDIR}/commit-ce25aa57a3 \
+		${FILESDIR}/commit-8399425f5f
 LIB_DEPENDS+=	libexpat.so:textproc/expat2

 VER=		${PORTVERSION:S/.//g}
@ -70,6 +79,7 @@ OPTIONS_SUB=	yes
 BUNDLED_READLINE_CONFIGURE_OFF=	--with-system-readline
 DEBUG_CFLAGS=		-g
 GUILE_CONFIGURE_WITH=	guile
+GUILE_USES=		pkgconfig
 GUILE_LIB_DEPENDS=	libguile-2.2.so:lang/guile2
 GUILE_EXTRA_PATCHES=	${FILESDIR}/extrapatch-guile22
 NLS_USES=	gettext-runtime
@ -108,6 +118,10 @@ PLIST_SUB+=	LIBCXX=""
 PLIST_SUB+=	LIBCXX="@comment "
 .endif

+.if ! ${PORT_OPTIONS:MBUNDLED_READLINE}
+EXCLUDE+=	readline
+.endif
+
 .if ! ${PORT_OPTIONS:MBUNDLED_ZLIB}
 EXCLUDE+=	zlib
 .endif
@ -129,15 +143,15 @@ post-patch-KGDB-on:
 	@${PATCH} -d ${PATCH_WRKSRC} ${PATCH_ARGS} < ${FILESDIR}/extrapatch-kgdb

 do-install:
-	${INSTALL_PROGRAM} ${INSTALL_WRKSRC}/gdb/gdb \
+	${INSTALL_PROGRAM} ${WRKSRC}/gdb/gdb \
 		${STAGEDIR}${PREFIX}/bin/gdb${VER}
 	${INSTALL_MAN} ${WRKSRC}/gdb/doc/gdb.1 \
 		${STAGEDIR}${MAN1PREFIX}/man/man1/gdb${VER}.1
-	(cd ${INSTALL_WRKSRC}/gdb/data-directory ; \
+	(cd ${WRKSRC}/gdb/data-directory ; \
 		${SETENV} ${MAKE_ENV} ${MAKE_CMD} ${MAKE_ARGS} install-syscalls )

 do-install-KGDB-on:
-	${INSTALL_PROGRAM} ${INSTALL_WRKSRC}/gdb/kgdb \
+	${INSTALL_PROGRAM} ${WRKSRC}/gdb/kgdb \
 		${STAGEDIR}${PREFIX}/bin/kgdb${VER}
 	${INSTALL_MAN} ${FILESDIR}/kgdb/kgdb.1 \
 		${STAGEDIR}${MAN1PREFIX}/man/man1/kgdb${VER}.1
@ -154,9 +168,8 @@ do-install-GDB_LINK-on:
 .endif

 do-install-PYTHON-on:
-	(cd ${INSTALL_WRKSRC}/gdb ; \
-		${SETENV} ${MAKE_ENV} ${MAKE_CMD} ${MAKE_ARGS} install-python )
-	(cd ${INSTALL_WRKSRC}/gdb/data-directory ; \
+	(cd ${WRKSRC}/gdb; ${SETENV} ${MAKE_ENV} ${MAKE_CMD} ${MAKE_ARGS} install-python )
+	(cd ${WRKSRC}/gdb/data-directory ; \
 		${SETENV} ${MAKE_ENV} ${MAKE_CMD} ${MAKE_ARGS} install-python )
 	@(cd ${STAGEDIR}${PREFIX}/share/gdb/python && \
 		${PYTHON_CMD} -m compileall .)
@ -173,9 +186,8 @@ do-install-PYTHON-on:
 .endif

 do-install-GUILE-on:
-	(cd ${INSTALL_WRKSRC}/gdb ; \
-		${SETENV} ${MAKE_ENV} ${MAKE_CMD} ${MAKE_ARGS} install-guile )
-	(cd ${INSTALL_WRKSRC}/gdb/data-directory ; \
+	(cd ${WRKSRC}/gdb; ${SETENV} ${MAKE_ENV} ${MAKE_CMD} ${MAKE_ARGS} install-guile )
+	(cd ${WRKSRC}/gdb/data-directory ; \
 		${SETENV} ${MAKE_ENV} ${MAKE_CMD} ${MAKE_ARGS} install-guile )

 .include <bsd.port.post.mk>
--- a/devel/gdb/distinfo
+++ b/devel/gdb/distinfo
@ -1,5 +1,5 @@
-TIMESTAMP = 1582826568
-SHA256 (gdb-9.1.tar.xz) = 699e0ec832fdd2f21c8266171ea5bf44024bd05164fdf064e4d10cc4cf0d1737
-SIZE (gdb-9.1.tar.xz) = 20980824
+TIMESTAMP = 1569514923
+SHA256 (gdb-8.3.1.tar.xz) = 1e55b4d7cdca7b34be12f4ceae651623aa73b2fd640152313f9f66a7149757c4
+SIZE (gdb-8.3.1.tar.xz) = 20489528
 SHA256 (bsdjhb-libcxx-gdbpy-229610a_GH0.tar.gz) = d4235f98b71c4d5e3f01744de279e64808229dd46c0f00cac6a12fdeb3a998a1
 SIZE (bsdjhb-libcxx-gdbpy-229610a_GH0.tar.gz) = 5299
--- a/devel/gdb/files/commit-1163a4b7a3
+++ b/devel/gdb/files/commit-1163a4b7a3
@ -0,0 +1,419 @@
+commit 1163a4b7a38a79ebd153dc5ee76ce93877d21dbd
+Author: John Baldwin <jhb@FreeBSD.org>
+Date:   Tue Mar 12 13:39:02 2019 -0700
+
+    Support the fs_base and gs_base registers on i386.
+    
+    As on amd64, these registers hold the base address of the fs and gs
+    segments, respectively.  For i386 these two registers are 32 bits.
+    
+    gdb/ChangeLog:
+    
+            * amd64-fbsd-nat.c (amd64_fbsd_nat_target::read_description):
+            Update calls to i386_target_description to add 'segments'
+            parameter.
+            * amd64-tdep.c (amd64_init_abi): Set tdep->fsbase_regnum.  Don't
+            add segment base registers.
+            * arch/i386.c (i386_create_target_description): Add 'segments'
+            parameter to enable segment base registers.
+            * arch/i386.h (i386_create_target_description): Likewise.
+            * features/i386/32bit-segments.xml: New file.
+            * features/i386/32bit-segments.c: Generate.
+            * i386-fbsd-nat.c (i386_fbsd_nat_target::read_description): Update
+            call to i386_target_description to add 'segments' parameter.
+            * i386-fbsd-tdep.c (i386fbsd_core_read_description): Likewise.
+            * i386-go32-tdep.c (i386_go32_init_abi): Likewise.
+            * i386-linux-tdep.c (i386_linux_read_description): Likewise.
+            * i386-tdep.c (i386_validate_tdesc_p): Add segment base registers
+            if feature is present.
+            (i386_gdbarch_init): Pass I386_NUM_REGS to set_gdbarch_num_regs.
+            Add 'segments' parameter to call to i386_target_description.
+            (i386_target_description): Add 'segments' parameter to enable
+            segment base registers.
+            (_initialize_i386_tdep) [GDB_SELF_TEST]: Add 'segments' parameter
+            to call to i386_target_description.
+            * i386-tdep.h (struct gdbarch_tdep): Add 'fsbase_regnum'.
+            (enum i386_regnum): Add I386_FSBASE_REGNUM and I386_GSBASE_REGNUM.
+            Define I386_NUM_REGS.
+            (i386_target_description): Add 'segments' parameter to enable
+            segment base registers.
+    
+    gdb/gdbserver/ChangeLog:
+    
+            * linux-x86-tdesc.c (i386_linux_read_description): Update call to
+            i386_create_target_description for 'segments' parameter.
+            * lynx-i386-low.c (lynx_i386_arch_setup): Likewise.
+            * nto-x86-low.c (nto_x86_arch_setup): Likewise.
+            * win32-i386-low.c (i386_arch_setup): Likewise.
+
+diff --git gdb/amd64-fbsd-nat.c gdb/amd64-fbsd-nat.c
+index 74ef240766..9fff763dd3 100644
+--- gdb/amd64-fbsd-nat.c
+++ gdb/amd64-fbsd-nat.c
+@@ -190,13 +190,13 @@ amd64_fbsd_nat_target::read_description ()
+       if (is64)
+ 	return amd64_target_description (xcr0, true);
+       else
+-	return i386_target_description (xcr0);
+	return i386_target_description (xcr0, false);
+     }
+ #endif
+   if (is64)
+     return amd64_target_description (X86_XSTATE_SSE_MASK, true);
+   else
+-    return i386_target_description (X86_XSTATE_SSE_MASK);
+    return i386_target_description (X86_XSTATE_SSE_MASK, false);
+ }
+ 
+ #if defined(HAVE_PT_GETDBREGS) && defined(USE_SIGTRAP_SIGINFO)
+diff --git gdb/amd64-tdep.c gdb/amd64-tdep.c
+index 3f61997d66..d5892954d7 100644
+--- gdb/amd64-tdep.c
+++ gdb/amd64-tdep.c
+@@ -3107,15 +3107,7 @@ amd64_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch,
+ 
+   if (tdesc_find_feature (tdesc, "org.gnu.gdb.i386.segments") != NULL)
+     {
+-      const struct tdesc_feature *feature =
+-	  tdesc_find_feature (tdesc, "org.gnu.gdb.i386.segments");
+-      struct tdesc_arch_data *tdesc_data_segments =
+-	  (struct tdesc_arch_data *) info.tdep_info;
+-
+-      tdesc_numbered_register (feature, tdesc_data_segments,
+-		       AMD64_FSBASE_REGNUM, "fs_base");
+-      tdesc_numbered_register (feature, tdesc_data_segments,
+-		       AMD64_GSBASE_REGNUM, "gs_base");
+      tdep->fsbase_regnum = AMD64_FSBASE_REGNUM;
+     }
+ 
+   if (tdesc_find_feature (tdesc, "org.gnu.gdb.i386.pkeys") != NULL)
+diff --git gdb/arch/i386.c gdb/arch/i386.c
+index 7d2901333b..ab24cf71cb 100644
+--- gdb/arch/i386.c
+++ gdb/arch/i386.c
+@@ -28,11 +28,12 @@
+ #include "../features/i386/32bit-avx512.c"
+ #include "../features/i386/32bit-mpx.c"
+ #include "../features/i386/32bit-pkeys.c"
+#include "../features/i386/32bit-segments.c"
+ 
+ /* Create i386 target descriptions according to XCR0.  */
+ 
+ target_desc *
+-i386_create_target_description (uint64_t xcr0, bool is_linux)
+i386_create_target_description (uint64_t xcr0, bool is_linux, bool segments)
+ {
+   target_desc *tdesc = allocate_target_description ();
+ 
+@@ -53,6 +54,9 @@ i386_create_target_description (uint64_t xcr0, bool is_linux)
+   if (is_linux)
+     regnum = create_feature_i386_32bit_linux (tdesc, regnum);
+ 
+  if (segments)
+    regnum = create_feature_i386_32bit_segments (tdesc, regnum);
+
+   if (xcr0 & X86_XSTATE_AVX)
+     regnum = create_feature_i386_32bit_avx (tdesc, regnum);
+ 
+diff --git gdb/arch/i386.h gdb/arch/i386.h
+index fa85438080..9a831cea30 100644
+--- gdb/arch/i386.h
+++ gdb/arch/i386.h
+@@ -21,6 +21,7 @@
+ #include "common/tdesc.h"
+ #include <stdint.h>
+ 
+-target_desc *i386_create_target_description (uint64_t xcr0, bool is_linux);
+target_desc *i386_create_target_description (uint64_t xcr0, bool is_linux,
+					     bool segments);
+ 
+ #endif /* ARCH_I386_H */
+diff --git gdb/features/i386/32bit-segments.c gdb/features/i386/32bit-segments.c
+new file mode 100644
+index 0000000000..c22c3dfbc3
+--- /dev/null
+++ gdb/features/i386/32bit-segments.c
+@@ -0,0 +1,15 @@
+/* THIS FILE IS GENERATED.  -*- buffer-read-only: t -*- vi:set ro:
+  Original: 32bit-segments.xml */
+
+#include "common/tdesc.h"
+
+static int
+create_feature_i386_32bit_segments (struct target_desc *result, long regnum)
+{
+  struct tdesc_feature *feature;
+
+  feature = tdesc_create_feature (result, "org.gnu.gdb.i386.segments");
+  tdesc_create_reg (feature, "fs_base", regnum++, 1, NULL, 32, "int");
+  tdesc_create_reg (feature, "gs_base", regnum++, 1, NULL, 32, "int");
+  return regnum;
+}
+diff --git gdb/features/i386/32bit-segments.xml gdb/features/i386/32bit-segments.xml
+new file mode 100644
+index 0000000000..098948e5ec
+--- /dev/null
+++ gdb/features/i386/32bit-segments.xml
+@@ -0,0 +1,12 @@
+<?xml version="1.0"?>
+<!-- Copyright (C) 2016-2018 Free Software Foundation, Inc.
+
+     Copying and distribution of this file, with or without modification,
+     are permitted in any medium without royalty provided the copyright
+     notice and this notice are preserved.  -->
+
+<!DOCTYPE feature SYSTEM "gdb-target.dtd">
+<feature name="org.gnu.gdb.i386.segments">
+  <reg name="fs_base" bitsize="32" type="int"/>
+  <reg name="gs_base" bitsize="32" type="int"/>
+</feature>
+diff --git gdb/gdbserver/linux-x86-tdesc.c gdb/gdbserver/linux-x86-tdesc.c
+index 04bccc84ed..8f24a3d72d 100644
+--- gdb/gdbserver/linux-x86-tdesc.c
+++ gdb/gdbserver/linux-x86-tdesc.c
+@@ -87,7 +87,7 @@ i386_linux_read_description (uint64_t xcr0)
+ 
+   if (*tdesc == NULL)
+     {
+-      *tdesc = i386_create_target_description (xcr0, true);
+      *tdesc = i386_create_target_description (xcr0, true, false);
+ 
+       init_target_desc (*tdesc, i386_expedite_regs);
+     }
+diff --git gdb/gdbserver/lynx-i386-low.c gdb/gdbserver/lynx-i386-low.c
+index bc1027dc52..e47f6b92f6 100644
+--- gdb/gdbserver/lynx-i386-low.c
+++ gdb/gdbserver/lynx-i386-low.c
+@@ -331,7 +331,7 @@ static void
+ lynx_i386_arch_setup (void)
+ {
+   struct target_desc *tdesc
+-    = i386_create_target_description (X86_XSTATE_SSE_MASK, false);
+    = i386_create_target_description (X86_XSTATE_SSE_MASK, false, false);
+ 
+   init_target_desc (tdesc, i386_expedite_regs);
+ 
+diff --git gdb/gdbserver/nto-x86-low.c gdb/gdbserver/nto-x86-low.c
+index 1b00f7f6cc..cfbe7ba6d8 100644
+--- gdb/gdbserver/nto-x86-low.c
+++ gdb/gdbserver/nto-x86-low.c
+@@ -89,7 +89,7 @@ nto_x86_arch_setup (void)
+ {
+   the_low_target.num_regs = 16;
+   struct target_desc *tdesc
+-    = i386_create_target_description (X86_XSTATE_SSE_MASK, false);
+    = i386_create_target_description (X86_XSTATE_SSE_MASK, false, false);
+ 
+   init_target_desc (tdesc, i386_expedite_regs);
+ 
+diff --git gdb/gdbserver/win32-i386-low.c gdb/gdbserver/win32-i386-low.c
+index 3be75d2bf2..7b187d3bea 100644
+--- gdb/gdbserver/win32-i386-low.c
+++ gdb/gdbserver/win32-i386-low.c
+@@ -439,7 +439,7 @@ i386_arch_setup (void)
+ 					   false, false);
+   const char **expedite_regs = amd64_expedite_regs;
+ #else
+-  tdesc = i386_create_target_description (X86_XSTATE_SSE_MASK, false);
+  tdesc = i386_create_target_description (X86_XSTATE_SSE_MASK, false, false);
+   const char **expedite_regs = i386_expedite_regs;
+ #endif
+ 
+diff --git gdb/i386-fbsd-nat.c gdb/i386-fbsd-nat.c
+index 2309b76506..7106e90801 100644
+--- gdb/i386-fbsd-nat.c
+++ gdb/i386-fbsd-nat.c
+@@ -160,7 +160,7 @@ i386_fbsd_nat_target::read_description ()
+   if (x86bsd_xsave_len == 0)
+     xcr0 = X86_XSTATE_SSE_MASK;
+ 
+-  return i386_target_description (xcr0);
+  return i386_target_description (xcr0, false);
+ }
+ #endif
+ 
+diff --git gdb/i386-fbsd-tdep.c gdb/i386-fbsd-tdep.c
+index 236edd692a..2f28bad728 100644
+--- gdb/i386-fbsd-tdep.c
+++ gdb/i386-fbsd-tdep.c
+@@ -267,7 +267,7 @@ i386fbsd_core_read_description (struct gdbarch *gdbarch,
+ 				struct target_ops *target,
+ 				bfd *abfd)
+ {
+-  return i386_target_description (i386fbsd_core_read_xcr0 (abfd));
+  return i386_target_description (i386fbsd_core_read_xcr0 (abfd), false);
+ }
+ 
+ /* Similar to i386_supply_fpregset, but use XSAVE extended state.  */
+diff --git gdb/i386-go32-tdep.c gdb/i386-go32-tdep.c
+index 06833c346c..30db72d880 100644
+--- gdb/i386-go32-tdep.c
+++ gdb/i386-go32-tdep.c
+@@ -35,7 +35,7 @@ i386_go32_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
+ 
+   /* DJGPP does not support the SSE registers.  */
+   if (!tdesc_has_registers (info.target_desc))
+-    tdep->tdesc = i386_target_description (X86_XSTATE_X87_MASK);
+    tdep->tdesc = i386_target_description (X86_XSTATE_X87_MASK, false);
+ 
+   /* Native compiler is GCC, which uses the SVR4 register numbering
+      even in COFF and STABS.  See the comment in i386_gdbarch_init,
+diff --git gdb/i386-linux-tdep.c gdb/i386-linux-tdep.c
+index da81715061..fa6b86f1c8 100644
+--- gdb/i386-linux-tdep.c
+++ gdb/i386-linux-tdep.c
+@@ -694,7 +694,7 @@ i386_linux_read_description (uint64_t xcr0)
+     [(xcr0 & X86_XSTATE_PKRU) ? 1 : 0];
+ 
+   if (*tdesc == NULL)
+-    *tdesc = i386_create_target_description (xcr0, true);
+    *tdesc = i386_create_target_description (xcr0, true, false);
+ 
+   return *tdesc;
+ }
+diff --git gdb/i386-tdep.c gdb/i386-tdep.c
+index bc9ba752ed..4e63832b0e 100644
+--- gdb/i386-tdep.c
+++ gdb/i386-tdep.c
+@@ -8175,7 +8175,7 @@ i386_validate_tdesc_p (struct gdbarch_tdep *tdep,
+   const struct tdesc_feature *feature_core;
+ 
+   const struct tdesc_feature *feature_sse, *feature_avx, *feature_mpx,
+-			     *feature_avx512, *feature_pkeys;
+			     *feature_avx512, *feature_pkeys, *feature_segments;
+   int i, num_regs, valid_p;
+ 
+   if (! tdesc_has_registers (tdesc))
+@@ -8198,6 +8198,9 @@ i386_validate_tdesc_p (struct gdbarch_tdep *tdep,
+   /* Try AVX512 registers.  */
+   feature_avx512 = tdesc_find_feature (tdesc, "org.gnu.gdb.i386.avx512");
+ 
+  /* Try segment base registers.  */
+  feature_segments = tdesc_find_feature (tdesc, "org.gnu.gdb.i386.segments");
+
+   /* Try PKEYS  */
+   feature_pkeys = tdesc_find_feature (tdesc, "org.gnu.gdb.i386.pkeys");
+ 
+@@ -8307,6 +8310,16 @@ i386_validate_tdesc_p (struct gdbarch_tdep *tdep,
+ 	    tdep->mpx_register_names[i]);
+     }
+ 
+  if (feature_segments)
+    {
+      if (tdep->fsbase_regnum < 0)
+	tdep->fsbase_regnum = I386_FSBASE_REGNUM;
+      valid_p &= tdesc_numbered_register (feature_segments, tdesc_data,
+					  tdep->fsbase_regnum, "fs_base");
+      valid_p &= tdesc_numbered_register (feature_segments, tdesc_data,
+					  tdep->fsbase_regnum + 1, "gs_base");
+    }
+
+   if (feature_pkeys)
+     {
+       tdep->xcr0 |= X86_XSTATE_PKRU;
+@@ -8543,14 +8556,14 @@ i386_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
+   /* Even though the default ABI only includes general-purpose registers,
+      floating-point registers and the SSE registers, we have to leave a
+      gap for the upper AVX, MPX and AVX512 registers.  */
+-  set_gdbarch_num_regs (gdbarch, I386_PKEYS_NUM_REGS);
+  set_gdbarch_num_regs (gdbarch, I386_NUM_REGS);
+ 
+   set_gdbarch_gnu_triplet_regexp (gdbarch, i386_gnu_triplet_regexp);
+ 
+   /* Get the x86 target description from INFO.  */
+   tdesc = info.target_desc;
+   if (! tdesc_has_registers (tdesc))
+-    tdesc = i386_target_description (X86_XSTATE_SSE_MASK);
+    tdesc = i386_target_description (X86_XSTATE_SSE_MASK, false);
+   tdep->tdesc = tdesc;
+ 
+   tdep->num_core_regs = I386_NUM_GREGS + I387_NUM_REGS;
+@@ -8592,6 +8605,9 @@ i386_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
+   tdep->pkru_regnum = -1;
+   tdep->num_pkeys_regs = 0;
+ 
+  /* No segment base registers.  */
+  tdep->fsbase_regnum = -1;
+
+   tdesc_data = tdesc_data_alloc ();
+ 
+   set_gdbarch_relocate_instruction (gdbarch, i386_relocate_instruction);
+@@ -8717,20 +8733,21 @@ i386_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
+ /* Return the target description for a specified XSAVE feature mask.  */
+ 
+ const struct target_desc *
+-i386_target_description (uint64_t xcr0)
+i386_target_description (uint64_t xcr0, bool segments)
+ {
+   static target_desc *i386_tdescs \
+-    [2/*SSE*/][2/*AVX*/][2/*MPX*/][2/*AVX512*/][2/*PKRU*/] = {};
+    [2/*SSE*/][2/*AVX*/][2/*MPX*/][2/*AVX512*/][2/*PKRU*/][2/*segments*/] = {};
+   target_desc **tdesc;
+ 
+   tdesc = &i386_tdescs[(xcr0 & X86_XSTATE_SSE) ? 1 : 0]
+     [(xcr0 & X86_XSTATE_AVX) ? 1 : 0]
+     [(xcr0 & X86_XSTATE_MPX) ? 1 : 0]
+     [(xcr0 & X86_XSTATE_AVX512) ? 1 : 0]
+-    [(xcr0 & X86_XSTATE_PKRU) ? 1 : 0];
+    [(xcr0 & X86_XSTATE_PKRU) ? 1 : 0]
+    [segments ? 1 : 0];
+ 
+   if (*tdesc == NULL)
+-    *tdesc = i386_create_target_description (xcr0, false);
+    *tdesc = i386_create_target_description (xcr0, false, segments);
+ 
+   return *tdesc;
+ }
+@@ -9072,7 +9089,7 @@ Show Intel Memory Protection Extensions specific variables."),
+ 
+   for (auto &a : xml_masks)
+     {
+-      auto tdesc = i386_target_description (a.mask);
+      auto tdesc = i386_target_description (a.mask, false);
+ 
+       selftests::record_xml_tdesc (a.xml, tdesc);
+     }
+diff --git gdb/i386-tdep.h gdb/i386-tdep.h
+index 2532306e5c..c0d494824c 100644
+--- gdb/i386-tdep.h
+++ gdb/i386-tdep.h
+@@ -200,6 +200,10 @@ struct gdbarch_tdep
+   /* PKEYS register names.  */
+   const char **pkeys_register_names;
+ 
+  /* Register number for %fsbase.  Set this to -1 to indicate the
+     absence of segment base registers.  */
+  int fsbase_regnum;
+
+   /* Target description.  */
+   const struct target_desc *tdesc;
+ 
+@@ -296,7 +300,9 @@ enum i386_regnum
+   I386_K7_REGNUM = I386_K0_REGNUM + 7,
+   I386_ZMM0H_REGNUM,		/* %zmm0h */
+   I386_ZMM7H_REGNUM = I386_ZMM0H_REGNUM + 7,
+-  I386_PKRU_REGNUM
+  I386_PKRU_REGNUM,
+  I386_FSBASE_REGNUM,
+  I386_GSBASE_REGNUM
+ };
+ 
+ /* Register numbers of RECORD_REGMAP.  */
+@@ -337,6 +343,7 @@ enum record_i386_regnum
+ #define I386_MPX_NUM_REGS	(I386_BNDSTATUS_REGNUM + 1)
+ #define I386_AVX512_NUM_REGS	(I386_ZMM7H_REGNUM + 1)
+ #define I386_PKEYS_NUM_REGS	(I386_PKRU_REGNUM + 1)
+#define I386_NUM_REGS		(I386_GSBASE_REGNUM + 1)
+ 
+ /* Size of the largest register.  */
+ #define I386_MAX_REGISTER_SIZE	64
+@@ -440,7 +447,8 @@ extern int i386_svr4_reg_to_regnum (struct gdbarch *gdbarch, int reg);
+ 
+ extern int i386_process_record (struct gdbarch *gdbarch,
+                                 struct regcache *regcache, CORE_ADDR addr);
+-extern const struct target_desc *i386_target_description (uint64_t xcr0);
+extern const struct target_desc *i386_target_description (uint64_t xcr0,
+							  bool segments);
+ 
+ /* Return true iff the current target is MPX enabled.  */
+ extern int i386_mpx_enabled (void);
--- a/devel/gdb/files/commit-36c53a0262
+++ b/devel/gdb/files/commit-36c53a0262
@ -0,0 +1,60 @@
+commit 36c53a0262f84ad11d738471789dadfa9c4eb320
+Author: John Baldwin <jhb@FreeBSD.org>
+Date:   Tue Mar 12 13:39:02 2019 -0700
+
+    Remove code disabled since at least 1999 from lookup_struct_elt_type.
+    
+    Update the comment above the function to reflect the code removal and
+    document the existing behavior.
+    
+    gdb/ChangeLog:
+    
+            * gdbtypes.c (lookup_struct_elt_type): Update comment and
+            remove disabled code block.
+
+diff --git gdb/gdbtypes.c gdb/gdbtypes.c
+index 09284ef259..5924b15520 100644
+--- gdb/gdbtypes.c
+++ gdb/gdbtypes.c
+@@ -1644,8 +1644,7 @@ lookup_template_type (char *name, struct type *type,
+   return (SYMBOL_TYPE (sym));
+ }
+ 
+-/* Given a type TYPE, lookup the type of the component of type named
+-   NAME.
+/* Given a type TYPE, lookup the type of the component named NAME.
+ 
+    TYPE can be either a struct or union, or a pointer or reference to
+    a struct or union.  If it is a pointer or reference, its target
+@@ -1653,8 +1652,8 @@ lookup_template_type (char *name, struct type *type,
+    as specified for the definitions of the expression element types
+    STRUCTOP_STRUCT and STRUCTOP_PTR.
+ 
+-   If NOERR is nonzero, return zero if NAME is not suitably defined.
+-   If NAME is the name of a baseclass type, return that type.  */
+   If NOERR is nonzero, return NULL if there is no component named
+   NAME.  */
+ 
+ struct type *
+ lookup_struct_elt_type (struct type *type, const char *name, int noerr)
+@@ -1678,20 +1677,6 @@ lookup_struct_elt_type (struct type *type, const char *name, int noerr)
+ 	     type_name.c_str ());
+     }
+ 
+-#if 0
+-  /* FIXME: This change put in by Michael seems incorrect for the case
+-     where the structure tag name is the same as the member name.
+-     I.e. when doing "ptype bell->bar" for "struct foo { int bar; int
+-     foo; } bell;" Disabled by fnf.  */
+-  {
+-    char *type_name;
+-
+-    type_name = TYPE_NAME (type);
+-    if (type_name != NULL && strcmp (type_name, name) == 0)
+-      return type;
+-  }
+-#endif
+-
+   for (i = TYPE_NFIELDS (type) - 1; i >= TYPE_N_BASECLASSES (type); i--)
+     {
+       const char *t_field_name = TYPE_FIELD_NAME (type, i);
--- a/devel/gdb/files/commit-6e056c8178
+++ b/devel/gdb/files/commit-6e056c8178
@ -0,0 +1,166 @@
+commit 6e056c817845f3d736a1be6b68c69b439c6c6d25
+Author: John Baldwin <jhb@FreeBSD.org>
+Date:   Tue Mar 12 13:39:02 2019 -0700
+
+    Add a new gdbarch method to resolve the address of TLS variables.
+    
+    Permit TLS variable addresses to be resolved purely by an ABI rather
+    than requiring a target method.  This doesn't try the target method if
+    the ABI function is present (even if the ABI function fails) to
+    simplify error handling.
+    
+    gdb/ChangeLog:
+    
+            * gdbarch.sh (get_thread_local_address): New method.
+            * gdbarch.h, gdbarch.c: Regenerate.
+            * target.c (target_translate_tls_address): Use
+            gdbarch_get_thread_local_address if present instead of
+            target::get_thread_local_address.
+
+diff --git gdb/gdbarch.c gdb/gdbarch.c
+index 434ee3bfcf..2b3fcef004 100644
+--- gdb/gdbarch.c
+++ gdb/gdbarch.c
+@@ -251,6 +251,7 @@ struct gdbarch
+   CORE_ADDR deprecated_function_start_offset;
+   gdbarch_remote_register_number_ftype *remote_register_number;
+   gdbarch_fetch_tls_load_module_address_ftype *fetch_tls_load_module_address;
+  gdbarch_get_thread_local_address_ftype *get_thread_local_address;
+   CORE_ADDR frame_args_skip;
+   gdbarch_unwind_pc_ftype *unwind_pc;
+   gdbarch_unwind_sp_ftype *unwind_sp;
+@@ -613,6 +614,7 @@ verify_gdbarch (struct gdbarch *gdbarch)
+   /* Skip verify of deprecated_function_start_offset, invalid_p == 0 */
+   /* Skip verify of remote_register_number, invalid_p == 0 */
+   /* Skip verify of fetch_tls_load_module_address, has predicate.  */
+  /* Skip verify of get_thread_local_address, has predicate.  */
+   /* Skip verify of frame_args_skip, invalid_p == 0 */
+   /* Skip verify of unwind_pc, invalid_p == 0 */
+   /* Skip verify of unwind_sp, invalid_p == 0 */
+@@ -1073,6 +1075,12 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
+   fprintf_unfiltered (file,
+                       "gdbarch_dump: get_syscall_number = <%s>\n",
+                       host_address_to_string (gdbarch->get_syscall_number));
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: gdbarch_get_thread_local_address_p() = %d\n",
+                      gdbarch_get_thread_local_address_p (gdbarch));
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: get_thread_local_address = <%s>\n",
+                      host_address_to_string (gdbarch->get_thread_local_address));
+   fprintf_unfiltered (file,
+                       "gdbarch_dump: gnu_triplet_regexp = <%s>\n",
+                       host_address_to_string (gdbarch->gnu_triplet_regexp));
+@@ -3018,6 +3026,30 @@ set_gdbarch_fetch_tls_load_module_address (struct gdbarch *gdbarch,
+   gdbarch->fetch_tls_load_module_address = fetch_tls_load_module_address;
+ }
+ 
+int
+gdbarch_get_thread_local_address_p (struct gdbarch *gdbarch)
+{
+  gdb_assert (gdbarch != NULL);
+  return gdbarch->get_thread_local_address != NULL;
+}
+
+CORE_ADDR
+gdbarch_get_thread_local_address (struct gdbarch *gdbarch, ptid_t ptid, CORE_ADDR lm_addr, CORE_ADDR offset)
+{
+  gdb_assert (gdbarch != NULL);
+  gdb_assert (gdbarch->get_thread_local_address != NULL);
+  if (gdbarch_debug >= 2)
+    fprintf_unfiltered (gdb_stdlog, "gdbarch_get_thread_local_address called\n");
+  return gdbarch->get_thread_local_address (gdbarch, ptid, lm_addr, offset);
+}
+
+void
+set_gdbarch_get_thread_local_address (struct gdbarch *gdbarch,
+                                      gdbarch_get_thread_local_address_ftype get_thread_local_address)
+{
+  gdbarch->get_thread_local_address = get_thread_local_address;
+}
+
+ CORE_ADDR
+ gdbarch_frame_args_skip (struct gdbarch *gdbarch)
+ {
+diff --git gdb/gdbarch.h gdb/gdbarch.h
+index 75618376ab..abb72e752b 100644
+--- gdb/gdbarch.h
+++ gdb/gdbarch.h
+@@ -649,6 +649,18 @@ typedef CORE_ADDR (gdbarch_fetch_tls_load_module_address_ftype) (struct objfile
+ extern CORE_ADDR gdbarch_fetch_tls_load_module_address (struct gdbarch *gdbarch, struct objfile *objfile);
+ extern void set_gdbarch_fetch_tls_load_module_address (struct gdbarch *gdbarch, gdbarch_fetch_tls_load_module_address_ftype *fetch_tls_load_module_address);
+ 
+/* Return the thread-local address at OFFSET in the thread-local
+   storage for the thread PTID and the shared library or executable
+   file given by LM_ADDR.  If that block of thread-local storage hasn't
+   been allocated yet, this function may throw an error.  LM_ADDR may
+   be zero for statically linked multithreaded inferiors. */
+
+extern int gdbarch_get_thread_local_address_p (struct gdbarch *gdbarch);
+
+typedef CORE_ADDR (gdbarch_get_thread_local_address_ftype) (struct gdbarch *gdbarch, ptid_t ptid, CORE_ADDR lm_addr, CORE_ADDR offset);
+extern CORE_ADDR gdbarch_get_thread_local_address (struct gdbarch *gdbarch, ptid_t ptid, CORE_ADDR lm_addr, CORE_ADDR offset);
+extern void set_gdbarch_get_thread_local_address (struct gdbarch *gdbarch, gdbarch_get_thread_local_address_ftype *get_thread_local_address);
+
+ extern CORE_ADDR gdbarch_frame_args_skip (struct gdbarch *gdbarch);
+ extern void set_gdbarch_frame_args_skip (struct gdbarch *gdbarch, CORE_ADDR frame_args_skip);
+ 
+diff --git gdb/gdbarch.sh gdb/gdbarch.sh
+index 48fcebd19a..63bfbad7d9 100755
+--- gdb/gdbarch.sh
+++ gdb/gdbarch.sh
+@@ -602,6 +602,14 @@ m;int;remote_register_number;int regno;regno;;default_remote_register_number;;0
+ 
+ # Fetch the target specific address used to represent a load module.
+ F;CORE_ADDR;fetch_tls_load_module_address;struct objfile *objfile;objfile
+
+# Return the thread-local address at OFFSET in the thread-local
+# storage for the thread PTID and the shared library or executable
+# file given by LM_ADDR.  If that block of thread-local storage hasn't
+# been allocated yet, this function may throw an error.  LM_ADDR may
+# be zero for statically linked multithreaded inferiors.
+
+M;CORE_ADDR;get_thread_local_address;ptid_t ptid, CORE_ADDR lm_addr, CORE_ADDR offset;ptid, lm_addr, offset
+ #
+ v;CORE_ADDR;frame_args_skip;;;0;;;0
+ m;CORE_ADDR;unwind_pc;struct frame_info *next_frame;next_frame;;default_unwind_pc;;0
+diff --git gdb/target.c gdb/target.c
+index 8579c19d05..c27157d209 100644
+--- gdb/target.c
+++ gdb/target.c
+@@ -698,8 +698,9 @@ target_translate_tls_address (struct objfile *objfile, CORE_ADDR offset)
+ {
+   volatile CORE_ADDR addr = 0;
+   struct target_ops *target = current_top_target ();
+  struct gdbarch *gdbarch = target_gdbarch ();
+ 
+-  if (gdbarch_fetch_tls_load_module_address_p (target_gdbarch ()))
+  if (gdbarch_fetch_tls_load_module_address_p (gdbarch))
+     {
+       ptid_t ptid = inferior_ptid;
+ 
+@@ -708,10 +709,14 @@ target_translate_tls_address (struct objfile *objfile, CORE_ADDR offset)
+ 	  CORE_ADDR lm_addr;
+ 	  
+ 	  /* Fetch the load module address for this objfile.  */
+-	  lm_addr = gdbarch_fetch_tls_load_module_address (target_gdbarch (),
+	  lm_addr = gdbarch_fetch_tls_load_module_address (gdbarch,
+ 	                                                   objfile);
+ 
+-	  addr = target->get_thread_local_address (ptid, lm_addr, offset);
+	  if (gdbarch_get_thread_local_address_p (gdbarch))
+	    addr = gdbarch_get_thread_local_address (gdbarch, ptid, lm_addr,
+						     offset);
+	  else
+	    addr = target->get_thread_local_address (ptid, lm_addr, offset);
+ 	}
+       /* If an error occurred, print TLS related messages here.  Otherwise,
+          throw the error to some higher catcher.  */
+@@ -766,8 +771,6 @@ target_translate_tls_address (struct objfile *objfile, CORE_ADDR offset)
+ 	}
+       END_CATCH
+     }
+-  /* It wouldn't be wrong here to try a gdbarch method, too; finding
+-     TLS is an ABI-specific thing.  But we don't do that yet.  */
+   else
+     error (_("Cannot find thread-local variables on this target"));
+ 
--- a/devel/gdb/files/commit-8399425f5f
+++ b/devel/gdb/files/commit-8399425f5f
@ -0,0 +1,69 @@
+commit 8399425f5f472ad8e630bb30ad2dbefeddbb68b7
+Author: John Baldwin <jhb@FreeBSD.org>
+Date:   Tue Mar 12 13:39:02 2019 -0700
+
+    Support TLS variables on FreeBSD/powerpc.
+    
+    Derive the pointer to the DTV array from the %r2 register on 32-bit
+    powerpc and %r13 on 64-bit powerpc.
+    
+    gdb/ChangeLog:
+    
+            * ppc-fbsd-tdep.c (ppcfbsd_get_thread_local_address): New.
+            (ppcfbsd_init_abi): Install gdbarch
+            "fetch_tls_load_module_address" and "get_thread_local_address"
+            methods.
+
+diff --git gdb/ppc-fbsd-tdep.c gdb/ppc-fbsd-tdep.c
+index c21a52c898..290bd1fd88 100644
+--- gdb/ppc-fbsd-tdep.c
+++ gdb/ppc-fbsd-tdep.c
+@@ -279,6 +279,39 @@ ppcfbsd_return_value (struct gdbarch *gdbarch, struct value *function,
+ 					   regcache, readbuf, writebuf);
+ }
+ 
+/* Implement the "get_thread_local_address" gdbarch method.  */
+
+static CORE_ADDR
+ppcfbsd_get_thread_local_address (struct gdbarch *gdbarch, ptid_t ptid,
+				  CORE_ADDR lm_addr, CORE_ADDR offset)
+{
+  struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
+  struct regcache *regcache;
+  int tp_offset, tp_regnum;
+
+  regcache = get_thread_arch_regcache (ptid, gdbarch);
+
+  if (tdep->wordsize == 4)
+    {
+      tp_offset = 0x7008;
+      tp_regnum = PPC_R0_REGNUM + 2;
+    }
+  else
+    {
+      tp_offset = 0x7010;
+      tp_regnum = PPC_R0_REGNUM + 13;
+    }
+  target_fetch_registers (regcache, tp_regnum);
+
+  ULONGEST tp;
+  if (regcache->cooked_read (tp_regnum, &tp) != REG_VALID)
+    error (_("Unable to fetch tcb pointer"));
+
+  /* tp points to the end of the TCB block.  The first member of the
+     TCB is the pointer to the DTV array.  */
+  CORE_ADDR dtv_addr = tp - tp_offset;
+  return fbsd_get_thread_local_address (gdbarch, dtv_addr, lm_addr, offset);
+}
+ 
+ static void
+ ppcfbsd_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
+@@ -322,6 +355,8 @@ ppcfbsd_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
+ 
+   set_gdbarch_fetch_tls_load_module_address (gdbarch,
+ 					     svr4_fetch_objfile_link_map);
+  set_gdbarch_get_thread_local_address (gdbarch,
+					ppcfbsd_get_thread_local_address);
+ }
+ 
+ void
--- a/devel/gdb/files/commit-945f3901b5
+++ b/devel/gdb/files/commit-945f3901b5
@ -0,0 +1,224 @@
+commit 945f3901b5889e57edf5a2ee25acb51f0078a719
+Author: John Baldwin <jhb@FreeBSD.org>
+Date:   Tue Mar 12 13:39:02 2019 -0700
+
+    Add a helper function to resolve TLS variable addresses for FreeBSD.
+    
+    The fbsd_get_thread_local_address function accepts the base address of
+    a thread's DTV array and the base address of an object file's link map
+    and uses this to compute a TLS variable's address.  FreeBSD
+    architectures use an architecture-specific method to determine the
+    address of the DTV array pointer and call this helper function to
+    perform the rest of the address calculation.
+    
+            * fbsd-tdep.c (fbsd_pspace_data_handle): New variable.
+            (struct fbsd_pspace_data): New type.
+            (get_fbsd_pspace_data, fbsd_pspace_data_cleanup)
+            (fbsd_read_integer_by_name, fbsd_fetch_rtld_offsets)
+            (fbsd_get_tls_index, fbsd_get_thread_local_address): New function.
+            (_initialize_fbsd_tdep): Initialize 'fbsd_pspace_data_handle'.
+            * fbsd-tdep.c (fbsd_get_thread_local_address): New prototype.
+
+diff --git gdb/fbsd-tdep.c gdb/fbsd-tdep.c
+index d971d3a653..f06836216d 100644
+--- gdb/fbsd-tdep.c
+++ gdb/fbsd-tdep.c
+@@ -24,6 +24,7 @@
+ #include "regcache.h"
+ #include "regset.h"
+ #include "gdbthread.h"
+#include "objfiles.h"
+ #include "xml-syscall.h"
+ #include <sys/socket.h>
+ #include <arpa/inet.h>
+@@ -444,6 +445,41 @@ get_fbsd_gdbarch_data (struct gdbarch *gdbarch)
+ 	  gdbarch_data (gdbarch, fbsd_gdbarch_data_handle));
+ }
+ 
+/* Per-program-space data for FreeBSD architectures.  */
+static const struct program_space_data *fbsd_pspace_data_handle;
+
+struct fbsd_pspace_data
+{
+  /* Offsets in the runtime linker's 'Obj_Entry' structure.  */
+  LONGEST off_linkmap;
+  LONGEST off_tlsindex;
+  bool rtld_offsets_valid;
+};
+
+static struct fbsd_pspace_data *
+get_fbsd_pspace_data (struct program_space *pspace)
+{
+  struct fbsd_pspace_data *data;
+
+  data = ((struct fbsd_pspace_data *)
+	  program_space_data (pspace, fbsd_pspace_data_handle));
+  if (data == NULL)
+    {
+      data = XCNEW (struct fbsd_pspace_data);
+      set_program_space_data (pspace, fbsd_pspace_data_handle, data);
+    }
+
+  return data;
+}
+
+/* The cleanup callback for FreeBSD architecture per-program-space data.  */
+
+static void
+fbsd_pspace_data_cleanup (struct program_space *pspace, void *data)
+{
+  xfree (data);
+}
+
+ /* This is how we want PTIDs from core files to be printed.  */
+ 
+ static const char *
+@@ -1932,6 +1968,121 @@ fbsd_get_syscall_number (struct gdbarch *gdbarch, thread_info *thread)
+   internal_error (__FILE__, __LINE__, _("fbsd_get_sycall_number called"));
+ }
+ 
+/* Read an integer symbol value from the current target.  */
+
+static LONGEST
+fbsd_read_integer_by_name (struct gdbarch *gdbarch, const char *name)
+{
+  bound_minimal_symbol ms = lookup_minimal_symbol (name, NULL, NULL);
+  if (ms.minsym == NULL)
+    error (_("Unable to resolve symbol '%s'"), name);
+
+  gdb_byte buf[4];
+  if (target_read_memory (BMSYMBOL_VALUE_ADDRESS (ms), buf, sizeof buf) != 0)
+    error (_("Unable to read value of '%s'"), name);
+
+  return extract_signed_integer (buf, sizeof buf, gdbarch_byte_order (gdbarch));
+}
+
+/* Lookup offsets of fields in the runtime linker's 'Obj_Entry'
+   structure needed to determine the TLS index of an object file.  */
+
+static void
+fbsd_fetch_rtld_offsets (struct gdbarch *gdbarch, struct fbsd_pspace_data *data)
+{
+  TRY
+    {
+      /* Fetch offsets from debug symbols in rtld.  */
+      struct symbol *obj_entry_sym
+	= lookup_symbol_in_language ("Struct_Obj_Entry", NULL, STRUCT_DOMAIN,
+				     language_c, NULL).symbol;
+      if (obj_entry_sym == NULL)
+	error (_("Unable to find Struct_Obj_Entry symbol"));
+      data->off_linkmap = lookup_struct_elt (SYMBOL_TYPE(obj_entry_sym),
+					     "linkmap", 0).offset / 8;
+      data->off_tlsindex = lookup_struct_elt (SYMBOL_TYPE(obj_entry_sym),
+					      "tlsindex", 0).offset / 8;
+      data->rtld_offsets_valid = true;
+      return;
+    }
+  CATCH (e, RETURN_MASK_ERROR)
+    {
+      data->off_linkmap = -1;
+    }
+  END_CATCH
+
+  TRY
+    {
+      /* Fetch offsets from global variables in libthr.  Note that
+	 this does not work for single-threaded processes that are not
+	 linked against libthr.  */
+      data->off_linkmap = fbsd_read_integer_by_name (gdbarch,
+						     "_thread_off_linkmap");
+      data->off_tlsindex = fbsd_read_integer_by_name (gdbarch,
+						      "_thread_off_tlsindex");
+      data->rtld_offsets_valid = true;
+      return;
+    }
+  CATCH (e, RETURN_MASK_ERROR)
+    {
+      data->off_linkmap = -1;
+    }
+  END_CATCH
+}
+
+/* Helper function to read the TLS index of an object file associated
+   with a link map entry at LM_ADDR.  */
+
+static LONGEST
+fbsd_get_tls_index (struct gdbarch *gdbarch, CORE_ADDR lm_addr)
+{
+  struct fbsd_pspace_data *data = get_fbsd_pspace_data (current_program_space);
+
+  if (!data->rtld_offsets_valid)
+    fbsd_fetch_rtld_offsets (gdbarch, data);
+
+  if (data->off_linkmap == -1)
+    throw_error (TLS_GENERIC_ERROR,
+		 _("Cannot fetch runtime linker structure offsets"));
+
+  /* Simulate container_of to convert from LM_ADDR to the Obj_Entry
+     pointer and then compute the offset of the tlsindex member.  */
+  CORE_ADDR tlsindex_addr = lm_addr - data->off_linkmap + data->off_tlsindex;
+
+  gdb_byte buf[4];
+  if (target_read_memory (tlsindex_addr, buf, sizeof buf) != 0)
+    throw_error (TLS_GENERIC_ERROR,
+		 _("Cannot find thread-local variables on this target"));
+
+  return extract_signed_integer (buf, sizeof buf, gdbarch_byte_order (gdbarch));
+}
+
+/* See fbsd-tdep.h.  */
+
+CORE_ADDR
+fbsd_get_thread_local_address (struct gdbarch *gdbarch, CORE_ADDR dtv_addr,
+			       CORE_ADDR lm_addr, CORE_ADDR offset)
+{
+  LONGEST tls_index = fbsd_get_tls_index (gdbarch, lm_addr);
+
+  gdb_byte buf[gdbarch_ptr_bit (gdbarch) / TARGET_CHAR_BIT];
+  if (target_read_memory (dtv_addr, buf, sizeof buf) != 0)
+    throw_error (TLS_GENERIC_ERROR,
+		 _("Cannot find thread-local variables on this target"));
+
+  const struct builtin_type *builtin = builtin_type (gdbarch);
+  CORE_ADDR addr = gdbarch_pointer_to_address (gdbarch,
+					       builtin->builtin_data_ptr, buf);
+
+  addr += (tls_index + 1) * TYPE_LENGTH (builtin->builtin_data_ptr);
+  if (target_read_memory (addr, buf, sizeof buf) != 0)
+    throw_error (TLS_GENERIC_ERROR,
+		 _("Cannot find thread-local variables on this target"));
+
+  addr = gdbarch_pointer_to_address (gdbarch, builtin->builtin_data_ptr, buf);
+  return addr + offset;
+}
+
+ /* To be called from GDB_OSABI_FREEBSD handlers. */
+ 
+ void
+@@ -1957,4 +2108,6 @@ _initialize_fbsd_tdep (void)
+ {
+   fbsd_gdbarch_data_handle =
+     gdbarch_data_register_post_init (init_fbsd_gdbarch_data);
+  fbsd_pspace_data_handle
+    = register_program_space_data_with_cleanup (NULL, fbsd_pspace_data_cleanup);
+ }
+diff --git gdb/fbsd-tdep.h gdb/fbsd-tdep.h
+index efd7c2c78f..0e29508c9f 100644
+--- gdb/fbsd-tdep.h
+++ gdb/fbsd-tdep.h
+@@ -60,4 +60,15 @@ extern void fbsd_info_proc_mappings_entry (int addr_bit, ULONGEST kve_start,
+ 					   int kve_flags, int kve_protection,
+ 					   const void *kve_path);
+ 
+/* Helper function to fetch the address of a thread-local variable.
+   DTV_ADDR is the base address of the thread's dtv array.  LM_ADDR is
+   the address of the link_map structure for the associated object
+   file.  OFFSET is the offset of the variable in the object file's
+   thread-local variable block.  */
+
+extern CORE_ADDR fbsd_get_thread_local_address (struct gdbarch *gdbarch,
+						CORE_ADDR dtv_addr,
+						CORE_ADDR lm_addr,
+						CORE_ADDR offset);
+
+ #endif /* fbsd-tdep.h */
--- a/devel/gdb/files/commit-b0f87ed032
+++ b/devel/gdb/files/commit-b0f87ed032
@ -0,0 +1,60 @@
+commit b0f87ed032bb68a9965de81cbf9fd676a83b9174
+Author: John Baldwin <jhb@FreeBSD.org>
+Date:   Tue Mar 12 13:39:02 2019 -0700
+
+    Support TLS variables on FreeBSD/riscv.
+    
+    Derive the pointer to the DTV array from the tp register.
+    
+    gdb/ChangeLog:
+    
+            * riscv-fbsd-tdep.c (riscv_fbsd_get_thread_local_address): New.
+            (riscv_fbsd_init_abi): Install gdbarch
+            "fetch_tls_load_module_address" and "get_thread_local_address"
+            methods.
+
+diff --git gdb/riscv-fbsd-tdep.c gdb/riscv-fbsd-tdep.c
+index 97ad28f59a..3125a2285e 100644
+--- gdb/riscv-fbsd-tdep.c
+++ gdb/riscv-fbsd-tdep.c
+@@ -174,6 +174,28 @@ static const struct tramp_frame riscv_fbsd_sigframe =
+   riscv_fbsd_sigframe_init
+ };
+ 
+/* Implement the "get_thread_local_address" gdbarch method.  */
+
+static CORE_ADDR
+riscv_fbsd_get_thread_local_address (struct gdbarch *gdbarch, ptid_t ptid,
+				     CORE_ADDR lm_addr, CORE_ADDR offset)
+{
+  struct regcache *regcache;
+
+  regcache = get_thread_arch_regcache (ptid, gdbarch);
+
+  target_fetch_registers (regcache, RISCV_TP_REGNUM);
+
+  ULONGEST tp;
+  if (regcache->cooked_read (RISCV_TP_REGNUM, &tp) != REG_VALID)
+    error (_("Unable to fetch %%tp"));
+
+  /* %tp points to the end of the TCB which contains two pointers.
+      The first pointer in the TCB points to the DTV array.  */
+  CORE_ADDR dtv_addr = tp - (gdbarch_ptr_bit (gdbarch) / 8) * 2;
+  return fbsd_get_thread_local_address (gdbarch, dtv_addr, lm_addr, offset);
+}
+
+ /* Implement the 'init_osabi' method of struct gdb_osabi_handler.  */
+ 
+ static void
+@@ -193,6 +215,11 @@ riscv_fbsd_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
+ 
+   set_gdbarch_iterate_over_regset_sections
+     (gdbarch, riscv_fbsd_iterate_over_regset_sections);
+
+  set_gdbarch_fetch_tls_load_module_address (gdbarch,
+					     svr4_fetch_objfile_link_map);
+  set_gdbarch_get_thread_local_address (gdbarch,
+					riscv_fbsd_get_thread_local_address);
+ }
+ 
+ void
--- a/devel/gdb/files/commit-cd250a1898
+++ b/devel/gdb/files/commit-cd250a1898
@ -0,0 +1,30 @@
+commit cd250a1898bb6fdb41f4a1063dbcfac04affcd11
+Author: John Baldwin <jhb@FreeBSD.org>
+Date:   Tue Mar 12 13:39:02 2019 -0700
+
+    Update comment for target::get_thread_local_address.
+    
+    There isn't an 'objfile' parameter, instead 'load_module_addr' is used
+    to indicate the executable or shared library.  Also, the function
+    throws errors rather than returning error values.
+    
+    gdb/ChangeLog:
+    
+            * target.h (target::get_thread_local_address): Update comment.
+
+diff --git gdb/target.h gdb/target.h
+index c95151a404..5fe6aa74b0 100644
+--- gdb/target.h
+++ gdb/target.h
+@@ -718,9 +718,9 @@ struct target_ops
+       TARGET_DEFAULT_NORETURN (tcomplain ());
+     /* Return the thread-local address at OFFSET in the
+        thread-local storage for the thread PTID and the shared library
+-       or executable file given by OBJFILE.  If that block of
+       or executable file given by LOAD_MODULE_ADDR.  If that block of
+        thread-local storage hasn't been allocated yet, this function
+-       may return an error.  LOAD_MODULE_ADDR may be zero for statically
+       may throw an error.  LOAD_MODULE_ADDR may be zero for statically
+        linked multithreaded inferiors.  */
+     virtual CORE_ADDR get_thread_local_address (ptid_t ptid,
+ 						CORE_ADDR load_module_addr,
--- a/devel/gdb/files/commit-ce25aa57a3
+++ b/devel/gdb/files/commit-ce25aa57a3
@ -0,0 +1,64 @@
+commit ce25aa57a3cdd028be5868423e6e55506ccd1053
+Author: John Baldwin <jhb@FreeBSD.org>
+Date:   Tue Mar 12 13:39:02 2019 -0700
+
+    Support TLS variables on FreeBSD/i386.
+    
+    Derive the pointer to the DTV array from the gs_base register.  As
+    with FreeBSD/amd64, gs_base is currently only available via the native
+    target.
+    
+    gdb/ChangeLog:
+    
+            * i386-fbsd-tdep.c (i386fbsd_get_thread_local_address): New.
+            (i386fbsd_init_abi): Install gdbarch
+            "fetch_tls_load_module_address" and "get_thread_local_address"
+            methods.
+
+diff --git gdb/i386-fbsd-tdep.c gdb/i386-fbsd-tdep.c
+index ac57e7383d..f274847174 100644
+--- gdb/i386-fbsd-tdep.c
+++ gdb/i386-fbsd-tdep.c
+@@ -320,6 +320,30 @@ i386fbsd_iterate_over_regset_sections (struct gdbarch *gdbarch,
+ 	"XSAVE extended state", cb_data);
+ }
+ 
+/* Implement the get_thread_local_address gdbarch method.  */
+
+static CORE_ADDR
+i386fbsd_get_thread_local_address (struct gdbarch *gdbarch, ptid_t ptid,
+				   CORE_ADDR lm_addr, CORE_ADDR offset)
+{
+  struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
+  struct regcache *regcache;
+
+  if (tdep->fsbase_regnum == -1)
+    error (_("Unable to fetch %%gsbase"));
+
+  regcache = get_thread_arch_regcache (ptid, gdbarch);
+
+  target_fetch_registers (regcache, tdep->fsbase_regnum + 1);
+
+  ULONGEST gsbase;
+  if (regcache->cooked_read (tdep->fsbase_regnum + 1, &gsbase) != REG_VALID)
+    error (_("Unable to fetch %%gsbase"));
+
+  CORE_ADDR dtv_addr = gsbase + gdbarch_ptr_bit (gdbarch) / 8;
+  return fbsd_get_thread_local_address (gdbarch, dtv_addr, lm_addr, offset);
+}
+
+ static void
+ i386fbsd_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
+ {
+@@ -418,6 +442,11 @@ i386fbsd4_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
+ 
+   set_gdbarch_core_read_description (gdbarch,
+ 				     i386fbsd_core_read_description);
+
+  set_gdbarch_fetch_tls_load_module_address (gdbarch,
+					     svr4_fetch_objfile_link_map);
+  set_gdbarch_get_thread_local_address (gdbarch,
+					i386fbsd_get_thread_local_address);
+ }
+ 
+ void
--- a/devel/gdb/files/commit-dd6876c91c
+++ b/devel/gdb/files/commit-dd6876c91c
@ -0,0 +1,237 @@
+commit dd6876c91cd40cc105b1a91f418ca2c80683b314
+Author: John Baldwin <jhb@FreeBSD.org>
+Date:   Tue Mar 12 13:39:02 2019 -0700
+
+    Support fs_base and gs_base on FreeBSD/i386.
+    
+    The i386 BSD native target uses the same ptrace operations
+    (PT_[GS]ET[FG]SBASE) as the amd64 BSD native target to fetch and store
+    the registers.
+    
+    The amd64 BSD native now uses 'tdep->fsbase_regnum' instead of
+    hardcoding AMD64_FSBASE_REGNUM and AMD64_GSBASE_REGNUM to support
+    32-bit targets.  In addition, the store operations explicitly zero the
+    new register value before fetching it from the register cache to
+    ensure 32-bit values are zero-extended.
+    
+    gdb/ChangeLog:
+    
+            * amd64-bsd-nat.c (amd64bsd_fetch_inferior_registers): Use
+            tdep->fsbase_regnum instead of constants for fs_base and gs_base.
+            (amd64bsd_store_inferior_registers): Likewise.
+            * amd64-fbsd-nat.c (amd64_fbsd_nat_target::read_description):
+            Enable segment base registers.
+            * i386-bsd-nat.c (i386bsd_fetch_inferior_registers): Use
+            PT_GETFSBASE and PT_GETGSBASE.
+            (i386bsd_store_inferior_registers): Use PT_SETFSBASE and
+            PT_SETGSBASE.
+            * i386-fbsd-nat.c (i386_fbsd_nat_target::read_description): Enable
+            segment base registers.
+            * i386-fbsd-tdep.c (i386fbsd_core_read_description): Likewise.
+
+diff --git gdb/amd64-bsd-nat.c gdb/amd64-bsd-nat.c
+index a2a91abb91..35763a5b95 100644
+--- gdb/amd64-bsd-nat.c
+++ gdb/amd64-bsd-nat.c
+@@ -43,6 +43,9 @@ amd64bsd_fetch_inferior_registers (struct regcache *regcache, int regnum)
+ {
+   struct gdbarch *gdbarch = regcache->arch ();
+   pid_t pid = get_ptrace_pid (regcache->ptid ());
+#if defined(PT_GETFSBASE) || defined(PT_GETGSBASE)
+  const struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
+#endif
+ 
+   if (regnum == -1 || amd64_native_gregset_supplies_p (gdbarch, regnum))
+     {
+@@ -57,27 +60,27 @@ amd64bsd_fetch_inferior_registers (struct regcache *regcache, int regnum)
+     }
+ 
+ #ifdef PT_GETFSBASE
+-  if (regnum == -1 || regnum == AMD64_FSBASE_REGNUM)
+  if (regnum == -1 || regnum == tdep->fsbase_regnum)
+     {
+       register_t base;
+ 
+       if (ptrace (PT_GETFSBASE, pid, (PTRACE_TYPE_ARG3) &base, 0) == -1)
+ 	perror_with_name (_("Couldn't get segment register fs_base"));
+ 
+-      regcache->raw_supply (AMD64_FSBASE_REGNUM, &base);
+      regcache->raw_supply (tdep->fsbase_regnum, &base);
+       if (regnum != -1)
+ 	return;
+     }
+ #endif
+ #ifdef PT_GETGSBASE
+-  if (regnum == -1 || regnum == AMD64_GSBASE_REGNUM)
+  if (regnum == -1 || regnum == tdep->fsbase_regnum + 1)
+     {
+       register_t base;
+ 
+       if (ptrace (PT_GETGSBASE, pid, (PTRACE_TYPE_ARG3) &base, 0) == -1)
+ 	perror_with_name (_("Couldn't get segment register gs_base"));
+ 
+-      regcache->raw_supply (AMD64_GSBASE_REGNUM, &base);
+      regcache->raw_supply (tdep->fsbase_regnum + 1, &base);
+       if (regnum != -1)
+ 	return;
+     }
+@@ -116,6 +119,9 @@ amd64bsd_store_inferior_registers (struct regcache *regcache, int regnum)
+ {
+   struct gdbarch *gdbarch = regcache->arch ();
+   pid_t pid = get_ptrace_pid (regcache->ptid ());
+#if defined(PT_SETFSBASE) || defined(PT_SETGSBASE)
+  const struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
+#endif
+ 
+   if (regnum == -1 || amd64_native_gregset_supplies_p (gdbarch, regnum))
+     {
+@@ -134,11 +140,13 @@ amd64bsd_store_inferior_registers (struct regcache *regcache, int regnum)
+     }
+ 
+ #ifdef PT_SETFSBASE
+-  if (regnum == -1 || regnum == AMD64_FSBASE_REGNUM)
+  if (regnum == -1 || regnum == tdep->fsbase_regnum)
+     {
+       register_t base;
+ 
+-      regcache->raw_collect (AMD64_FSBASE_REGNUM, &base);
+      /* Clear the full base value to support 32-bit targets.  */
+      base = 0;
+      regcache->raw_collect (tdep->fsbase_regnum, &base);
+ 
+       if (ptrace (PT_SETFSBASE, pid, (PTRACE_TYPE_ARG3) &base, 0) == -1)
+ 	perror_with_name (_("Couldn't write segment register fs_base"));
+@@ -147,11 +155,13 @@ amd64bsd_store_inferior_registers (struct regcache *regcache, int regnum)
+     }
+ #endif
+ #ifdef PT_SETGSBASE
+-  if (regnum == -1 || regnum == AMD64_GSBASE_REGNUM)
+  if (regnum == -1 || regnum == tdep->fsbase_regnum + 1)
+     {
+       register_t base;
+ 
+-      regcache->raw_collect (AMD64_GSBASE_REGNUM, &base);
+      /* Clear the full base value to support 32-bit targets.  */
+      base = 0;
+      regcache->raw_collect (tdep->fsbase_regnum + 1, &base);
+ 
+       if (ptrace (PT_SETGSBASE, pid, (PTRACE_TYPE_ARG3) &base, 0) == -1)
+ 	perror_with_name (_("Couldn't write segment register gs_base"));
+diff --git gdb/amd64-fbsd-nat.c gdb/amd64-fbsd-nat.c
+index 9fff763dd3..cc676d3214 100644
+--- gdb/amd64-fbsd-nat.c
+++ gdb/amd64-fbsd-nat.c
+@@ -190,13 +190,13 @@ amd64_fbsd_nat_target::read_description ()
+       if (is64)
+ 	return amd64_target_description (xcr0, true);
+       else
+-	return i386_target_description (xcr0, false);
+	return i386_target_description (xcr0, true);
+     }
+ #endif
+   if (is64)
+     return amd64_target_description (X86_XSTATE_SSE_MASK, true);
+   else
+-    return i386_target_description (X86_XSTATE_SSE_MASK, false);
+    return i386_target_description (X86_XSTATE_SSE_MASK, true);
+ }
+ 
+ #if defined(HAVE_PT_GETDBREGS) && defined(USE_SIGTRAP_SIGINFO)
+diff --git gdb/i386-bsd-nat.c gdb/i386-bsd-nat.c
+index 009a8dc1b2..a10b496096 100644
+--- gdb/i386-bsd-nat.c
+++ gdb/i386-bsd-nat.c
+@@ -144,6 +144,33 @@ i386bsd_fetch_inferior_registers (struct regcache *regcache, int regnum)
+ 	return;
+     }
+ 
+#ifdef PT_GETFSBASE
+  if (regnum == -1 || regnum == I386_FSBASE_REGNUM)
+    {
+      register_t base;
+
+      if (ptrace (PT_GETFSBASE, pid, (PTRACE_TYPE_ARG3) &base, 0) == -1)
+	perror_with_name (_("Couldn't get segment register fs_base"));
+
+      regcache->raw_supply (I386_FSBASE_REGNUM, &base);
+      if (regnum != -1)
+	return;
+    }
+#endif
+#ifdef PT_GETGSBASE
+  if (regnum == -1 || regnum == I386_GSBASE_REGNUM)
+    {
+      register_t base;
+
+      if (ptrace (PT_GETGSBASE, pid, (PTRACE_TYPE_ARG3) &base, 0) == -1)
+	perror_with_name (_("Couldn't get segment register gs_base"));
+
+      regcache->raw_supply (I386_GSBASE_REGNUM, &base);
+      if (regnum != -1)
+	return;
+    }
+#endif
+
+   if (regnum == -1 || regnum >= I386_ST0_REGNUM)
+     {
+       struct fpreg fpregs;
+@@ -211,6 +238,33 @@ i386bsd_store_inferior_registers (struct regcache *regcache, int regnum)
+ 	return;
+     }
+ 
+#ifdef PT_SETFSBASE
+  if (regnum == -1 || regnum == I386_FSBASE_REGNUM)
+    {
+      register_t base;
+
+      regcache->raw_collect (I386_FSBASE_REGNUM, &base);
+
+      if (ptrace (PT_SETFSBASE, pid, (PTRACE_TYPE_ARG3) &base, 0) == -1)
+	perror_with_name (_("Couldn't write segment register fs_base"));
+      if (regnum != -1)
+	return;
+    }
+#endif
+#ifdef PT_SETGSBASE
+  if (regnum == -1 || regnum == I386_GSBASE_REGNUM)
+    {
+      register_t base;
+
+      regcache->raw_collect (I386_GSBASE_REGNUM, &base);
+
+      if (ptrace (PT_SETGSBASE, pid, (PTRACE_TYPE_ARG3) &base, 0) == -1)
+	perror_with_name (_("Couldn't write segment register gs_base"));
+      if (regnum != -1)
+	return;
+    }
+#endif
+
+   if (regnum == -1 || regnum >= I386_ST0_REGNUM)
+     {
+       struct fpreg fpregs;
+diff --git gdb/i386-fbsd-nat.c gdb/i386-fbsd-nat.c
+index 7106e90801..be5d4c67be 100644
+--- gdb/i386-fbsd-nat.c
+++ gdb/i386-fbsd-nat.c
+@@ -160,7 +160,7 @@ i386_fbsd_nat_target::read_description ()
+   if (x86bsd_xsave_len == 0)
+     xcr0 = X86_XSTATE_SSE_MASK;
+ 
+-  return i386_target_description (xcr0, false);
+  return i386_target_description (xcr0, true);
+ }
+ #endif
+ 
+diff --git gdb/i386-fbsd-tdep.c gdb/i386-fbsd-tdep.c
+index 2f28bad728..ac57e7383d 100644
+--- gdb/i386-fbsd-tdep.c
+++ gdb/i386-fbsd-tdep.c
+@@ -267,7 +267,7 @@ i386fbsd_core_read_description (struct gdbarch *gdbarch,
+ 				struct target_ops *target,
+ 				bfd *abfd)
+ {
+-  return i386_target_description (i386fbsd_core_read_xcr0 (abfd), false);
+  return i386_target_description (i386fbsd_core_read_xcr0 (abfd), true);
+ }
+ 
+ /* Similar to i386_supply_fpregset, but use XSAVE extended state.  */
--- a/devel/gdb/files/commit-df22c1e5d5
+++ b/devel/gdb/files/commit-df22c1e5d5
@ -0,0 +1,36 @@
+commit df22c1e5d53c38f38bce6072bb46de240f9e0e2b
+Author: John Baldwin <jhb@FreeBSD.org>
+Date:   Tue Mar 12 13:39:02 2019 -0700
+
+    Handle an edge case for minisym TLS variable lookups.
+    
+    If a TLS variable is provided by a minisym from a separate debug file,
+    the separate debug file is passed to
+    gdbarch_fetch_tls_load_module_address.  However, the object files
+    stored in the shared object list are the original object files, not
+    the separate debug object files.  In this case,
+    svr4_fetch_objfile_link_map was failing to find the link map entry
+    since the debug object file is not in its internal list, only the
+    original object file.
+    
+    gdb/ChangeLog:
+    
+            * solib-svr4.c (svr4_fetch_objfile_link_map): Look for
+            objfile->separate_debug_objfile_backlink if not NULL.
+
+diff --git gdb/solib-svr4.c gdb/solib-svr4.c
+index 84693c1766..14a471b6dc 100644
+--- gdb/solib-svr4.c
+++ gdb/solib-svr4.c
+@@ -1551,6 +1551,11 @@ svr4_fetch_objfile_link_map (struct objfile *objfile)
+   if (objfile == symfile_objfile)
+     return info->main_lm_addr;
+ 
+  /* If OBJFILE is a separate debug object file, look for the
+     original object file.  */
+  if (objfile->separate_debug_objfile_backlink != NULL)
+    objfile = objfile->separate_debug_objfile_backlink;
+
+   /* The other link map addresses may be found by examining the list
+      of shared libraries.  */
+   for (so = master_so_list (); so; so = so->next)
--- a/devel/gdb/files/commit-ef0bd2046f
+++ b/devel/gdb/files/commit-ef0bd2046f
@ -0,0 +1,165 @@
+commit ef0bd2046f58fac69577892c2d3b44b20d027476
+Author: John Baldwin <jhb@FreeBSD.org>
+Date:   Tue Mar 12 13:39:02 2019 -0700
+
+    Add a more general version of lookup_struct_elt_type.
+    
+    lookup_struct_elt is a new function which returns a tuple of
+    information about a component of a structure or union.  The returned
+    tuple contains a pointer to the struct field object for the component
+    as well as a bit offset of that field within the structure.  If the
+    field names a field in an anonymous substructure, the offset is the
+    "global" offset relative to the original structure type.  If noerr is
+    set, then the returned tuple will set the field pointer to NULL to
+    indicate a missing component rather than throwing an error.
+    
+    lookup_struct_elt_type is now reimplemented in terms of this new
+    function.  It simply returns the type of the returned field.
+    
+    gdb/ChangeLog:
+    
+            * gdbtypes.c (lookup_struct_elt): New function.
+            (lookup_struct_elt_type): Reimplement via lookup_struct_elt.
+            * gdbtypes.h (struct struct_elt): New type.
+            (lookup_struct_elt): New prototype.
+
+diff --git gdb/gdbtypes.c gdb/gdbtypes.c
+index 5924b15520..db470dafac 100644
+--- gdb/gdbtypes.c
+++ gdb/gdbtypes.c
+@@ -1644,19 +1644,10 @@ lookup_template_type (char *name, struct type *type,
+   return (SYMBOL_TYPE (sym));
+ }
+ 
+-/* Given a type TYPE, lookup the type of the component named NAME.
+/* See gdbtypes.h.  */
+ 
+-   TYPE can be either a struct or union, or a pointer or reference to
+-   a struct or union.  If it is a pointer or reference, its target
+-   type is automatically used.  Thus '.' and '->' are interchangable,
+-   as specified for the definitions of the expression element types
+-   STRUCTOP_STRUCT and STRUCTOP_PTR.
+-
+-   If NOERR is nonzero, return NULL if there is no component named
+-   NAME.  */
+-
+-struct type *
+-lookup_struct_elt_type (struct type *type, const char *name, int noerr)
+struct_elt
+lookup_struct_elt (struct type *type, const char *name, int noerr)
+ {
+   int i;
+ 
+@@ -1683,39 +1674,47 @@ lookup_struct_elt_type (struct type *type, const char *name, int noerr)
+ 
+       if (t_field_name && (strcmp_iw (t_field_name, name) == 0))
+ 	{
+-	  return TYPE_FIELD_TYPE (type, i);
+	  return {&TYPE_FIELD (type, i), TYPE_FIELD_BITPOS (type, i)};
+ 	}
+      else if (!t_field_name || *t_field_name == '\0')
+ 	{
+-	  struct type *subtype 
+-	    = lookup_struct_elt_type (TYPE_FIELD_TYPE (type, i), name, 1);
+-
+-	  if (subtype != NULL)
+-	    return subtype;
+	  struct_elt elt
+	    = lookup_struct_elt (TYPE_FIELD_TYPE (type, i), name, 1);
+	  if (elt.field != NULL)
+	    {
+	      elt.offset += TYPE_FIELD_BITPOS (type, i);
+	      return elt;
+	    }
+ 	}
+     }
+ 
+   /* OK, it's not in this class.  Recursively check the baseclasses.  */
+   for (i = TYPE_N_BASECLASSES (type) - 1; i >= 0; i--)
+     {
+-      struct type *t;
+-
+-      t = lookup_struct_elt_type (TYPE_BASECLASS (type, i), name, 1);
+-      if (t != NULL)
+-	{
+-	  return t;
+-	}
+      struct_elt elt = lookup_struct_elt (TYPE_BASECLASS (type, i), name, 1);
+      if (elt.field != NULL)
+	return elt;
+     }
+ 
+   if (noerr)
+-    {
+-      return NULL;
+-    }
+    return {nullptr, 0};
+ 
+   std::string type_name = type_to_string (type);
+   error (_("Type %s has no component named %s."), type_name.c_str (), name);
+ }
+ 
+/* See gdbtypes.h.  */
+
+struct type *
+lookup_struct_elt_type (struct type *type, const char *name, int noerr)
+{
+  struct_elt elt = lookup_struct_elt (type, name, noerr);
+  if (elt.field != NULL)
+    return FIELD_TYPE (*elt.field);
+  else
+    return NULL;
+}
+
+ /* Store in *MAX the largest number representable by unsigned integer type
+    TYPE.  */
+ 
+diff --git gdb/gdbtypes.h gdb/gdbtypes.h
+index a6d4f64e9b..66051cf02c 100644
+--- gdb/gdbtypes.h
+++ gdb/gdbtypes.h
+@@ -1873,6 +1873,44 @@ extern struct type *allocate_stub_method (struct type *);
+ 
+ extern const char *type_name_or_error (struct type *type);
+ 
+struct struct_elt
+{
+  /* The field of the element, or NULL if no element was found.  */
+  struct field *field;
+
+  /* The bit offset of the element in the parent structure.  */
+  LONGEST offset;
+};
+
+/* Given a type TYPE, lookup the field and offset of the component named
+   NAME.
+
+   TYPE can be either a struct or union, or a pointer or reference to
+   a struct or union.  If it is a pointer or reference, its target
+   type is automatically used.  Thus '.' and '->' are interchangable,
+   as specified for the definitions of the expression element types
+   STRUCTOP_STRUCT and STRUCTOP_PTR.
+
+   If NOERR is nonzero, the returned structure will have field set to
+   NULL if there is no component named NAME.
+
+   If the component NAME is a field in an anonymous substructure of
+   TYPE, the returned offset is a "global" offset relative to TYPE
+   rather than an offset within the substructure.  */
+
+extern struct_elt lookup_struct_elt (struct type *, const char *, int);
+
+/* Given a type TYPE, lookup the type of the component named NAME.
+
+   TYPE can be either a struct or union, or a pointer or reference to
+   a struct or union.  If it is a pointer or reference, its target
+   type is automatically used.  Thus '.' and '->' are interchangable,
+   as specified for the definitions of the expression element types
+   STRUCTOP_STRUCT and STRUCTOP_PTR.
+
+   If NOERR is nonzero, return NULL if there is no component named
+   NAME.  */
+
+ extern struct type *lookup_struct_elt_type (struct type *, const char *, int);
+ 
+ extern struct type *make_pointer_type (struct type *, struct type **);
--- a/devel/gdb/files/commit-f5424cfa7e
+++ b/devel/gdb/files/commit-f5424cfa7e
@ -0,0 +1,63 @@
+commit f5424cfa7e9337a6cb02a1f83c9feea0995c5350
+Author: John Baldwin <jhb@FreeBSD.org>
+Date:   Tue Mar 12 13:39:02 2019 -0700
+
+    Support TLS variables on FreeBSD/amd64.
+    
+    Use the fs_base register to fetch the address of a thread's tcb and
+    calculate the address of the DTV array.  This value is then passed to
+    fbsd_get_thread_local_address to compute the final variable address.
+    
+    Note that fs_base is currently only available via the native target as
+    core dumps on FreeBSD do not store the value of fs_base.
+    
+    gdb/ChangeLog:
+    
+            * amd64-fbsd-tdep.c (amd64fbsd_get_thread_local_address): New.
+            (amd64fbsd_init_abi): Install gdbarch
+            "fetch_tls_load_module_address" and "get_thread_local_address"
+            methods.
+
+diff --git gdb/amd64-fbsd-tdep.c gdb/amd64-fbsd-tdep.c
+index 403e65022d..7e2e9edf21 100644
+--- gdb/amd64-fbsd-tdep.c
+++ gdb/amd64-fbsd-tdep.c
+@@ -204,6 +204,26 @@ amd64fbsd_iterate_over_regset_sections (struct gdbarch *gdbarch,
+       &amd64fbsd_xstateregset, "XSAVE extended state", cb_data);
+ }
+ 
+/* Implement the get_thread_local_address gdbarch method.  */
+
+static CORE_ADDR
+amd64fbsd_get_thread_local_address (struct gdbarch *gdbarch, ptid_t ptid,
+				    CORE_ADDR lm_addr, CORE_ADDR offset)
+{
+  struct regcache *regcache;
+
+  regcache = get_thread_arch_regcache (ptid, gdbarch);
+
+  target_fetch_registers (regcache, AMD64_FSBASE_REGNUM);
+
+  ULONGEST fsbase;
+  if (regcache->cooked_read (AMD64_FSBASE_REGNUM, &fsbase) != REG_VALID)
+    error (_("Unable to fetch %%fsbase"));
+
+  CORE_ADDR dtv_addr = fsbase + gdbarch_ptr_bit (gdbarch) / 8;
+  return fbsd_get_thread_local_address (gdbarch, dtv_addr, lm_addr, offset);
+}
+
+ static void
+ amd64fbsd_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
+ {
+@@ -241,6 +261,11 @@ amd64fbsd_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
+   /* FreeBSD uses SVR4-style shared libraries.  */
+   set_solib_svr4_fetch_link_map_offsets
+     (gdbarch, svr4_lp64_fetch_link_map_offsets);
+
+  set_gdbarch_fetch_tls_load_module_address (gdbarch,
+					     svr4_fetch_objfile_link_map);
+  set_gdbarch_get_thread_local_address (gdbarch,
+					amd64fbsd_get_thread_local_address);
+ }
+ 
+ void
--- a/devel/gdb/files/extrapatch-guile22
+++ b/devel/gdb/files/extrapatch-guile22
@ -175,7 +175,7 @@
 
 /* Support for connecting Guile's stdio ports to GDB's stdio ports.  */
 
-@@ -218,6 +262,72 @@ ioscm_input_waiting (SCM port)
+@@ -218,6 +262,73 @@ ioscm_input_waiting (SCM port)
   }
 }
 
@ -228,17 +228,18 @@
 +      scm_syserror("ioscm_write");
 +    }
 +
-+  try
+  TRY
 +    {
 +      if (scm_is_eq (port, error_port_scm))
 +	fputsn_filtered (ptr, count, gdb_stderr);
 +      else
 +	fputsn_filtered (ptr, count, gdb_stdout);
 +    }
-+  catch (gdbscm_gdb_exception &except)
+  CATCH (except, RETURN_MASK_ALL)
 +    {
 +      GDBSCM_HANDLE_GDB_EXCEPTION (except);
 +    }
+  END_CATCH
 +
 +  return count;
 +}
--- a/devel/gdb/files/extrapatch-kgdb
+++ b/devel/gdb/files/extrapatch-kgdb
@ -1,8 +1,18 @@
 diff --git gdb/Makefile.in gdb/Makefile.in
-index c3e074b21f..8d026a98cb 100644
+index 5614cc3386..b9acc63c3f 100644
 --- gdb/Makefile.in
 +++ gdb/Makefile.in
-@@ -648,6 +648,7 @@ TARGET_OBS = @TARGET_OBS@
+@@ -230,7 +230,8 @@ INCGNU = -I$(srcdir)/gnulib/import -I$(GNULIB_BUILDDIR)/import
+ 
+ # Generated headers in the gnulib directory.  These must be listed
+ # so that they are generated before other files are compiled.
+-GNULIB_H = $(GNULIB_BUILDDIR)/import/string.h @GNULIB_STDINT_H@
+GNULIB_H = $(GNULIB_BUILDDIR)/import/string.h \
+	$(GNULIB_BUILDDIR)/import/alloca.h @GNULIB_STDINT_H@
+ 
+ #
+ # CLI sub directory definitons
+@@ -632,6 +633,7 @@ TARGET_OBS = @TARGET_OBS@
 # All target-dependent objects files that require 64-bit CORE_ADDR
 # (used with --enable-targets=all --enable-64-bit-bfd).
 ALL_64_TARGET_OBS = \
@ -10,7 +20,7 @@ index c3e074b21f..8d026a98cb 100644
 	aarch64-fbsd-tdep.o \
 	aarch64-linux-tdep.o \
 	aarch64-newlib-tdep.o \
-@@ -662,6 +663,7 @@ ALL_64_TARGET_OBS = \
+@@ -646,6 +648,7 @@ ALL_64_TARGET_OBS = \
 	amd64-darwin-tdep.o \
 	amd64-dicos-tdep.o \
 	amd64-fbsd-tdep.o \
@ -18,7 +28,7 @@ index c3e074b21f..8d026a98cb 100644
 	amd64-linux-tdep.o \
 	amd64-nbsd-tdep.o \
 	amd64-obsd-tdep.o \
-@@ -676,6 +678,7 @@ ALL_64_TARGET_OBS = \
+@@ -660,6 +663,7 @@ ALL_64_TARGET_OBS = \
 	ia64-vms-tdep.o \
 	mips64-obsd-tdep.o \
 	sparc64-fbsd-tdep.o \
@ -26,7 +36,7 @@ index c3e074b21f..8d026a98cb 100644
 	sparc64-linux-tdep.o \
 	sparc64-nbsd-tdep.o \
 	sparc64-obsd-tdep.o \
-@@ -694,6 +697,7 @@ ALL_TARGET_OBS = \
+@@ -676,6 +680,7 @@ ALL_TARGET_OBS = \
 	arch/ppc-linux-common.o \
 	arch/riscv.o \
 	arm-bsd-tdep.o \
@ -34,7 +44,7 @@ index c3e074b21f..8d026a98cb 100644
 	arm-fbsd-tdep.o \
 	arm-linux-tdep.o \
 	arm-nbsd-tdep.o \
-@@ -711,6 +715,8 @@ ALL_TARGET_OBS = \
+@@ -693,6 +698,8 @@ ALL_TARGET_OBS = \
 	csky-linux-tdep.o \
 	csky-tdep.o \
 	dicos-tdep.o \
@ -43,7 +53,7 @@ index c3e074b21f..8d026a98cb 100644
 	fbsd-tdep.o \
 	frv-linux-tdep.o \
 	frv-tdep.o \
-@@ -727,6 +733,7 @@ ALL_TARGET_OBS = \
+@@ -709,6 +716,7 @@ ALL_TARGET_OBS = \
 	i386-darwin-tdep.o \
 	i386-dicos-tdep.o \
 	i386-fbsd-tdep.o \
@ -51,7 +61,7 @@ index c3e074b21f..8d026a98cb 100644
 	i386-gnu-tdep.o \
 	i386-go32-tdep.o \
 	i386-linux-tdep.o \
-@@ -750,6 +757,7 @@ ALL_TARGET_OBS = \
+@@ -732,6 +740,7 @@ ALL_TARGET_OBS = \
 	mep-tdep.o \
 	microblaze-linux-tdep.o \
 	microblaze-tdep.o \
@ -59,7 +69,7 @@ index c3e074b21f..8d026a98cb 100644
 	mips-fbsd-tdep.o \
 	mips-linux-tdep.o \
 	mips-nbsd-tdep.o \
-@@ -768,6 +776,7 @@ ALL_TARGET_OBS = \
+@@ -750,6 +759,7 @@ ALL_TARGET_OBS = \
 	or1k-linux-tdep.o \
 	or1k-tdep.o \
 	ppc-fbsd-tdep.o \
@ -67,7 +77,7 @@ index c3e074b21f..8d026a98cb 100644
 	ppc-linux-tdep.o \
 	ppc-nbsd-tdep.o \
 	ppc-obsd-tdep.o \
-@@ -775,6 +784,7 @@ ALL_TARGET_OBS = \
+@@ -757,6 +767,7 @@ ALL_TARGET_OBS = \
 	ppc-sysv-tdep.o \
 	ppc64-tdep.o \
 	ravenscar-thread.o \
@ -75,7 +85,7 @@ index c3e074b21f..8d026a98cb 100644
 	riscv-fbsd-tdep.o \
 	riscv-linux-tdep.o \
 	riscv-tdep.o \
-@@ -1648,7 +1658,7 @@ generated_files = \
+@@ -1629,7 +1640,7 @@ generated_files = \
 # Flags needed to compile Python code
 PYTHON_CFLAGS = @PYTHON_CFLAGS@
 
@ -84,7 +94,7 @@ index c3e074b21f..8d026a98cb 100644
 	@$(MAKE) $(FLAGS_TO_PASS) DO=all "DODIRS=`echo $(SUBDIRS) | sed 's/testsuite//'`" subdir_do
 
 # Rule for compiling .c files in the top-level gdb directory.
-@@ -1913,6 +1923,12 @@ ifneq ($(CODESIGN_CERT),)
+@@ -1894,6 +1905,12 @@ ifneq ($(CODESIGN_CERT),)
 	$(ECHO_SIGN) $(CODESIGN) -s $(CODESIGN_CERT) gdb$(EXEEXT)
 endif
 
@ -95,9 +105,9 @@ index c3e074b21f..8d026a98cb 100644
 +		$(TDEPLIBS) $(TUI_LIBRARY) $(CLIBS) $(LOADLIBES)
 +
 # Convenience rule to handle recursion.
- .PHONY: all-data-directory
- all-data-directory: data-directory/Makefile
-@@ -1953,6 +1969,7 @@ clean mostlyclean: $(CONFIG_CLEAN)
+ $(LIBGNU) $(GNULIB_H): all-lib
+ all-lib: $(GNULIB_BUILDDIR)/Makefile
+@@ -1940,6 +1957,7 @@ clean mostlyclean: $(CONFIG_CLEAN)
 	rm -f init.c stamp-init version.c stamp-version
 	rm -f gdb$(EXEEXT) core make.log
 	rm -f gdb[0-9]$(EXEEXT)
@ -105,15 +115,15 @@ index c3e074b21f..8d026a98cb 100644
 	rm -f test-cp-name-parser$(EXEEXT)
 	rm -f xml-builtin.c stamp-xml
 	rm -f $(DEPDIR)/*
-@@ -2152,6 +2169,7 @@ MAKEOVERRIDES =
+@@ -2154,6 +2172,7 @@ force_update:
+ MAKEOVERRIDES =
 
 ALLDEPFILES = \
- 	aarch32-tdep.c \
 +	aarch64-fbsd-kern.c \
 	aarch64-fbsd-nat.c \
 	aarch64-fbsd-tdep.c \
 	aarch64-linux-nat.c \
-@@ -2171,6 +2189,7 @@ ALLDEPFILES = \
+@@ -2173,6 +2192,7 @@ ALLDEPFILES = \
 	amd64-bsd-nat.c \
 	amd64-darwin-tdep.c \
 	amd64-dicos-tdep.c \
@ -121,7 +131,7 @@ index c3e074b21f..8d026a98cb 100644
 	amd64-fbsd-nat.c \
 	amd64-fbsd-tdep.c \
 	amd64-linux-nat.c \
-@@ -2185,6 +2204,7 @@ ALLDEPFILES = \
+@@ -2187,6 +2207,7 @@ ALLDEPFILES = \
 	arc-tdep.c \
 	arm.c \
 	arm-bsd-tdep.c \
@ -129,7 +139,7 @@ index c3e074b21f..8d026a98cb 100644
 	arm-fbsd-nat.c \
 	arm-fbsd-tdep.c \
 	arm-get-next-pcs.c \
-@@ -2205,6 +2225,9 @@ ALLDEPFILES = \
+@@ -2207,6 +2228,9 @@ ALLDEPFILES = \
 	csky-tdep.c \
 	darwin-nat.c \
 	dicos-tdep.c \
@ -139,7 +149,7 @@ index c3e074b21f..8d026a98cb 100644
 	fbsd-nat.c \
 	fbsd-tdep.c \
 	fork-child.c \
-@@ -2226,6 +2249,7 @@ ALLDEPFILES = \
+@@ -2228,6 +2252,7 @@ ALLDEPFILES = \
 	i386-darwin-nat.c \
 	i386-darwin-tdep.c \
 	i386-dicos-tdep.c \
@ -147,7 +157,7 @@ index c3e074b21f..8d026a98cb 100644
 	i386-fbsd-nat.c \
 	i386-fbsd-tdep.c \
 	i386-gnu-nat.c \
-@@ -2262,6 +2286,7 @@ ALLDEPFILES = \
+@@ -2264,6 +2289,7 @@ ALLDEPFILES = \
 	microblaze-linux-tdep.c \
 	microblaze-tdep.c \
 	mingw-hdep.c \
@ -155,7 +165,7 @@ index c3e074b21f..8d026a98cb 100644
 	mips-fbsd-nat.c \
 	mips-fbsd-tdep.c \
 	mips-linux-nat.c \
-@@ -2281,6 +2306,7 @@ ALLDEPFILES = \
+@@ -2283,6 +2309,7 @@ ALLDEPFILES = \
 	obsd-nat.c \
 	obsd-tdep.c \
 	posix-hdep.c \
@ -163,7 +173,7 @@ index c3e074b21f..8d026a98cb 100644
 	ppc-fbsd-nat.c \
 	ppc-fbsd-tdep.c \
 	ppc-linux-nat.c \
-@@ -2295,6 +2321,7 @@ ALLDEPFILES = \
+@@ -2297,6 +2324,7 @@ ALLDEPFILES = \
 	procfs.c \
 	ravenscar-thread.c \
 	remote-sim.c \
@ -171,7 +181,7 @@ index c3e074b21f..8d026a98cb 100644
 	riscv-fbsd-nat.c \
 	riscv-fbsd-tdep.c \
 	riscv-linux-nat.c \
-@@ -2330,6 +2357,7 @@ ALLDEPFILES = \
+@@ -2333,6 +2361,7 @@ ALLDEPFILES = \
 	sparc-sol2-nat.c \
 	sparc-sol2-tdep.c \
 	sparc-tdep.c \
@ -179,7 +189,7 @@ index c3e074b21f..8d026a98cb 100644
 	sparc64-fbsd-nat.c \
 	sparc64-fbsd-tdep.c \
 	sparc64-linux-nat.c \
-@@ -2588,7 +2616,7 @@ endif
+@@ -2596,7 +2625,7 @@ endif
 
 # A list of all the objects we might care about in this build, for
 # dependency tracking.
@ -189,10 +199,10 @@ index c3e074b21f..8d026a98cb 100644
 
 # All the .deps files to include.
 diff --git gdb/config.in gdb/config.in
-index cb886ba8e1..b8a937f6de 100644
+index ea907d2b56..1019e448c5 100644
 --- gdb/config.in
 +++ gdb/config.in
-@@ -218,6 +218,12 @@
+@@ -219,6 +219,12 @@
 /* Define to 1 if your system has the kinfo_getvmmap function. */
 #undef HAVE_KINFO_GETVMMAP
 
@ -206,10 +216,10 @@ index cb886ba8e1..b8a937f6de 100644
 #undef HAVE_LANGINFO_CODESET
 
 diff --git gdb/configure gdb/configure
-index b572d414ca..12e08354cc 100755
+index 854837c50a..df64effa90 100755
 --- gdb/configure
 +++ gdb/configure
-@@ -8064,6 +8064,126 @@ $as_echo "#define HAVE_KINFO_GETFILE 1" >>confdefs.h
+@@ -8107,6 +8107,126 @@ $as_echo "#define HAVE_KINFO_GETFILE 1" >>confdefs.h
 fi
 
 
@ -337,10 +347,10 @@ index b572d414ca..12e08354cc 100755
       if test "X$prefix" = "XNONE"; then
     acl_final_prefix="$ac_default_prefix"
 diff --git gdb/configure.ac gdb/configure.ac
-index ca0da7980c..39dc6a3559 100644
+index 1527585839..7ff0361e69 100644
 --- gdb/configure.ac
 +++ gdb/configure.ac
-@@ -485,6 +485,16 @@ AC_SEARCH_LIBS(kinfo_getfile, util util-freebsd,
+@@ -511,6 +511,16 @@ AC_SEARCH_LIBS(kinfo_getfile, util util-freebsd,
   [AC_DEFINE(HAVE_KINFO_GETFILE, 1,
             [Define to 1 if your system has the kinfo_getfile function. ])])
 
@ -358,7 +368,7 @@ index ca0da7980c..39dc6a3559 100644
 
 # GDB may fork/exec the iconv program to get the list of supported character
 diff --git gdb/configure.nat gdb/configure.nat
-index fb4522f579..a5059ff37d 100644
+index 64ee101d83..f32e6328e0 100644
 --- gdb/configure.nat
 +++ gdb/configure.nat
@@ -63,7 +63,8 @@ case ${gdb_host} in
@ -372,10 +382,10 @@ index fb4522f579..a5059ff37d 100644
 	LOADLIBES='-lkvm'
 	;;
 diff --git gdb/configure.tgt gdb/configure.tgt
-index caa42be1c0..45668ccaed 100644
+index 27f122ad04..5fa0d0179e 100644
 --- gdb/configure.tgt
 +++ gdb/configure.tgt
-@@ -101,7 +101,7 @@ esac
+@@ -98,7 +98,7 @@ esac
 
 case "${targ}" in
 *-*-freebsd* | *-*-kfreebsd*-gnu)
@ -384,7 +394,7 @@ index caa42be1c0..45668ccaed 100644
 *-*-netbsd* | *-*-knetbsd*-gnu)
 	os_obs="nbsd-tdep.o solib-svr4.o";;
 *-*-openbsd*)
-@@ -118,7 +118,7 @@ aarch64*-*-elf | aarch64*-*-rtems*)
+@@ -115,7 +115,7 @@ aarch64*-*-elf | aarch64*-*-rtems*)
 
 aarch64*-*-freebsd*)
 	# Target: FreeBSD/aarch64
@ -393,7 +403,7 @@ index caa42be1c0..45668ccaed 100644
 	;;
 
 aarch64*-*-linux*)
-@@ -171,7 +171,7 @@ arm*-*-linux*)
+@@ -168,7 +168,7 @@ arm*-*-linux*)
 	;;
 arm*-*-freebsd*)
 	# Target: FreeBSD/arm
@ -402,7 +412,7 @@ index caa42be1c0..45668ccaed 100644
 	;;
 arm*-*-netbsd* | arm*-*-knetbsd*-gnu)
 	# Target: NetBSD/arm
-@@ -270,7 +270,11 @@ i[34567]86-*-dicos*)
+@@ -267,7 +267,11 @@ i[34567]86-*-dicos*)
 	;;
 i[34567]86-*-freebsd* | i[34567]86-*-kfreebsd*-gnu)
 	# Target: FreeBSD/i386
@ -415,7 +425,7 @@ index caa42be1c0..45668ccaed 100644
 	;;
 i[34567]86-*-netbsd* | i[34567]86-*-knetbsd*-gnu)
 	# Target: NetBSD/i386
-@@ -424,7 +428,7 @@ mips*-*-netbsd* | mips*-*-knetbsd*-gnu)
+@@ -421,7 +425,7 @@ mips*-*-netbsd* | mips*-*-knetbsd*-gnu)
 	;;
 mips*-*-freebsd*)
 	# Target: MIPS running FreeBSD
@ -424,7 +434,7 @@ index caa42be1c0..45668ccaed 100644
 	gdb_sim=../sim/mips/libsim.a
 	;;
 mips64*-*-openbsd*)
-@@ -491,7 +495,7 @@ or1k-*-* | or1knd-*-*)
+@@ -488,7 +492,7 @@ or1k-*-* | or1knd-*-*)
 powerpc*-*-freebsd*)
 	# Target: FreeBSD/powerpc
 	gdb_target_obs="rs6000-tdep.o ppc-sysv-tdep.o ppc64-tdep.o \
@ -433,7 +443,7 @@ index caa42be1c0..45668ccaed 100644
 			ravenscar-thread.o ppc-ravenscar-thread.o"
 	;;
 
-@@ -545,7 +549,7 @@ s390*-*-linux*)
+@@ -543,7 +547,7 @@ s390*-*-linux*)
 
 riscv*-*-freebsd*)
 	# Target: FreeBSD/riscv
@ -442,7 +452,7 @@ index caa42be1c0..45668ccaed 100644
 	;;
 
 riscv*-*-linux*)
-@@ -624,6 +628,7 @@ sparc64-*-linux*)
+@@ -622,6 +626,7 @@ sparc64-*-linux*)
 sparc*-*-freebsd* | sparc*-*-kfreebsd*-gnu)
 	# Target: FreeBSD/sparc64
 	gdb_target_obs="sparc-tdep.o sparc64-tdep.o sparc64-fbsd-tdep.o \
@ -450,7 +460,7 @@ index caa42be1c0..45668ccaed 100644
 			ravenscar-thread.o sparc-ravenscar-thread.o"
 	;;
 sparc-*-netbsd* | sparc-*-knetbsd*-gnu)
-@@ -745,8 +750,8 @@ x86_64-*-linux*)
+@@ -749,8 +754,8 @@ x86_64-*-linux*)
 	;;
 x86_64-*-freebsd* | x86_64-*-kfreebsd*-gnu)
 	# Target: FreeBSD/amd64
@ -462,10 +472,10 @@ index caa42be1c0..45668ccaed 100644
 x86_64-*-mingw* | x86_64-*-cygwin*)
         # Target: MingW/amd64
 diff --git gdb/defs.h gdb/defs.h
-index 567f214b81..abbaa1f950 100644
+index a44e186907..c4bfd42073 100644
 --- gdb/defs.h
 +++ gdb/defs.h
-@@ -481,6 +481,7 @@ enum gdb_osabi
+@@ -484,6 +484,7 @@ enum gdb_osabi
   GDB_OSABI_SOLARIS,
   GDB_OSABI_LINUX,
   GDB_OSABI_FREEBSD,
@ -473,8 +483,20 @@ index 567f214b81..abbaa1f950 100644
   GDB_OSABI_NETBSD,
   GDB_OSABI_OPENBSD,
   GDB_OSABI_WINCE,
+diff --git gdb/gnulib/configure gdb/gnulib/configure
+index 340c622cb3..bf0c4dd5d9 100644
+--- gdb/gnulib/configure
+++ gdb/gnulib/configure
+@@ -18579,6 +18579,7 @@ else
+       case "$host_os" in
+                 # Guess all is fine on glibc systems.
+         *-gnu*) gl_cv_func_gettimeofday_clobber="guessing no" ;;
+        freebsd*) gl_cv_func_gettimeofday_clobber="guessing no" ;;
+                 # If we don't know, assume the worst.
+         *)      gl_cv_func_gettimeofday_clobber="guessing yes" ;;
+       esac
 diff --git gdb/osabi.c gdb/osabi.c
-index dec1bddc4c..06c514167e 100644
+index 5d4bbcdff8..a982b22624 100644
 --- gdb/osabi.c
 +++ gdb/osabi.c
@@ -66,6 +66,7 @@ static const struct osabi_names gdb_osabi_names[] =
@ -486,10 +508,10 @@ index dec1bddc4c..06c514167e 100644
   { "OpenBSD", NULL },
   { "WindowsCE", NULL },
 diff --git gdb/regcache.c gdb/regcache.c
-index 1580359cd4..50ff8d4039 100644
+index 6e3eee9663..49ca1e1535 100644
 --- gdb/regcache.c
 +++ gdb/regcache.c
-@@ -996,6 +996,22 @@ reg_buffer::raw_supply_zeroed (int regnum)
+@@ -1003,6 +1003,22 @@ reg_buffer::raw_supply_zeroed (int regnum)
   m_register_status[regnum] = REG_VALID;
 }
 
@ -509,14 +531,14 @@ index 1580359cd4..50ff8d4039 100644
 +  m_register_status[regnum] = REG_VALID;
 +}
 +
- /* See gdbsupport/common-regcache.h.  */
+ /* See common/common-regcache.h.  */
 
 void
 diff --git gdb/regcache.h gdb/regcache.h
-index e2935eea74..83654be825 100644
+index 2b703ea4a4..d06e001957 100644
 --- gdb/regcache.h
 +++ gdb/regcache.h
-@@ -226,6 +226,8 @@ public:
+@@ -224,6 +224,8 @@ public:
      only LEN, without editing the rest of the register.  */
   void raw_supply_part (int regnum, int offset, int len, const gdb_byte *in);
 
@ -525,16 +547,3 @@ index e2935eea74..83654be825 100644
   void invalidate (int regnum);
 
   virtual ~reg_buffer () = default;
-diff --git gnulib/configure gnulib/configure
-index 7c74371e8f..396467f68d 100644
--- gnulib/configure
-+++ gnulib/configure
-@@ -20267,6 +20267,8 @@ else
-       case "$host_os" in
-                 # Guess all is fine on glibc systems.
-         *-gnu*) gl_cv_func_gettimeofday_clobber="guessing no" ;;
-+                # Guess all is fine on FreeBSD.
-+        freebsd*) gl_cv_func_gettimeofday_clobber="guessing no" ;;
-                 # If we don't know, assume the worst.
-         *)      gl_cv_func_gettimeofday_clobber="guessing yes" ;;
-       esac
--- a/devel/gdb/files/kgdb/aarch64-fbsd-kern.c
+++ b/devel/gdb/files/kgdb/aarch64-fbsd-kern.c
@ -32,7 +32,6 @@

 #include "aarch64-tdep.h"
 #include "frame-unwind.h"
-#include "gdbarch.h"
 #include "gdbcore.h"
 #include "osabi.h"
 #include "regcache.h"
--- a/devel/gdb/files/kgdb/amd64fbsd-kern.c
+++ b/devel/gdb/files/kgdb/amd64fbsd-kern.c
@ -37,7 +37,7 @@ __FBSDID("$FreeBSD$");
 #include "symtab.h"
 #include "trad-frame.h"
 #include "amd64-tdep.h"
-#include "gdbsupport/x86-xstate.h"
+#include "common/x86-xstate.h"

 #ifdef __amd64__
 #include <machine/pcb.h>
--- a/devel/gdb/files/kgdb/fbsd-kld.c
+++ b/devel/gdb/files/kgdb/fbsd-kld.c
@ -242,9 +242,9 @@ adjust_section_address (struct target_section *sec, CORE_ADDR *curr_base)
 	}

 	*curr_base = align_power(*curr_base,
-	    bfd_section_alignment(asect));
+	    bfd_get_section_alignment(abfd, asect));
 	sec->addr = *curr_base;
-	sec->endaddr = sec->addr + bfd_section_size(asect);
+	sec->endaddr = sec->addr + bfd_section_size(abfd, asect);
 	*curr_base = sec->endaddr;
 }

@ -252,6 +252,7 @@ static void
 load_kld (char *path, CORE_ADDR base_addr, int from_tty)
 {
 	struct target_section *sections = NULL, *sections_end = NULL, *s;
+	struct cleanup *cleanup;
 	gdb_bfd_ref_ptr bfd;
 	CORE_ADDR curr_addr;
 	symfile_add_flags add_flags;
@ -273,6 +274,7 @@ load_kld (char *path, CORE_ADDR base_addr, int from_tty)
 	/* Build a section table from the bfd and relocate the sections. */
 	if (build_section_table (bfd.get(), &sections, &sections_end))
 		error("\"%s\": can't find file sections", path);
+	cleanup = make_cleanup(xfree, sections);
 	curr_addr = base_addr;
 	for (s = sections; s < sections_end; s++)
 		adjust_section_address(s, &curr_addr);
@ -281,7 +283,6 @@ load_kld (char *path, CORE_ADDR base_addr, int from_tty)
 	section_addr_info sap
 	    = build_section_addr_info_from_section_table (sections,
 		sections_end);
-	xfree(sections);

 	printf_unfiltered("add symbol table from file \"%s\" at\n", path);
 	for (i = 0; i < sap.size(); i++)
@ -296,6 +297,8 @@ load_kld (char *path, CORE_ADDR base_addr, int from_tty)
 		add_flags |= SYMFILE_VERBOSE;
 	symbol_file_add_from_bfd(bfd.get(), path, add_flags, &sap,
 	    OBJF_USERLOADED, NULL);
+
+	do_cleanups(cleanup);
 }

 static void
@ -381,53 +384,39 @@ kld_solib_create_inferior_hook (int from_tty)
 	 * Compute offsets of relevant members in struct linker_file
 	 * and the addresses of global variables.  Newer kernels
 	 * include constants we can use without requiring debug
-	 * symbols.
+	 * symbols.  If those aren't present, fall back to using
+	 * home-grown offsetof() equivalents.
 	 */
-	try {
+	TRY {
 		info->off_address = parse_and_eval_long("kld_off_address");
 		info->off_filename = parse_and_eval_long("kld_off_filename");
 		info->off_pathname = parse_and_eval_long("kld_off_pathname");
 		info->off_next = parse_and_eval_long("kld_off_next");
-	} catch (const gdb_exception_error &e) {
-		try {
-			struct symbol *linker_file_sym =
-			    lookup_symbol_in_language ("struct linker_file",
-				NULL, STRUCT_DOMAIN, language_c, NULL).symbol;
-			if (linker_file_sym == NULL)
-				error (_(
-			    "Unable to find struct linker_file symbol"));
-
-			info->off_address =
-			    lookup_struct_elt (SYMBOL_TYPE (linker_file_sym),
-				"address", 0).offset / 8;
-			info->off_filename =
-			    lookup_struct_elt (SYMBOL_TYPE (linker_file_sym),
-				"filename", 0).offset / 8;
-			info->off_pathname =
-			    lookup_struct_elt (SYMBOL_TYPE (linker_file_sym),
-				"pathname", 0).offset / 8;
-
-			struct type *link_type =
-			    lookup_struct_elt_type (SYMBOL_TYPE (linker_file_sym),
-				"link", 0);
-			if (link_type == NULL)
-				error (_("Unable to find link type"));
-
-			info->off_next =
-			    lookup_struct_elt (link_type, "tqe_next",
-				0).offset / 8;
-		} catch (const gdb_exception_error &e2) {
+	} CATCH(e, RETURN_MASK_ERROR) {
+		TRY {
+			info->off_address = parse_and_eval_address(
+			    "&((struct linker_file *)0)->address");
+			info->off_filename = parse_and_eval_address(
+			    "&((struct linker_file *)0)->filename");
+			info->off_pathname = parse_and_eval_address(
+			    "&((struct linker_file *)0)->pathname");
+			info->off_next = parse_and_eval_address(
+			    "&((struct linker_file *)0)->link.tqe_next");
+		} CATCH(e2, RETURN_MASK_ERROR) {
 			return;
 		}
+		END_CATCH
 	}
+	END_CATCH

-	try {
+	TRY {
 		info->module_path_addr = parse_and_eval_address("linker_path");
 		info->linker_files_addr = kgdb_lookup("linker_files");
 		info->kernel_file_addr = kgdb_lookup("linker_kernel_file");
-	} catch (const gdb_exception_error &e) {
+	} CATCH(e, RETURN_MASK_ERROR) {
 		return;
 	}
+	END_CATCH

 	solib_add(NULL, from_tty, auto_solib_add);
 }
--- a/devel/gdb/files/kgdb/fbsd-kthr.c
+++ b/devel/gdb/files/kgdb/fbsd-kthr.c
@ -106,18 +106,18 @@ kgdb_thr_add_procs(CORE_ADDR paddr, CORE_ADDR (*cpu_pcb_addr) (u_int))
 	LONGEST pid, tid;

 	while (paddr != 0) {
-		try {
+		TRY {
 			tdaddr = read_memory_typed_address (paddr +
 			    proc_off_p_threads, ptr_type);
 			pid = read_memory_integer (paddr + proc_off_p_pid, 4,
 			    byte_order);
 			pnext = read_memory_typed_address (paddr +
 			    proc_off_p_list, ptr_type);
-		} catch (const gdb_exception_error &e) {
+		} CATCH(e, RETURN_MASK_ERROR) {
 			break;
-		}
+		} END_CATCH
 		while (tdaddr != 0) {
-			try {
+			TRY {
 				tid = read_memory_integer (tdaddr +
 				    thread_off_td_tid, 4, byte_order);
 				oncpu = read_memory_unsigned_integer (tdaddr +
@ -127,9 +127,9 @@ kgdb_thr_add_procs(CORE_ADDR paddr, CORE_ADDR (*cpu_pcb_addr) (u_int))
 				    thread_off_td_pcb, ptr_type);
 				tdnext = read_memory_typed_address (tdaddr +
 				    thread_off_td_plist, ptr_type);
-			} catch (const gdb_exception_error &e) {
+			} CATCH(e, RETURN_MASK_ERROR) {
 				break;
-			}
+			} END_CATCH
 			kt = XNEW (struct kthr);
 			if (last == NULL)
 				first = last = kt;
@ -172,27 +172,27 @@ kgdb_thr_init(CORE_ADDR (*cpu_pcb_addr) (u_int))
 	addr = kgdb_lookup("allproc");
 	if (addr == 0)
 		return (NULL);
-	try {
+	TRY {
 		paddr = read_memory_typed_address (addr, ptr_type);
-	} catch (const gdb_exception_error &e) {
+	} CATCH(e, RETURN_MASK_ERROR) {
 		return (NULL);
-	}
+	} END_CATCH

 	dumppcb = kgdb_lookup("dumppcb");
 	if (dumppcb == 0)
 		return (NULL);

-	try {
+	TRY {
 		dumptid = parse_and_eval_long("dumptid");
-	} catch (const gdb_exception_error &e) {
+	} CATCH(e, RETURN_MASK_ERROR) {
 		dumptid = -1;
-	}
+	} END_CATCH

-	try {
+	TRY {
 		mp_maxid = parse_and_eval_long("mp_maxid");
-	} catch (const gdb_exception_error &e) {
+	} CATCH(e, RETURN_MASK_ERROR) {
 		mp_maxid = 0;
-	}
+	} END_CATCH
 	stopped_cpus = kgdb_lookup("stopped_cpus");

 	/*
@ -201,7 +201,7 @@ kgdb_thr_init(CORE_ADDR (*cpu_pcb_addr) (u_int))
 	 * kernels, try to extract these offsets using debug symbols.  If
 	 * that fails, use native values.
 	 */
-	try {
+	TRY {
 		proc_off_p_pid = parse_and_eval_long("proc_off_p_pid");
 		proc_off_p_comm = parse_and_eval_long("proc_off_p_comm");
 		proc_off_p_list = parse_and_eval_long("proc_off_p_list");
@ -212,52 +212,29 @@ kgdb_thr_init(CORE_ADDR (*cpu_pcb_addr) (u_int))
 		thread_off_td_pcb = parse_and_eval_long("thread_off_td_pcb");
 		thread_off_td_plist = parse_and_eval_long("thread_off_td_plist");
 		thread_oncpu_size = 4;
-	} catch (const gdb_exception_error &e) {
-		try {
-			struct symbol *proc_sym =
-			    lookup_symbol_in_language ("struct proc", NULL,
-				STRUCT_DOMAIN, language_c, NULL).symbol;
-			if (proc_sym == NULL)
-				error (_("Unable to find struct proc symbol"));
-
-			proc_off_p_pid =
-			    lookup_struct_elt (SYMBOL_TYPE (proc_sym), "p_pid",
-				0).offset / 8;
-			proc_off_p_comm =
-			    lookup_struct_elt (SYMBOL_TYPE (proc_sym), "p_comm",
-				0).offset / 8;
-			proc_off_p_list =
-			    lookup_struct_elt (SYMBOL_TYPE (proc_sym), "p_list",
-				0).offset / 8;
-			proc_off_p_threads =
-			    lookup_struct_elt (SYMBOL_TYPE (proc_sym),
-				"p_threads", 0).offset / 8;
-
-			struct symbol *thread_sym =
-			    lookup_symbol_in_language ("struct thread", NULL,
-				STRUCT_DOMAIN, language_c, NULL).symbol;
-			if (thread_sym == NULL)
-				error (_("Unable to find struct thread symbol"));
-
-			thread_off_td_tid =
-			    lookup_struct_elt (SYMBOL_TYPE (proc_sym), "td_tid",
-				0).offset / 8;
-			thread_off_td_name =
-			    lookup_struct_elt (SYMBOL_TYPE (proc_sym), "td_name",
-				0).offset / 8;
-			thread_off_td_pcb =
-			    lookup_struct_elt (SYMBOL_TYPE (proc_sym), "td_pcb",
-				0).offset / 8;
-			thread_off_td_plist =
-			    lookup_struct_elt (SYMBOL_TYPE (proc_sym), "td_plist",
-				0).offset / 8;
-
-			struct_elt td_oncpu =
-			    lookup_struct_elt (SYMBOL_TYPE (proc_sym), "td_oncpu",
-				0);
-			thread_off_td_oncpu = td_oncpu.offset / 8;
-			thread_oncpu_size = FIELD_BITSIZE(*td_oncpu.field) / 8;
-		} catch (const gdb_exception_error &e2) {
+	} CATCH(e, RETURN_MASK_ERROR) {
+		TRY {
+			proc_off_p_pid = parse_and_eval_address(
+			    "&((struct proc *)0)->p_pid");
+			proc_off_p_comm = parse_and_eval_address(
+			    "&((struct proc *)0)->p_comm");
+			proc_off_p_list = parse_and_eval_address(
+			    "&((struct proc *)0)->p_list");
+			proc_off_p_threads = parse_and_eval_address(
+			    "&((struct proc *)0)->p_threads");
+			thread_off_td_tid = parse_and_eval_address(
+			    "&((struct thread *)0)->td_tid");
+			thread_off_td_name = parse_and_eval_address(
+			    "&((struct thread *)0)->td_name");
+			thread_off_td_oncpu = parse_and_eval_address(
+			    "&((struct thread *)0)->td_oncpu");
+			thread_off_td_pcb = parse_and_eval_address(
+			    "&((struct thread *)0)->td_pcb");
+			thread_off_td_plist = parse_and_eval_address(
+			    "&((struct thread *)0)->td_plist");
+			thread_oncpu_size = parse_and_eval_long(
+			    "sizeof(((struct thread *)0)->td_oncpu)");
+		} CATCH(e2, RETURN_MASK_ERROR) {
 			proc_off_p_pid = offsetof(struct proc, p_pid);
 			proc_off_p_comm = offsetof(struct proc, p_comm);
 			proc_off_p_list = offsetof(struct proc, p_list);
@ -269,17 +246,17 @@ kgdb_thr_init(CORE_ADDR (*cpu_pcb_addr) (u_int))
 			thread_off_td_plist = offsetof(struct thread, td_plist);
 			thread_oncpu_size =
 			    sizeof(((struct thread *)0)->td_oncpu);
-		}
-	}
+		} END_CATCH
+	} END_CATCH

 	kgdb_thr_add_procs(paddr, cpu_pcb_addr);
 	addr = kgdb_lookup("zombproc");
 	if (addr != 0) {
-		try {
+		TRY {
 			paddr = read_memory_typed_address (addr, ptr_type);
 			kgdb_thr_add_procs(paddr, cpu_pcb_addr);
-		} catch (const gdb_exception_error &e) {
-		}
+		} CATCH(e, RETURN_MASK_ERROR) {
+		} END_CATCH
 	}
 	curkthr = kgdb_thr_lookup_tid(dumptid);
 	if (curkthr == NULL)
@ -349,7 +326,7 @@ kgdb_thr_extra_thread_info(int tid)
 	if (kt == NULL)
 		return (NULL);	
 	snprintf(buf, sizeof(buf), "PID=%d", kt->pid);
-	try {
+	TRY {
 		read_memory_string (kt->paddr + proc_off_p_comm, comm,
 		    sizeof(comm));
 		strlcat(buf, ": ", sizeof(buf));
@ -360,7 +337,7 @@ kgdb_thr_extra_thread_info(int tid)
 			strlcat(buf, "/", sizeof(buf));
 			strlcat(buf, td_name, sizeof(buf));
 		}
-	} catch (const gdb_exception_error &e) {
-	}
+	} CATCH(e, RETURN_MASK_ERROR) {
+	} END_CATCH
 	return (buf);
 }
--- a/devel/gdb/files/kgdb/fbsd-kvm.c
+++ b/devel/gdb/files/kgdb/fbsd-kvm.c
@ -42,7 +42,6 @@ __FBSDID("$FreeBSD$");
 #include "target.h"
 #include "value.h"
 #include "readline/tilde.h"
-#include "gdbsupport/pathstuff.h"

 #include <sys/user.h>
 #include <fcntl.h>
@ -139,14 +138,14 @@ kgdb_dmesg(void)
 	 */
 	if (kgdb_quiet)
 		return;
-	try {
+	TRY {
 		bufp = parse_and_eval_address("msgbufp->msg_ptr");
 		size = parse_and_eval_long("msgbufp->msg_size");
 		rseq = parse_and_eval_long("msgbufp->msg_rseq");
 		wseq = parse_and_eval_long("msgbufp->msg_wseq");
-	} catch (const gdb_exception_error &e) {
+	} CATCH(e, RETURN_MASK_ERROR) {
 		return;
-	}
+	} END_CATCH
 	rseq = MSGBUF_SEQ_TO_POS(size, rseq);
 	wseq = MSGBUF_SEQ_TO_POS(size, wseq);
 	if (rseq == wseq)
@ -203,7 +202,7 @@ fbsd_kernel_osabi_sniffer(bfd *abfd)
 	/* FreeBSD ELF kernels have an interpreter path of "/red/herring". */
 	bufp = buf;
 	s = bfd_get_section_by_name(abfd, ".interp");
-	if (s != NULL && bfd_section_size(s) == sizeof(buf) &&
+	if (s != NULL && bfd_section_size(abfd, s) == sizeof(buf) &&
 	    bfd_get_full_section_contents(abfd, s, &bufp) &&
 	    memcmp(buf, KERNEL_INTERP, sizeof(buf)) == 0)
 		return (GDB_OSABI_FREEBSD_KERNEL);
@ -242,7 +241,7 @@ public:
  void files_info () override;
  bool thread_alive (ptid_t ptid) override;
  void update_thread_list () override;
-  std::string pid_to_str (ptid_t) override;
+  const char *pid_to_str (ptid_t) override;
  const char *extra_thread_info (thread_info *) override;

  bool has_all_memory () override { return false; }
@ -279,15 +278,14 @@ fbsd_kvm_target_open (const char *args, int from_tty)
 	struct cleanup *old_chain;
 	struct kthr *kt;
 	kvm_t *nkvm;
-	const char *kernel;
-	char *temp, *filename;
+	char *temp, *kernel, *filename;
 	bool writeable;

 	if (ops == NULL || ops->supply_pcb == NULL || ops->cpu_pcb_addr == NULL)
 		error ("ABI doesn't support a vmcore target");

 	target_preopen (from_tty);
-	kernel = get_exec_file (0);
+	kernel = get_exec_file (1);
 	if (kernel == NULL)
 		error ("Can't open a vmcore without a kernel");

@ -307,16 +305,18 @@ fbsd_kvm_target_open (const char *args, int from_tty)
 					error (_("Invalid argument"));

 				filename = tilde_expand (*argv);
-				if (filename[0] != '/') {
-					gdb::unique_xmalloc_ptr<char> temp (gdb_abspath (filename));
-
-					xfree (filename);
-					filename = temp.release ();
+				if (!IS_ABSOLUTE_PATH (filename)) {
+					temp = concat (current_directory, "/",
+					    filename, NULL);
+					xfree(filename);
+					filename = temp;
 				}
 			}
 		}
 	}

+	old_chain = make_cleanup (xfree, filename);
+
 #ifdef HAVE_KVM_OPEN2
 	nkvm = kvm_open2(kernel, filename,
 	    writeable ? O_RDWR : O_RDONLY, kvm_err, kgdb_resolve_symbol);
@ -324,12 +324,11 @@ fbsd_kvm_target_open (const char *args, int from_tty)
 	nkvm = kvm_openfiles(kernel, filename, NULL,
 	    writeable ? O_RDWR : O_RDONLY, kvm_err);
 #endif
-	if (nkvm == NULL) {
-		xfree (filename);
+	if (nkvm == NULL)
 		error ("Failed to open vmcore: %s", kvm_err);
-	}

 	/* Don't free the filename now and close any previous vmcore. */
+	discard_cleanups(old_chain);
 	unpush_target(&fbsd_kvm_ops);

 #ifdef HAVE_KVM_DISP
@ -361,27 +360,27 @@ fbsd_kvm_target_open (const char *args, int from_tty)
 	 * symbol that is valid on all platforms, but kernbase is close
 	 * for most platforms.
 	 */
-	try {
+	TRY {
 		kernstart = parse_and_eval_address("vm_maxuser_address") + 1;
-	} catch (const gdb_exception_error &e) {
+	} CATCH(e, RETURN_MASK_ERROR) {
 		kernstart = kgdb_lookup("kernbase");
-	}
+	} END_CATCH

 	/*
 	 * Lookup symbols needed for stoppcbs[] handling, but don't
 	 * fail if they aren't present.
 	 */
 	stoppcbs = kgdb_lookup("stoppcbs");
-	try {
+	TRY {
 		pcb_size = parse_and_eval_long("pcb_size");
-	} catch (const gdb_exception_error &e) {
+	} CATCH(e, RETURN_MASK_ERROR) {
 		pcb_size = 0;
-	}
+	} END_CATCH

 	if (pcb_size == 0) {
-		try {
+		TRY {
 			pcb_size = parse_and_eval_long("sizeof(struct pcb)");
-		} catch (const gdb_exception_error &e) {
+		} CATCH(e, RETURN_MASK_ERROR) {
 #ifdef HAVE_KVM_OPEN2
 			if (kvm_native(nkvm))
 				pcb_size = sizeof(struct pcb);
@ -390,7 +389,7 @@ fbsd_kvm_target_open (const char *args, int from_tty)
 #else
 			pcb_size = sizeof(struct pcb);
 #endif
-		}
+		} END_CATCH
 	}

 	kvm = nkvm;
@ -509,10 +508,13 @@ fbsd_kvm_target::update_thread_list()
 #endif
 }

-std::string
+const char *
 fbsd_kvm_target::pid_to_str(ptid_t ptid)
 {
-  return string_printf (_("Thread %ld"), ptid.tid ());
+	static char buf[33];
+
+	snprintf(buf, sizeof(buf), "Thread %ld", ptid.tid());
+	return (buf);
 }

 bool
--- a/devel/gdb/files/kgdb/i386fbsd-kern.c
+++ b/devel/gdb/files/kgdb/i386fbsd-kern.c
@ -211,11 +211,11 @@ i386fbsd_fetch_tss(void)
 	 * change it to be relative to cpu0prvpage instead.
 	 */ 
 	if (trunc_page(tss) == 0xffc00000) {
-		try {
+		TRY {
 			cpu0prvpage = parse_and_eval_address("cpu0prvpage");
-		} catch (const gdb_exception_error &e) {
+		} CATCH(e, RETURN_MASK_ERROR) {
 			return (0);
-		}
+		} END_CATCH
 		tss = cpu0prvpage + (tss & PAGE_MASK);
 	}
 	return (tss);
--- a/devel/gdb/files/kgdb/riscv-fbsd-kern.c
+++ b/devel/gdb/files/kgdb/riscv-fbsd-kern.c
@ -32,7 +32,6 @@

 #include "riscv-tdep.h"
 #include "frame-unwind.h"
-#include "gdbarch.h"
 #include "gdbcore.h"
 #include "osabi.h"
 #include "regcache.h"
--- a/devel/gdb/files/kgdb/sparc64fbsd-kern.c
+++ b/devel/gdb/files/kgdb/sparc64fbsd-kern.c
@ -28,7 +28,6 @@
 __FBSDID("$FreeBSD$");

 #include "defs.h"
-#include "gdbarch.h"
 #include "gdbcore.h"
 #include "osabi.h"
 #include "regcache.h"
--- a/devel/gdb/files/patch-gdb_gdbsupport_common-defs.h
+++ b/devel/gdb/files/patch-gdb_gdbsupport_common-defs.h
@ -1,6 +1,6 @@
--- gdb/gdbsupport/common-defs.h.orig	2020-02-08 04:50:14.000000000 -0800
-+++ gdb/gdbsupport/common-defs.h	2020-02-27 10:06:21.899297000 -0800
-@@ -55,9 +55,15 @@
+--- gdb/common/common-defs.h.orig	2017-09-12 12:25:12 UTC
+++ gdb/common/common-defs.h
+@@ -44,9 +44,15 @@
 
    Must do this before including any system header, since other system
    headers may include stdint.h/inttypes.h.  */
@ -14,5 +14,5 @@
 #define __STDC_FORMAT_MACROS 1
 +#endif
 
- /* Some distros enable _FORTIFY_SOURCE by default, which on occasion
-    has caused build failures with -Wunused-result when a patch is
+ #include <stdarg.h>
+ #include <stdio.h>
--- a/devel/gdb/files/patch-gdb_gnulib_import_stddef.in.h
+++ b/devel/gdb/files/patch-gdb_gnulib_import_stddef.in.h
@ -1,5 +1,5 @@
--- gnulib/import/stddef.in.h.orig	2020-02-08 04:50:14.000000000 -0800
-+++ gnulib/import/stddef.in.h	2020-02-27 10:09:59.859133000 -0800
+--- gdb/gnulib/import/stddef.in.h.orig 2017-09-14 09:28:17 UTC
+++ gdb/gnulib/import/stddef.in.h
@@ -84,7 +84,7 @@
 /* Some platforms lack max_align_t.  The check for _GCC_MAX_ALIGN_T is
    a hack in case the configure-time test was done with g++ even though
--- a/devel/gdb/files/patch-libctf_swap.h
+++ b/devel/gdb/files/patch-libctf_swap.h
@ -1,11 +0,0 @@
--- libctf/swap.h.orig	2020-02-27 15:22:32.550650000 -0800
-+++ libctf/swap.h	2020-02-27 15:22:43.397285000 -0800
-@@ -43,7 +43,7 @@ bswap_32 (uint32_t v)
- 	  | ((v & 0x000000ff) << 24));
- }
- 
-inline uint64_t
-+static inline uint64_t
- bswap_identity_64 (uint64_t v)
- {
-   return v;