Added build scripts for GDB

Change-Id: I7300952fa95337fd6f5bcdb7a88933e8c06538b1
Reviewed-by: hjk <qthjk@ovi.com>

8 files changed, 2502 insertions, 0 deletions

diff --git a/dist/gdb/Makefile.linux b/dist/gdb/Makefile.linux
new file mode 100644
index 0000000000..a014bc443d
--- /dev/null
+++ b/dist/gdb/Makefile.linux
@@ -0,0 +1,95 @@
+broot=${PWD}
+source=${broot}/source
+targets=x86_64-unknown-linux-gnu i686-unknown-linux-gnu arm-none-linux-gnueabi arm-none-symbianelf
+staging=${broot}/staging
+pyversion=2.7
+expatversion=2.0.1
+arch=`uname -sm | sed 's/ /-/g' | tr A-Z a-z`
+version=7.4
+targetdir=${broot}/qtcreator-gdb-${version}
+gdbtargets=$(addprefix ${targetdir}/gdb-, ${targets})
+packagename=qtcreator-gdb-${version}-${arch}.tar.gz
+
+all:package
+
+gdb-7.4: override version=7.4
+
+gdb-7.4: ${staging}/lib/libpython${pyversion}.a ${staging}/lib/libexpat.a
+	${MAKE} version=${version}
+
+clean:
+	rm -rf  ${broot}/qtcreator-gdb-* ${staging}/gdb-* qtcreator-gdb-*.tar.gz
+
+makesourcedir:
+	test -e ${source} || mkdir ${source}
+
+maketargetdir:
+	test -e ${targetdir} || mkdir ${targetdir}
+
+makestagingdir:
+	test -e ${staging} || mkdir ${staging}
+
+${source}/expat-${expatversion}.tar.gz: | makesourcedir
+	cd ${source}; wget http://sourceforge.net/projects/expat/files/expat/${expatversion}/expat-${expatversion}.tar.gz && \
+	touch ${source}/expat-${expatversion}.tar.gz
+
+${source}/Python-${pyversion}.tgz: | makesourcedir
+	cd ${source}; wget http://www.python.org/ftp/python/${pyversion}/Python-${pyversion}.tgz && \
+	touch ${source}/Python-${pyversion}.tgz
+
+${source}/gdb-${version}.tar.bz2: | makesourcedir
+	cd ${source} &&\
+	wget http://ftp.gnu.org/gnu/gdb/gdb-${version}.tar.bz2 || \
+	wget -O gdb-${version}.tar.bz2 http://ftp.gnu.org/gnu/gdb/gdb-${version}a.tar.bz2 && \
+	touch gdb-*.tar.bz2
+
+${staging}/lib/libexpat.a: ${source}/expat-${expatversion}.tar.gz | makestagingdir
+	cd ${staging} && tar xvf ${source}/expat-${expatversion}.tar.gz && cd expat-${expatversion} && \
+	./configure --disable-shared -prefix=${staging} && ${MAKE} && ${MAKE} install
+
+${staging}/lib/libpython${pyversion}.a: ${source}/Python-${pyversion}.tgz | makestagingdir
+	unset PYTHONHOME && cd ${staging} && tar xvf ${source}/Python-${pyversion}.tgz && cd Python-${pyversion} && \
+	export LDFLAGS="-pthread -lm" && \
+	./configure --prefix=${staging} && ${MAKE} && ${MAKE} install
+
+${targetdir}/python/include/python${pyversion}/pyconfig.h: ${staging}/lib/libpython${pyversion}.a | maketargetdir
+	mkdir -p ${targetdir}/python/lib && cp -a ${staging}/lib/python${pyversion} ${targetdir}/python/lib/
+	mkdir -p ${targetdir}/python/include/python${pyversion} && cp ${staging}/include/python${pyversion}/pyconfig.h ${targetdir}/python/include/python${pyversion}/
+
+${staging}/gdb-${version}/configure: ${source}/gdb-${version}.tar.bz2 | makestagingdir
+	cd ${staging} && \
+	tar xvf ${source}/gdb-${version}.tar.bz2 && \
+	cd gdb-${version} && \
+	touch configure && \
+        patch -p2 < ${broot}/patches/pythonhome-7.4.patch && \
+        patch -p1 < ${broot}/patches/gdb-buildid-locate.patch && \
+        patch -p1 < ${broot}/patches/gdb-ipv6.patch && \
+	patch -p1 < ${broot}/patches/gdb-work-around-trk-single-step.patch
+
+${gdbtargets}: ${targetdir}/gdb-%: ${staging}/gdb-${version}/configure ${staging}/lib/libpython${pyversion}.a ${staging}/lib/libexpat.a | maketargetdir
+	test -e ${staging}/gdb-${version}-$* || mkdir ${staging}/gdb-${version}-$*
+	export PYTHONHOME=${staging} && \
+	export PATH="${staging}/bin/:$$PATH" && \
+	export LDFLAGS="-pthread -lm" && \
+	cd ${staging}/gdb-${version}-$* && \
+	${staging}/gdb-${version}/configure --disable-nls --target=$* --with-python=${staging} --with-libexpat-prefix=${staging} && \
+	sleep 3 && \
+	${MAKE} MAKEFLAGS+=-j1 && \
+	strip gdb/gdb && \
+	cp -T gdb/gdb ${targetdir}/gdb-$*
+
+${targetdir}/gdb: ${staging}/gdb-${version}/configure ${staging}/lib/libpython${pyversion}.a ${staging}/lib/libexpat.a | maketargetdir
+	test -e ${staging}/gdb-${version}-${arch} || mkdir ${staging}/gdb-${version}-${arch}
+	export PYTHONHOME=${staging}  && \
+	export PATH="${staging}/bin/:$$PATH" && \
+	export LDFLAGS="-pthread -lm" && \
+	cd ${staging}/gdb-${version}-${arch} && \
+	${staging}/gdb-${version}/configure --disable-nls --with-python=${staging} --with-libexpat-prefix=${staging} && \
+	${MAKE} MAKEFLAGS+=-j1 && \
+	strip gdb/gdb && \
+	cp -T gdb/gdb ${targetdir}/gdb
+
+package: ${gdbtargets} ${targetdir}/gdb ${targetdir}/python/include/python${pyversion}/pyconfig.h
+	mv ${targetdir} ${targetdir}-${arch}
+	tar cvzf ${packagename} qtcreator-gdb-${version}-${arch}
+	mv ${targetdir}-${arch} ${targetdir}
diff --git a/dist/gdb/Makefile.mingw b/dist/gdb/Makefile.mingw
new file mode 100644
index 0000000000..e7f78a6f8e
--- /dev/null
+++ b/dist/gdb/Makefile.mingw
@@ -0,0 +1,101 @@
+broot=${PWD}
+source=${broot}/source
+targets=arm-none-symbianelf arm-none-linux-gnueabi i686-pc-mingw32
+staging=${broot}/staging
+pyversion=2.7
+pydir=${broot}/python
+expatversion=2.0.1
+iconvversion=1.14
+version=7.4
+targetdir=${broot}/qtcreator-gdb-${version}
+gdbtargets=$(addprefix ${targetdir}/gdb-, ${targets})
+packageparts=${targetdir}/lib ${targetdir}/lib ${targetdir}/libiconv-2.dll ${targetdir}/python27.dll ${targetdir}/libexpat-1.dll
+arch=`uname -sm | sed 's/ /-/g' | tr A-Z a-z`
+packagename=qtcreator-gdb-${version}-${arch}.tar.gz
+
+all: package
+
+gdb-7.4: override version=7.4
+
+gdb-7.4:
+	${MAKE} version=${version}
+
+clean:
+	rm -rf  ${broot}/qtcreator-gdb-* ${staging}/gdb-*
+
+distclean:
+	rm -rf ${staging} ${source} ${broot}/qtcreator-gdb-*
+
+makesourcedir:
+	test -e ${source} || mkdir ${source}
+
+maketargetdir:
+	test -e ${targetdir} || mkdir ${targetdir}
+
+makestagingdir:
+	test -e ${staging} || mkdir ${staging}
+
+checkwget:
+	wget -V || mingw-get install msys-wget-bin
+
+${source}/gdb-${version}.tar.bz2: | makesourcedir checkwget
+	cd ${source} && \
+	wget http://ftp.gnu.org/gnu/gdb/gdb-${version}.tar.bz2 || \
+	wget -O gdb-${version}.tar.bz2 http://ftp.gnu.org/gnu/gdb/gdb-${version}a.tar.bz2 && \
+	touch gdb-${version}.tar.bz2
+
+${source}/libiconv-${iconvversion}.tar.gz: | makesourcedir checkwget
+	cd ${source} && \
+	wget http://ftp.gnu.org/pub/gnu/libiconv/libiconv-${iconvversion}.tar.gz  && \
+	touch ${source}/libiconv-${iconvversion}.tar.gz
+
+${source}/expat-${expatversion}.tar.gz: | makesourcedir checkwget
+	cd ${source} &&\
+	wget http://sourceforge.net/projects/expat/files/expat/${expatversion}/expat-${expatversion}.tar.gz/download && \
+	touch ${source}/expat-${expatversion}.tar.gz
+
+${staging}/gdb-${version}/configure: ${source}/gdb-${version}.tar.bz2 | makestagingdir
+	cd ${staging} && \
+	tar xvf ${source}/gdb-${version}.tar.bz2 && \
+	cd gdb-${version} && \
+	touch configure && \
+	patch -p1 < ${broot}/patches/gdb-ipv6.patch && \
+	patch -p1 < ${broot}/patches/gdb-target-debugging.patch
+
+${staging}/lib/libiconv.a: ${source}/libiconv-${iconvversion}.tar.gz | makestagingdir
+	cd ${staging} && \
+	tar xvf ${source}/libiconv-${iconvversion}.tar.gz && \
+	cd libiconv-${iconvversion} && \
+	./configure -prefix=${staging} --enable-static && \
+	${MAKE} && ${MAKE} install
+
+${staging}/lib/libexpat.a: ${source}/expat-${expatversion}.tar.gz | makestagingdir
+	cd ${staging} && \
+	tar xvf ${source}/expat-${expatversion}.tar.gz && \
+	cd expat-${expatversion} && \
+	./configure -prefix=${staging} --enable-static && \
+	${MAKE} && ${MAKE} install
+
+${gdbtargets}: ${targetdir}/gdb-%: ${staging}/lib/libexpat.a ${staging}/lib/libiconv.a ${staging}/gdb-${version}/configure | maketargetdir
+	test -e ${staging}/gdb-${version}-$* || mkdir ${staging}/gdb-${version}-$*
+	export PYTHONHOME=${pydir} && \
+	LDFLAGS="L${pydir} -lpthread -ldl -lutil -lpython27" && \
+	CFLAGS="-I${pydir}/include" && \
+	cd ${staging}/gdb-${version}-$* && \
+	${staging}/gdb-${version}/configure --target=$* --disable-nls \
+	--with-libiconv-prefix=${staging} \
+	--with-expat --with-libexpat-prefix=${staging} \
+	--with-python=${pydir} &&\
+	${MAKE} MAKEFLAGS+= -j1 &&\
+	strip gdb/gdb.exe && \
+	cp -T gdb/gdb.exe ${targetdir}/gdb-$*.exe
+
+package: ${gdbtargets}
+	cp ${staging}/bin/libiconv* ${targetdir} && \
+	cp ${staging}/bin/libexpat* ${targetdir} && \
+	cp ${pydir}/python*.dll ${targetdir} && \
+	cp -r ${pydir}/lib ${targetdir} && \
+	cp -r ${pydir}/include ${targetdir} && \
+	mv ${targetdir} ${targetdir}-${arch} && \
+	tar cvzf ${packagename} qtcreator-gdb-${version}-${arch} && \
+	mv ${targetdir}-${arch} ${targetdir}
diff --git a/dist/gdb/Makefile.osx b/dist/gdb/Makefile.osx
new file mode 100644
index 0000000000..b8343e5f57
--- /dev/null
+++ b/dist/gdb/Makefile.osx
@@ -0,0 +1,89 @@
+broot=${PWD}
+source=${broot}/source
+targets=x86_64-unknown-linux-gnu i686-unknown-linux-gnu arm-none-linux-gnueabi arm-none-symbianelf
+staging=${broot}/staging
+pyversion=2.7
+expatversion=2.0.1
+arch=`uname -sm | sed 's/ /-/g' | tr A-Z a-z`
+version=7.4
+targetdir=${broot}/qtcreator-gdb-${version}
+gdbtargets=$(addprefix ${targetdir}/gdb-, ${targets})
+packagename=qtcreator-gdb-${version}-${arch}.tar.gz
+
+all:package
+
+gdb-7.4: override version=7.4
+
+gdb-7.4: ${staging}/lib/libpython${pyversion}.a ${staging}/lib/libexpat.a
+	${MAKE} version=${version}
+
+clean:
+	rm -rf  ${broot}/qtcreator-gdb-* ${staging}/gdb-* qtcreator-gdb-*.tar.gz
+
+makesourcedir:
+	test -e ${source} || mkdir ${source}
+
+maketargetdir:
+	test -e ${targetdir} || mkdir ${targetdir}
+
+makestagingdir:
+	test -e ${staging} || mkdir ${staging}
+
+${source}/expat-${expatversion}.tar.gz: | makesourcedir
+	cd ${source}; curl -LOf http://sourceforge.net/projects/expat/files/expat/${expatversion}/expat-${expatversion}.tar.gz && \
+	touch ${source}/expat-${expatversion}.tar.gz
+
+${source}/Python-${pyversion}.tgz: | makesourcedir
+	cd ${source}; curl -Of http://www.python.org/ftp/python/${pyversion}/Python-${pyversion}.tgz && \
+	touch ${source}/Python-${pyversion}.tgz
+
+${source}/gdb-${version}.tar.bz2: | makesourcedir
+	cd ${source} && \
+	curl -Of http://ftp.gnu.org/gnu/gdb/gdb-${version}.tar.bz2 || \
+	curl -of gdb-${version}.tar.bz2 http://ftp.gnu.org/gnu/gdb/gdb-${version}a.tar.bz2 && \
+	touch gdb-*.tar.bz2
+
+${staging}/lib/libexpat.a: ${source}/expat-${expatversion}.tar.gz | makestagingdir
+	cd ${staging} && tar xvf ${source}/expat-${expatversion}.tar.gz && cd expat-${expatversion} && \
+	./configure --disable-shared -prefix=/ && ${MAKE} && ${MAKE} install
+
+${staging}/lib/libpython${pyversion}.a: ${source}/Python-${pyversion}.tgz | makestagingdir
+	unset PYTHONHOME && cd ${staging} && tar xvf ${source}/Python-${pyversion}.tgz && cd Python-${pyversion} && \
+	./configure --prefix=${staging} && ${MAKE} && ${MAKE} install
+
+${targetdir}/python/include/python${pyversion}/pyconfig.h: ${staging}/lib/libpython${pyversion}.a | maketargetdir
+	mkdir -p ${targetdir}/python/lib && cp -a ${staging}/lib/python${pyversion} ${targetdir}/python/lib/
+	mkdir -p ${targetdir}/python/include/python${pyversion} && cp ${staging}/include/python${pyversion}/pyconfig.h ${targetdir}/python/include/python${pyversion}/
+
+${staging}/gdb-${version}/configure: ${source}/gdb-${version}.tar.bz2 | makestagingdir
+	cd ${staging} && \
+	tar xvf ${source}/gdb-${version}.tar.bz2 && \
+	cd gdb-${version} && \
+	touch configure && \
+	patch -p2 < ${broot}/patches/pythonhome-${version}.patch && \
+	patch -p1 < ${broot}/patches/gdb-ipv6.patch
+
+${gdbtargets}: ${targetdir}/gdb-%: ${staging}/gdb-${version}/configure ${staging}/lib/libpython${pyversion}.a ${staging}/lib/libexpat.a | maketargetdir
+	test -e ${staging}/gdb-${version}-$* || mkdir ${staging}/gdb-${version}-$*
+	export PYTHONHOME=${staging} && \
+	export PATH="${staging}/bin/:$$PATH" && \
+	cd ${staging}/gdb-${version}-$* && \
+	${staging}/gdb-${version}/configure --disable-nls --target=$* --with-python=${staging} --with-libexpat-prefix=${staging} && \
+	${MAKE} MAKEFLAGS+=-j1 && \
+	strip gdb/gdb && \
+	mv gdb/gdb ${targetdir}/gdb-$*
+
+${targetdir}/gdb: ${staging}/gdb-${version}/configure ${staging}/lib/libpython${pyversion}.a ${staging}/lib/libexpat.a | maketargetdir
+	test -e ${staging}/gdb-${version}-${arch} || mkdir ${staging}/gdb-${version}-${arch}
+	export PYTHONHOME=${staging}  && \
+	export PATH="${staging}/bin/:$$PATH" && \
+	cd ${staging}/gdb-${version}-${arch} && \
+	${staging}/gdb-${version}/configure --disable-nls --with-python=${staging} --with-libexpat-prefix=${staging} --disable-werror && \
+	${MAKE} MAKEFLAGS+=-j1 && \
+	strip gdb/gdb && \
+	mv gdb/gdb ${targetdir}/gdb
+
+package: ${gdbtargets} ${targetdir}/gdb ${targetdir}/python/include/python${pyversion}/pyconfig.h
+	mv ${targetdir} ${targetdir}-${arch}
+	tar cvzf ${packagename} qtcreator-gdb-${version}-${arch}
+	mv ${targetdir}-${arch} ${targetdir}
diff --git a/dist/gdb/patches/gdb-buildid-locate.patch b/dist/gdb/patches/gdb-buildid-locate.patch
new file mode 100644
index 0000000000..31521b8c72
--- /dev/null
+++ b/dist/gdb/patches/gdb-buildid-locate.patch
@@ -0,0 +1,1037 @@
+diff -rup gdb-7.4-clean/gdb/corelow.c gdb-7.4/gdb/corelow.c
+--- gdb-7.4-clean/gdb/corelow.c	2012-01-06 05:43:06.000000000 +0100
++++ gdb-7.4/gdb/corelow.c	2012-04-02 10:32:00.884169912 +0200
+@@ -47,7 +47,9 @@
+ #include "progspace.h"
+ #include "objfiles.h"
+ #include "wrapper.h"
+-
++#include "auxv.h"
++#include "elf/common.h"
++#include "gdbcmd.h"
+ 
+ #ifndef O_LARGEFILE
+ #define O_LARGEFILE 0
+@@ -278,6 +280,52 @@ add_to_thread_list (bfd *abfd, asection
+     inferior_ptid = ptid;			/* Yes, make it current.  */
+ }
+ 
++static int build_id_core_loads = 1;
++
++static void
++build_id_locate_exec (int from_tty)
++{
++  CORE_ADDR at_entry;
++  struct build_id *build_id;
++  char *exec_filename, *debug_filename;
++  char *build_id_filename;
++  struct cleanup *back_to;
++
++  if (exec_bfd != NULL || symfile_objfile != NULL)
++    return;
++
++  if (target_auxv_search (&current_target, AT_ENTRY, &at_entry) <= 0)
++    return;
++
++  build_id = build_id_addr_get (at_entry);
++  if (build_id == NULL)
++    return;
++
++  /* SYMFILE_OBJFILE should refer to the main executable (not only to its
++     separate debug info file).  gcc44+ keeps .eh_frame only in the main
++     executable without its duplicate .debug_frame in the separate debug info
++     file - such .eh_frame would not be found if SYMFILE_OBJFILE would refer
++     directly to the separate debug info file.  */
++
++  exec_filename = build_id_to_filename (build_id, &build_id_filename, 0);
++  back_to = make_cleanup (xfree, build_id_filename);
++
++  if (exec_filename != NULL)
++    {
++      make_cleanup (xfree, exec_filename);
++      exec_file_attach (exec_filename, from_tty);
++      symbol_file_add_main (exec_filename, from_tty);
++      if (symfile_objfile != NULL)
++        symfile_objfile->flags |= OBJF_BUILD_ID_CORE_LOADED;
++    }
++  else
++    debug_print_missing (_("the main executable file"), build_id_filename);
++
++  do_cleanups (back_to);
++
++  /* No automatic SOLIB_ADD as the libraries would get read twice.  */
++}
++
+ /* This routine opens and sets up the core file bfd.  */
+ 
+ static void
+@@ -379,6 +427,12 @@ core_open (char *filename, int from_tty)
+   push_target (&core_ops);
+   discard_cleanups (old_chain);
+ 
++  /* Find the build_id identifiers.  If it gets executed after
++     POST_CREATE_INFERIOR we would clash with asking to discard the already
++     loaded VDSO symbols.  */
++  if (build_id_core_loads != 0)
++    build_id_locate_exec (from_tty);
++
+   /* Do this before acknowledging the inferior, so if
+      post_create_inferior throws (can happen easilly if you're loading
+      a core file with the wrong exec), we aren't left with threads
+@@ -932,4 +986,11 @@ _initialize_corelow (void)
+   init_core_ops ();
+ 
+   add_target (&core_ops);
++
++  add_setshow_boolean_cmd ("build-id-core-loads", class_files,
++			   &build_id_core_loads, _("\
++Set whether CORE-FILE loads the build-id associated files automatically."), _("\
++Show whether CORE-FILE loads the build-id associated files automatically.."),
++			   NULL, NULL, NULL,
++			   &setlist, &showlist);
+ }
+Only in gdb-7.4/gdb: corelow.c.orig
+Only in gdb-7.4/gdb: corelow.c.rej
+diff -rup gdb-7.4-clean/gdb/doc/gdb.texinfo gdb-7.4/gdb/doc/gdb.texinfo
+--- gdb-7.4-clean/gdb/doc/gdb.texinfo	2012-01-06 05:43:35.000000000 +0100
++++ gdb-7.4/gdb/doc/gdb.texinfo	2012-04-02 10:30:11.104170086 +0200
+@@ -15872,6 +15872,27 @@ information files.
+ 
+ @end table
+ 
++You can also adjust the current verbosity of the @dfn{build id} locating.
++
++@table @code
++
++@kindex set build-id-verbose
++@item set build-id-verbose 0
++No additional messages are printed.
++
++@item set build-id-verbose 1
++Missing separate debug filenames are printed.
++
++@item set build-id-verbose 2
++Missing separate debug filenames are printed and also all the parsing of the
++binaries to find their @dfn{build id} content is printed.
++
++@kindex show build-id-verbose
++@item show build-id-verbose
++Show the current verbosity value for the @dfn{build id} content locating.
++
++@end table
++
+ @cindex @code{.gnu_debuglink} sections
+ @cindex debug link sections
+ A debug link is a special section of the executable file named
+Only in gdb-7.4/gdb/doc: gdb.texinfo.orig
+diff -rup gdb-7.4-clean/gdb/elfread.c gdb-7.4/gdb/elfread.c
+--- gdb-7.4-clean/gdb/elfread.c	2012-01-06 05:43:11.000000000 +0100
++++ gdb-7.4/gdb/elfread.c	2012-04-02 10:31:10.748169992 +0200
+@@ -41,6 +41,11 @@
+ #include "infcall.h"
+ #include "gdbthread.h"
+ #include "regcache.h"
++#include "libbfd.h"
++#include "gdbcore.h"
++#include "gdbcmd.h"
++#include "observer.h"
++#include <sys/stat.h>
+ 
+ extern void _initialize_elfread (void);
+ 
+@@ -1042,16 +1047,65 @@ elf_gnu_ifunc_resolver_return_stop (stru
+   update_breakpoint_locations (b, sals, sals_end);
+ }
+ 
++#define BUILD_ID_VERBOSE_NONE 0
++#define BUILD_ID_VERBOSE_FILENAMES 1
++#define BUILD_ID_VERBOSE_BINARY_PARSE 2
++static int build_id_verbose = BUILD_ID_VERBOSE_FILENAMES;
++static void
++show_build_id_verbose (struct ui_file *file, int from_tty,
++		       struct cmd_list_element *c, const char *value)
++{
++  fprintf_filtered (file, _("Verbosity level of the build-id locator is %s.\n"),
++		    value);
++}
++
+ struct build_id
+   {
+     size_t size;
+     gdb_byte data[1];
+   };
+ 
+-/* Locate NT_GNU_BUILD_ID from ABFD and return its content.  */
++/* Locate NT_GNU_BUILD_ID and return its matching debug filename.
++   FIXME: NOTE decoding should be unified with the BFD core notes decoding.  */
++
++struct build_id *
++build_id_buf_get (bfd *templ, gdb_byte *buf, bfd_size_type size)
++{
++  bfd_byte *p;
++
++  p = buf;
++  while (p < buf + size)
++    {
++      /* FIXME: bad alignment assumption.  */
++      Elf_External_Note *xnp = (Elf_External_Note *) p;
++      size_t namesz = H_GET_32 (templ, xnp->namesz);
++      size_t descsz = H_GET_32 (templ, xnp->descsz);
++      bfd_byte *descdata = xnp->name + BFD_ALIGN (namesz, 4);
++
++      if (H_GET_32 (templ, xnp->type) == NT_GNU_BUILD_ID
++	  && namesz == sizeof "GNU"
++	  && memcmp (xnp->name, "GNU", sizeof "GNU") == 0)
++	{
++	  size_t size = descsz;
++	  gdb_byte *data = (void *) descdata;
++	  struct build_id *retval;
++
++	  retval = xmalloc (sizeof *retval - 1 + size);
++	  retval->size = size;
++	  memcpy (retval->data, data, size);
++
++	  return retval;
++	}
++      p = descdata + BFD_ALIGN (descsz, 4);
++    }
++  return NULL;
++}
++
++/* Separate debuginfo files have corrupted PHDR but SHDR is correct there.
++   Locate NT_GNU_BUILD_ID from ABFD and return its content.  */
+ 
+ static struct build_id *
+-build_id_bfd_get (bfd *abfd)
++build_id_bfd_shdr_get (bfd *abfd)
+ {
+   struct build_id *retval;
+ 
+@@ -1067,6 +1121,348 @@ build_id_bfd_get (bfd *abfd)
+   return retval;
+ }
+ 
++/* Core files may have missing (corrupt) SHDR but PDHR is correct there.
++   bfd_elf_bfd_from_remote_memory () has too much overhead by
++   allocating/reading all the available ELF PT_LOADs.  */
++
++static struct build_id *
++build_id_phdr_get (bfd *templ, bfd_vma loadbase, unsigned e_phnum,
++		   Elf_Internal_Phdr *i_phdr)
++{
++  int i;
++  struct build_id *retval = NULL;
++
++  for (i = 0; i < e_phnum; i++)
++    if (i_phdr[i].p_type == PT_NOTE && i_phdr[i].p_filesz > 0)
++      {
++	Elf_Internal_Phdr *hdr = &i_phdr[i];
++	gdb_byte *buf;
++	int err;
++
++	buf = xmalloc (hdr->p_filesz);
++	err = target_read_memory (loadbase + i_phdr[i].p_vaddr, buf,
++				  hdr->p_filesz);
++	if (err == 0)
++	  retval = build_id_buf_get (templ, buf, hdr->p_filesz);
++	else
++	  retval = NULL;
++	xfree (buf);
++	if (retval != NULL)
++	  break;
++      }
++  return retval;
++}
++
++/* First we validate the file by reading in the ELF header and checking
++   the magic number.  */
++
++static inline bfd_boolean
++elf_file_p (Elf64_External_Ehdr *x_ehdrp64)
++{
++  gdb_assert (sizeof (Elf64_External_Ehdr) >= sizeof (Elf32_External_Ehdr));
++  gdb_assert (offsetof (Elf64_External_Ehdr, e_ident)
++	      == offsetof (Elf32_External_Ehdr, e_ident));
++  gdb_assert (sizeof (((Elf64_External_Ehdr *) 0)->e_ident)
++	      == sizeof (((Elf32_External_Ehdr *) 0)->e_ident));
++
++  return ((x_ehdrp64->e_ident[EI_MAG0] == ELFMAG0)
++	  && (x_ehdrp64->e_ident[EI_MAG1] == ELFMAG1)
++	  && (x_ehdrp64->e_ident[EI_MAG2] == ELFMAG2)
++	  && (x_ehdrp64->e_ident[EI_MAG3] == ELFMAG3));
++}
++
++/* Translate an ELF file header in external format into an ELF file header in
++   internal format.  */
++
++#define H_GET_WORD(bfd, ptr) (is64 ? H_GET_64 (bfd, (ptr))		\
++				   : H_GET_32 (bfd, (ptr)))
++#define H_GET_SIGNED_WORD(bfd, ptr) (is64 ? H_GET_S64 (bfd, (ptr))	\
++					  : H_GET_S32 (bfd, (ptr)))
++
++static void
++elf_swap_ehdr_in (bfd *abfd,
++		  const Elf64_External_Ehdr *src64,
++		  Elf_Internal_Ehdr *dst)
++{
++  int is64 = bfd_get_arch_size (abfd) == 64;
++#define SRC(field) (is64 ? src64->field \
++			 : ((const Elf32_External_Ehdr *) src64)->field)
++
++  int signed_vma = get_elf_backend_data (abfd)->sign_extend_vma;
++  memcpy (dst->e_ident, SRC (e_ident), EI_NIDENT);
++  dst->e_type = H_GET_16 (abfd, SRC (e_type));
++  dst->e_machine = H_GET_16 (abfd, SRC (e_machine));
++  dst->e_version = H_GET_32 (abfd, SRC (e_version));
++  if (signed_vma)
++    dst->e_entry = H_GET_SIGNED_WORD (abfd, SRC (e_entry));
++  else
++    dst->e_entry = H_GET_WORD (abfd, SRC (e_entry));
++  dst->e_phoff = H_GET_WORD (abfd, SRC (e_phoff));
++  dst->e_shoff = H_GET_WORD (abfd, SRC (e_shoff));
++  dst->e_flags = H_GET_32 (abfd, SRC (e_flags));
++  dst->e_ehsize = H_GET_16 (abfd, SRC (e_ehsize));
++  dst->e_phentsize = H_GET_16 (abfd, SRC (e_phentsize));
++  dst->e_phnum = H_GET_16 (abfd, SRC (e_phnum));
++  dst->e_shentsize = H_GET_16 (abfd, SRC (e_shentsize));
++  dst->e_shnum = H_GET_16 (abfd, SRC (e_shnum));
++  dst->e_shstrndx = H_GET_16 (abfd, SRC (e_shstrndx));
++
++#undef SRC
++}
++
++/* Translate an ELF program header table entry in external format into an
++   ELF program header table entry in internal format.  */
++
++void
++elf_swap_phdr_in (bfd *abfd,
++		  const Elf64_External_Phdr *src64,
++		  Elf_Internal_Phdr *dst)
++{
++  int is64 = bfd_get_arch_size (abfd) == 64;
++#define SRC(field) (is64 ? src64->field					\
++			 : ((const Elf32_External_Phdr *) src64)->field)
++
++  int signed_vma = get_elf_backend_data (abfd)->sign_extend_vma;
++
++  dst->p_type = H_GET_32 (abfd, SRC (p_type));
++  dst->p_flags = H_GET_32 (abfd, SRC (p_flags));
++  dst->p_offset = H_GET_WORD (abfd, SRC (p_offset));
++  if (signed_vma)
++    {
++      dst->p_vaddr = H_GET_SIGNED_WORD (abfd, SRC (p_vaddr));
++      dst->p_paddr = H_GET_SIGNED_WORD (abfd, SRC (p_paddr));
++    }
++  else
++    {
++      dst->p_vaddr = H_GET_WORD (abfd, SRC (p_vaddr));
++      dst->p_paddr = H_GET_WORD (abfd, SRC (p_paddr));
++    }
++  dst->p_filesz = H_GET_WORD (abfd, SRC (p_filesz));
++  dst->p_memsz = H_GET_WORD (abfd, SRC (p_memsz));
++  dst->p_align = H_GET_WORD (abfd, SRC (p_align));
++
++#undef SRC
++}
++
++#undef H_GET_SIGNED_WORD
++#undef H_GET_WORD
++
++static Elf_Internal_Phdr *
++elf_get_phdr (bfd *templ, bfd_vma ehdr_vma, unsigned *e_phnum_pointer,
++              bfd_vma *loadbase_pointer)
++{
++  /* sizeof (Elf64_External_Ehdr) >= sizeof (Elf32_External_Ehdr)  */
++  Elf64_External_Ehdr x_ehdr64;	/* Elf file header, external form */
++  Elf_Internal_Ehdr i_ehdr;	/* Elf file header, internal form */
++  bfd_size_type x_phdrs_size;
++  gdb_byte *x_phdrs_ptr;
++  Elf_Internal_Phdr *i_phdrs;
++  int err;
++  unsigned int i;
++  bfd_vma loadbase;
++  int loadbase_set;
++
++  gdb_assert (templ != NULL);
++  gdb_assert (sizeof (Elf64_External_Ehdr) >= sizeof (Elf32_External_Ehdr));
++
++  /* Read in the ELF header in external format.  */
++  err = target_read_memory (ehdr_vma, (bfd_byte *) &x_ehdr64, sizeof x_ehdr64);
++  if (err)
++    {
++      if (build_id_verbose >= BUILD_ID_VERBOSE_BINARY_PARSE)
++        warning (_("build-id: Error reading ELF header at address 0x%lx"),
++		 (unsigned long) ehdr_vma);
++      return NULL;
++    }
++
++  /* Now check to see if we have a valid ELF file, and one that BFD can
++     make use of.  The magic number must match, the address size ('class')
++     and byte-swapping must match our XVEC entry.  */
++
++  if (! elf_file_p (&x_ehdr64)
++      || x_ehdr64.e_ident[EI_VERSION] != EV_CURRENT
++      || !((bfd_get_arch_size (templ) == 64
++            && x_ehdr64.e_ident[EI_CLASS] == ELFCLASS64)
++           || (bfd_get_arch_size (templ) == 32
++	       && x_ehdr64.e_ident[EI_CLASS] == ELFCLASS32)))
++    {
++      if (build_id_verbose >= BUILD_ID_VERBOSE_BINARY_PARSE)
++        warning (_("build-id: Unrecognized ELF header at address 0x%lx"),
++		 (unsigned long) ehdr_vma);
++      return NULL;
++    }
++
++  /* Check that file's byte order matches xvec's */
++  switch (x_ehdr64.e_ident[EI_DATA])
++    {
++    case ELFDATA2MSB:		/* Big-endian */
++      if (! bfd_header_big_endian (templ))
++	{
++	  if (build_id_verbose >= BUILD_ID_VERBOSE_BINARY_PARSE)
++	    warning (_("build-id: Unrecognized "
++		       "big-endian ELF header at address 0x%lx"),
++		     (unsigned long) ehdr_vma);
++	  return NULL;
++	}
++      break;
++    case ELFDATA2LSB:		/* Little-endian */
++      if (! bfd_header_little_endian (templ))
++	{
++	  if (build_id_verbose >= BUILD_ID_VERBOSE_BINARY_PARSE)
++	    warning (_("build-id: Unrecognized "
++		       "little-endian ELF header at address 0x%lx"),
++		     (unsigned long) ehdr_vma);
++	  return NULL;
++	}
++      break;
++    case ELFDATANONE:		/* No data encoding specified */
++    default:			/* Unknown data encoding specified */
++      if (build_id_verbose >= BUILD_ID_VERBOSE_BINARY_PARSE)
++	warning (_("build-id: Unrecognized "
++		   "ELF header endianity at address 0x%lx"),
++		 (unsigned long) ehdr_vma);
++      return NULL;
++    }
++
++  elf_swap_ehdr_in (templ, &x_ehdr64, &i_ehdr);
++
++  /* The file header tells where to find the program headers.
++     These are what we use to actually choose what to read.  */
++
++  if (i_ehdr.e_phentsize != (bfd_get_arch_size (templ) == 64
++                             ? sizeof (Elf64_External_Phdr)
++			     : sizeof (Elf32_External_Phdr))
++      || i_ehdr.e_phnum == 0)
++    {
++      if (build_id_verbose >= BUILD_ID_VERBOSE_BINARY_PARSE)
++	warning (_("build-id: Invalid ELF program headers from the ELF header "
++		   "at address 0x%lx"), (unsigned long) ehdr_vma);
++      return NULL;
++    }
++
++  x_phdrs_size = (bfd_get_arch_size (templ) == 64 ? sizeof (Elf64_External_Phdr)
++						: sizeof (Elf32_External_Phdr));
++
++  i_phdrs = xmalloc (i_ehdr.e_phnum * (sizeof *i_phdrs + x_phdrs_size));
++  x_phdrs_ptr = (void *) &i_phdrs[i_ehdr.e_phnum];
++  err = target_read_memory (ehdr_vma + i_ehdr.e_phoff, (bfd_byte *) x_phdrs_ptr,
++			    i_ehdr.e_phnum * x_phdrs_size);
++  if (err)
++    {
++      free (i_phdrs);
++      if (build_id_verbose >= BUILD_ID_VERBOSE_BINARY_PARSE)
++        warning (_("build-id: Error reading "
++		   "ELF program headers at address 0x%lx"),
++		 (unsigned long) (ehdr_vma + i_ehdr.e_phoff));
++      return NULL;
++    }
++
++  loadbase = ehdr_vma;
++  loadbase_set = 0;
++  for (i = 0; i < i_ehdr.e_phnum; ++i)
++    {
++      elf_swap_phdr_in (templ, (Elf64_External_Phdr *)
++			       (x_phdrs_ptr + i * x_phdrs_size), &i_phdrs[i]);
++      /* IA-64 vDSO may have two mappings for one segment, where one mapping
++	 is executable only, and one is read only.  We must not use the
++	 executable one (PF_R is the first one, PF_X the second one).  */
++      if (i_phdrs[i].p_type == PT_LOAD && (i_phdrs[i].p_flags & PF_R))
++	{
++	  /* Only the first PT_LOAD segment indicates the file bias.
++	     Next segments may have P_VADDR arbitrarily higher.
++	     If the first segment has P_VADDR zero any next segment must not
++	     confuse us, the first one sets LOADBASE certainly enough.  */
++	  if (!loadbase_set && i_phdrs[i].p_offset == 0)
++	    {
++	      loadbase = ehdr_vma - i_phdrs[i].p_vaddr;
++	      loadbase_set = 1;
++	    }
++	}
++    }
++
++  if (build_id_verbose >= BUILD_ID_VERBOSE_BINARY_PARSE)
++    warning (_("build-id: Found ELF header at address 0x%lx, loadbase 0x%lx"),
++	     (unsigned long) ehdr_vma, (unsigned long) loadbase);
++
++  *e_phnum_pointer = i_ehdr.e_phnum;
++  *loadbase_pointer = loadbase;
++  return i_phdrs;
++}
++
++/* BUILD_ID_ADDR_GET gets ADDR located somewhere in the object.
++   Find the first section before ADDR containing an ELF header.
++   We rely on the fact the sections from multiple files do not mix.
++   FIXME: We should check ADDR is contained _inside_ the section with possibly
++   missing content (P_FILESZ < P_MEMSZ).  These omitted sections are currently
++   hidden by _BFD_ELF_MAKE_SECTION_FROM_PHDR.  */
++
++static CORE_ADDR build_id_addr;
++struct build_id_addr_sect
++  {
++    struct build_id_addr_sect *next;
++    asection *sect;
++  };
++static struct build_id_addr_sect *build_id_addr_sect;
++
++static void build_id_addr_candidate (bfd *abfd, asection *sect, void *obj)
++{
++  if (build_id_addr >= bfd_section_vma (abfd, sect))
++    {
++      struct build_id_addr_sect *candidate;
++
++      candidate = xmalloc (sizeof *candidate);
++      candidate->next = build_id_addr_sect;
++      build_id_addr_sect = candidate;
++      candidate->sect = sect;
++    }
++}
++
++struct build_id *
++build_id_addr_get (CORE_ADDR addr)
++{
++  struct build_id_addr_sect *candidate;
++  struct build_id *retval = NULL;
++  Elf_Internal_Phdr *i_phdr = NULL;
++  bfd_vma loadbase = 0;
++  unsigned e_phnum = 0;
++
++  if (core_bfd == NULL)
++    return NULL;
++
++  build_id_addr = addr;
++  gdb_assert (build_id_addr_sect == NULL);
++  bfd_map_over_sections (core_bfd, build_id_addr_candidate, NULL);
++
++  /* Sections are sorted in the high-to-low VMAs order.
++     Stop the search on the first ELF header we find.
++     Do not continue the search even if it does not contain NT_GNU_BUILD_ID.  */
++
++  for (candidate = build_id_addr_sect; candidate != NULL;
++       candidate = candidate->next)
++    {
++      i_phdr = elf_get_phdr (core_bfd,
++			     bfd_section_vma (core_bfd, candidate->sect),
++			     &e_phnum, &loadbase);
++      if (i_phdr != NULL)
++	break;
++    }
++
++  if (i_phdr != NULL)
++    {
++      retval = build_id_phdr_get (core_bfd, loadbase, e_phnum, i_phdr);
++      xfree (i_phdr);
++    }
++
++  while (build_id_addr_sect != NULL)
++    {
++      candidate = build_id_addr_sect;
++      build_id_addr_sect = candidate->next;
++      xfree (candidate);
++    }
++
++  return retval;
++}
++
+ /* Return if FILENAME has NT_GNU_BUILD_ID matching the CHECK value.  */
+ 
+ static int
+@@ -1081,7 +1477,7 @@ build_id_verify (const char *filename, s
+   if (abfd == NULL)
+     return 0;
+ 
+-  found = build_id_bfd_get (abfd);
++  found = build_id_bfd_shdr_get (abfd);
+ 
+   if (found == NULL)
+     warning (_("File \"%s\" has no build-id, file skipped"), filename);
+@@ -1099,14 +1495,15 @@ build_id_verify (const char *filename, s
+   return retval;
+ }
+ 
+-static char *
+-build_id_to_debug_filename (struct build_id *build_id)
++char *
++build_id_to_filename (struct build_id *build_id, char **link_return,
++		      int add_debug_suffix)
+ {
+   char *link, *debugdir, *retval = NULL;
++  char *link_all = NULL;
+ 
+   /* DEBUG_FILE_DIRECTORY/.build-id/ab/cdef */
+-  link = alloca (strlen (debug_file_directory) + (sizeof "/.build-id/" - 1) + 1
+-		 + 2 * build_id->size + (sizeof ".debug" - 1) + 1);
++  link = xmalloc (strlen (debug_file_directory) + 2 * build_id->size + 50);
+ 
+   /* Keep backward compatibility so that DEBUG_FILE_DIRECTORY being "" will
+      cause "/.build-id/..." lookups.  */
+@@ -1117,6 +1514,8 @@ build_id_to_debug_filename (struct build
+       char *s, *debugdir_end;
+       gdb_byte *data = build_id->data;
+       size_t size = build_id->size;
++      unsigned seqno;
++      struct stat statbuf_trash;
+ 
+       while (*debugdir == DIRNAME_SEPARATOR)
+ 	debugdir++;
+@@ -1137,39 +1536,242 @@ build_id_to_debug_filename (struct build
+ 	*s++ = '/';
+       while (size-- > 0)
+ 	s += sprintf (s, "%02x", (unsigned) *data++);
+-      strcpy (s, ".debug");
+-
+-      /* lrealpath() is expensive even for the usually non-existent files.  */
+-      if (access (link, F_OK) == 0)
+-	retval = lrealpath (link);
+ 
+-      if (retval != NULL && !build_id_verify (retval, build_id))
++      for (seqno = 0;; seqno++)
+ 	{
+-	  xfree (retval);
+-	  retval = NULL;
++	  char *s2;
++
++	  if (seqno)
++	    {
++	      /* There can be multiple build-id symlinks pointing to real files
++		 with the same build-id (such as hard links).  Some of the real
++		 files may not be installed.  */
++
++	      s2 = s + sprintf (s, ".%u", seqno);
++	    }
++	  else
++	    s2 = s;
++
++	  if (add_debug_suffix)
++	    strcpy (s2, ".debug");
++	  else
++	    *s2 = 0;
++
++	  /* `access' automatically dereferences LINK.  */
++	  if (lstat (link, &statbuf_trash) != 0)
++	    {
++	      /* Stop increasing SEQNO.  */
++	      break;
++	    }
++
++	  retval = lrealpath (link);
++
++	  if (retval != NULL && !build_id_verify (retval, build_id))
++	    {
++	      xfree (retval);
++	      retval = NULL;
++	    }
++
++	  if (retval)
++	    break;
+ 	}
+ 
+       if (retval != NULL)
+-	break;
++	{
++	  /* LINK_ALL is not used below in this non-NULL RETVAL case.  */
++	  break;
++	}
++
++	if (link_all == NULL)
++	  link_all = xstrdup (link);
++	else
++	  {
++	    size_t len_orig = strlen (link_all);
++
++	    link_all = xrealloc (link_all, len_orig + 1 + strlen (link) + 1);
++
++	    /* Use whitespace instead of DIRNAME_SEPARATOR to be compatible with
++	       its possible use as an argument for installation command.  */
++	    link_all[len_orig] = ' ';
++
++	    strcpy (&link_all[len_orig + 1], link);
++	  }
+ 
+       debugdir = debugdir_end;
+     }
+   while (*debugdir != 0);
+ 
++  if (link_return != NULL)
++    {
++      if (retval != NULL)
++       {
++         *link_return = link;
++         link = NULL;
++       }
++      else
++       {
++         *link_return = link_all;
++         link_all = NULL;
++       }
++    }
++  xfree (link);
++  xfree (link_all);
++
++  return retval;
++}
++
++/* This MISSING_FILEPAIR_HASH tracker is used only for the duplicite messages
++     Try to install the hash file ...
++   avoidance.  */
++
++struct missing_filepair
++  {
++    char *binary;
++    char *debug;
++    char data[1];
++  };
++
++static struct htab *missing_filepair_hash;
++static struct obstack missing_filepair_obstack;
++
++static void *
++missing_filepair_xcalloc (size_t nmemb, size_t nmemb_size)
++{
++  void *retval;
++  size_t size = nmemb * nmemb_size;
++
++  retval = obstack_alloc (&missing_filepair_obstack, size);
++  memset (retval, 0, size);
+   return retval;
+ }
+ 
++static hashval_t
++missing_filepair_hash_func (const struct missing_filepair *elem)
++{
++  hashval_t retval = 0;
++
++  retval ^= htab_hash_string (elem->binary);
++  if (elem->debug != NULL)
++    retval ^= htab_hash_string (elem->debug);
++
++  return retval;
++}
++
++static int
++missing_filepair_eq (const struct missing_filepair *elem1,
++		       const struct missing_filepair *elem2)
++{
++  return strcmp (elem1->binary, elem2->binary) == 0
++         && ((elem1->debug == NULL) == (elem2->debug == NULL))
++         && (elem1->debug == NULL || strcmp (elem1->debug, elem2->debug) == 0);
++}
++
++static void
++missing_filepair_change (void)
++{
++  if (missing_filepair_hash != NULL)
++    {
++      obstack_free (&missing_filepair_obstack, NULL);
++      /* All their memory came just from missing_filepair_OBSTACK.  */
++      missing_filepair_hash = NULL;
++    }
++}
++
++static void
++debug_print_executable_changed (void)
++{
++  missing_filepair_change ();
++}
++
++/* Notify user the file BINARY with (possibly NULL) associated separate debug
++   information file DEBUG is missing.  DEBUG may or may not be the build-id
++   file such as would be:
++     /usr/lib/debug/.build-id/dd/b1d2ce632721c47bb9e8679f369e2295ce71be.debug
++   */
++
++void
++debug_print_missing (const char *binary, const char *debug)
++{
++  size_t binary_len0 = strlen (binary) + 1;
++  size_t debug_len0 = debug ? strlen (debug) + 1 : 0;
++  struct missing_filepair missing_filepair_find;
++  struct missing_filepair *missing_filepair;
++  struct missing_filepair **slot;
++
++  if (build_id_verbose < BUILD_ID_VERBOSE_FILENAMES)
++    return;
++
++  if (missing_filepair_hash == NULL)
++    {
++      obstack_init (&missing_filepair_obstack);
++      missing_filepair_hash = htab_create_alloc (64,
++	(hashval_t (*) (const void *)) missing_filepair_hash_func,
++	(int (*) (const void *, const void *)) missing_filepair_eq, NULL,
++	missing_filepair_xcalloc, NULL);
++    }
++
++  /* Use MISSING_FILEPAIR_FIND first instead of calling obstack_alloc with
++     obstack_free in the case of a (rare) match.  The problem is ALLOC_F for
++     MISSING_FILEPAIR_HASH allocates from MISSING_FILEPAIR_OBSTACK maintenance
++     structures for MISSING_FILEPAIR_HASH.  Calling obstack_free would possibly
++     not to free only MISSING_FILEPAIR but also some such structures (allocated
++     during the htab_find_slot call).  */
++
++  missing_filepair_find.binary = (char *) binary;
++  missing_filepair_find.debug = (char *) debug;
++  slot = (struct missing_filepair **) htab_find_slot (missing_filepair_hash,
++						      &missing_filepair_find,
++						      INSERT);
++
++  /* While it may be still printed duplicitely with the missing debuginfo file
++   * it is due to once printing about the binary file build-id link and once
++   * about the .debug file build-id link as both the build-id symlinks are
++   * located in the debuginfo package.  */
++
++  if (*slot != NULL)
++    return;
++
++  missing_filepair = obstack_alloc (&missing_filepair_obstack,
++				      sizeof (*missing_filepair) - 1
++				      + binary_len0 + debug_len0);
++  missing_filepair->binary = missing_filepair->data;
++  memcpy (missing_filepair->binary, binary, binary_len0);
++  if (debug != NULL)
++    {
++      missing_filepair->debug = missing_filepair->binary + binary_len0;
++      memcpy (missing_filepair->debug, debug, debug_len0);
++    }
++  else
++    missing_filepair->debug = NULL;
++
++  *slot = missing_filepair;
++
++  /* We do not collect and flush these messages as each such message
++     already requires its own separate lines.  */
++
++  fprintf_unfiltered (gdb_stdlog,
++		      _("Missing separate debuginfo for %s\n"), binary);
++  if (debug != NULL)
++    fprintf_unfiltered (gdb_stdlog, _("Try to install the hash file %s\n"),
++			debug);
++}
++
+ static char *
+-find_separate_debug_file_by_buildid (struct objfile *objfile)
++find_separate_debug_file_by_buildid (struct objfile *objfile,
++				     char **build_id_filename_return)
+ {
+   struct build_id *build_id;
+ 
+-  build_id = build_id_bfd_get (objfile->obfd);
++  if (build_id_filename_return)
++    *build_id_filename_return = NULL;
++
++  build_id = build_id_bfd_shdr_get (objfile->obfd);
+   if (build_id != NULL)
+     {
+       char *build_id_name;
+ 
+-      build_id_name = build_id_to_debug_filename (build_id);
++      build_id_name = build_id_to_filename (build_id, build_id_filename_return,
++					    1);
+       xfree (build_id);
+       /* Prevent looping on a stripped .debug file.  */
+       if (build_id_name != NULL
+@@ -1180,7 +1782,7 @@ find_separate_debug_file_by_buildid (str
+ 	  xfree (build_id_name);
+ 	}
+       else if (build_id_name != NULL)
+-        return build_id_name;
++	return build_id_name;
+     }
+   return NULL;
+ }
+@@ -1400,9 +2002,10 @@ elf_symfile_read (struct objfile *objfil
+      `.note.gnu.build-id'.  */
+   else if (!objfile_has_partial_symbols (objfile))
+     {
+-      char *debugfile;
++      char *debugfile, *build_id_filename;
+ 
+-      debugfile = find_separate_debug_file_by_buildid (objfile);
++      debugfile = find_separate_debug_file_by_buildid (objfile,
++						       &build_id_filename);
+ 
+       if (debugfile == NULL)
+ 	debugfile = find_separate_debug_file_by_debuglink (objfile);
+@@ -1414,6 +2017,12 @@ elf_symfile_read (struct objfile *objfil
+ 	  symbol_file_add_separate (abfd, symfile_flags, objfile);
+ 	  xfree (debugfile);
+ 	}
++      /* Check if any separate debug info has been extracted out.  */
++      else if (bfd_get_section_by_name (objfile->obfd, ".gnu_debuglink")
++	       != NULL)
++	debug_print_missing (objfile->name, build_id_filename);
++
++      xfree (build_id_filename);
+     }
+ }
+ 
+@@ -1629,4 +2238,16 @@ _initialize_elfread (void)
+ 
+   elf_objfile_gnu_ifunc_cache_data = register_objfile_data ();
+   gnu_ifunc_fns_p = &elf_gnu_ifunc_fns;
++
++  add_setshow_zinteger_cmd ("build-id-verbose", no_class, &build_id_verbose,
++			    _("\
++Set debugging level of the build-id locator."), _("\
++Show debugging level of the build-id locator."), _("\
++Level 1 (default) enables printing the missing debug filenames,\n\
++level 2 also prints the parsing of binaries to find the identificators."),
++			    NULL,
++			    show_build_id_verbose,
++			    &setlist, &showlist);
++
++  observer_attach_executable_changed (debug_print_executable_changed);
+ }
+Only in gdb-7.4/gdb: elfread.c.orig
+Only in gdb-7.4/gdb: elfread.c.rej
+diff -rup gdb-7.4-clean/gdb/objfiles.h gdb-7.4/gdb/objfiles.h
+--- gdb-7.4-clean/gdb/objfiles.h	2012-01-06 05:43:21.000000000 +0100
++++ gdb-7.4/gdb/objfiles.h	2012-04-02 10:30:11.108170086 +0200
+@@ -433,6 +433,10 @@ struct objfile
+ 
+ #define OBJF_MAINLINE (1 << 5)
+ 
++/* This file was loaded according to the BUILD_ID_CORE_LOADS rules.  */
++
++#define OBJF_BUILD_ID_CORE_LOADED (1 << 12)
++
+ /* The object file that contains the runtime common minimal symbols
+    for SunOS4.  Note that this objfile has no associated BFD.  */
+ 
+diff -rup gdb-7.4-clean/gdb/solib-svr4.c gdb-7.4/gdb/solib-svr4.c
+--- gdb-7.4-clean/gdb/solib-svr4.c	2012-01-06 05:43:30.000000000 +0100
++++ gdb-7.4/gdb/solib-svr4.c	2012-04-02 10:30:11.104170086 +0200
+@@ -1227,9 +1227,52 @@ svr4_read_so_list (CORE_ADDR lm, struct
+ 	  continue;
+ 	}
+ 
+-      strncpy (new->so_name, buffer, SO_NAME_MAX_PATH_SIZE - 1);
+-      new->so_name[SO_NAME_MAX_PATH_SIZE - 1] = '\0';
+-      strcpy (new->so_original_name, new->so_name);
++      {
++	struct build_id *build_id;
++
++	strncpy (new->so_original_name, buffer, SO_NAME_MAX_PATH_SIZE - 1);
++	new->so_original_name[SO_NAME_MAX_PATH_SIZE - 1] = '\0';
++	/* May get overwritten below.  */
++	strcpy (new->so_name, new->so_original_name);
++
++	build_id = build_id_addr_get (new->lm_info->l_ld);
++	if (build_id != NULL)
++	  {
++	    char *name, *build_id_filename;
++
++	    /* Missing the build-id matching separate debug info file
++	       would be handled while SO_NAME gets loaded.  */
++	    name = build_id_to_filename (build_id, &build_id_filename, 0);
++	    if (name != NULL)
++	      {
++		strncpy (new->so_name, name, SO_NAME_MAX_PATH_SIZE - 1);
++		new->so_name[SO_NAME_MAX_PATH_SIZE - 1] = '\0';
++		xfree (name);
++	      }
++	    else
++	      {
++		debug_print_missing (new->so_name, build_id_filename);
++
++		/* In the case the main executable was found according to
++		   its build-id (from a core file) prevent loading
++		   a different build of a library with accidentally the
++		   same SO_NAME.
++
++		   It suppresses bogus backtraces (and prints "??" there
++		   instead) if the on-disk files no longer match the
++		   running program version.  */
++
++		if (symfile_objfile != NULL
++		    && (symfile_objfile->flags
++			& OBJF_BUILD_ID_CORE_LOADED) != 0)
++		  new->so_name[0] = 0;
++	      }
++
++	    xfree (build_id_filename);
++	    xfree (build_id);
++	  }
++      }
++
+       xfree (buffer);
+ 
+       /* If this entry has no name, or its name matches the name
+diff -rup gdb-7.4-clean/gdb/symfile.h gdb-7.4/gdb/symfile.h
+--- gdb-7.4-clean/gdb/symfile.h	2012-01-06 05:43:31.000000000 +0100
++++ gdb-7.4/gdb/symfile.h	2012-04-02 10:30:11.108170086 +0200
+@@ -560,6 +560,13 @@ void free_symfile_segment_data (struct s
+ 
+ extern struct cleanup *increment_reading_symtab (void);
+ 
++/* build-id support.  */
++struct build_id;
++extern struct build_id *build_id_addr_get (CORE_ADDR addr);
++extern char *build_id_to_filename (struct build_id *build_id,
++				   char **link_return, int add_debug_suffix);
++extern void debug_print_missing (const char *binary, const char *debug);
++
+ /* From dwarf2read.c */
+ 
+ /* Names for a dwarf2 debugging section.  The field NORMAL is the normal
+Only in gdb-7.4/gdb: symfile.h.orig
+diff -rup gdb-7.4-clean/gdb/testsuite/lib/gdb.exp gdb-7.4/gdb/testsuite/lib/gdb.exp
+--- gdb-7.4-clean/gdb/testsuite/lib/gdb.exp	2012-01-06 05:54:30.000000000 +0100
++++ gdb-7.4/gdb/testsuite/lib/gdb.exp	2012-04-02 10:30:11.108170086 +0200
+@@ -1392,6 +1392,16 @@ proc default_gdb_start { } {
+ 	    warning "Couldn't set the width to 0."
+ 	}
+     }
++    # Turn off the missing warnings as the testsuite does not expect it.
++    send_gdb "set build-id-verbose 0\n"
++    gdb_expect 10 {
++	-re "$gdb_prompt $" {
++	    verbose "Disabled the missing debug infos warnings." 2
++	}
++	timeout {
++	    warning "Could not disable the missing debug infos warnings.."
++	}
++    }
+     return 0;
+ }
+ 
+Only in gdb-7.4/gdb/testsuite/lib: gdb.exp.orig
+diff -rup gdb-7.4-clean/gdb/testsuite/lib/mi-support.exp gdb-7.4/gdb/testsuite/lib/mi-support.exp
+--- gdb-7.4-clean/gdb/testsuite/lib/mi-support.exp	2012-01-06 05:54:30.000000000 +0100
++++ gdb-7.4/gdb/testsuite/lib/mi-support.exp	2012-04-02 10:30:11.108170086 +0200
+@@ -212,6 +212,16 @@ proc default_mi_gdb_start { args } {
+ 	    warning "Couldn't set the width to 0."
+ 	}
+     }
++    # Turn off the missing warnings as the testsuite does not expect it.
++    send_gdb "190-gdb-set build-id-verbose 0\n"
++    gdb_expect 10 {
++	-re ".*190-gdb-set build-id-verbose 0\r\n190\\\^done\r\n$mi_gdb_prompt$" {
++	    verbose "Disabled the missing debug infos warnings." 2
++	}
++	timeout {
++	    warning "Could not disable the missing debug infos warnings.."
++	}
++    }
+     # If allowing the inferior to have its own PTY then assign the inferior
+     # its own terminal device here.
+     if { $separate_inferior_pty } {
diff --git a/dist/gdb/patches/gdb-ipv6.patch b/dist/gdb/patches/gdb-ipv6.patch
new file mode 100644
index 0000000000..d5abf5f6c4
--- /dev/null
+++ b/dist/gdb/patches/gdb-ipv6.patch
@@ -0,0 +1,1100 @@
+diff -rup gdb-7.4-clean/gdb/gdbserver/gdbreplay.c gdb-7.4/gdb/gdbserver/gdbreplay.c
+--- gdb-7.4-clean/gdb/gdbserver/gdbreplay.c	2012-03-30 15:07:01.540553998 +0200
++++ gdb-7.4/gdb/gdbserver/gdbreplay.c	2012-03-30 15:08:39.484553844 +0200
+@@ -188,14 +188,41 @@ remote_close (void)
+ static void
+ remote_open (char *name)
+ {
+-  if (!strchr (name, ':'))
++  char *port_str;
++  char *host_start, *host_end;
++  
++  host_start = name;
++  if (host_start[0] == '[')
+     {
+-      fprintf (stderr, "%s: Must specify tcp connection as host:addr\n", name);
+-      fflush (stderr);
+-      exit (1);
++      ++host_start;
++      host_end = strchr (host_start, ']');
++      if (host_end == NULL)
++        {
++          fprintf (stderr, "Mismatched `[' in hostname.");
++          fflush (stderr);
++          exit (1);
++        }
++      port_str = host_end + 1;
++      if (*port_str != ':')
++        {
++          fprintf (stderr, "Missing port after hostname, specify tcp connection as host:port or [host]:port.");
++          fflush (stderr);
++          exit (1);
++        }
+     }
+   else
+     {
++      port_str = strchr (name, ':');
++      host_end = port_str;
++      if (port_str == NULL)
++        {
++          fprintf (stderr, "Missing port after hostname, specify tcp connection as host:port or [host]:port.");
++          fflush (stderr);
++          exit(1);
++        }
++    }
++  
++    {
+ #ifdef USE_WIN32API
+       static int winsock_initialized;
+ #endif
+diff -rup gdb-7.4-clean/gdb/gdbserver/remote-utils.c gdb-7.4/gdb/gdbserver/remote-utils.c
+--- gdb-7.4-clean/gdb/gdbserver/remote-utils.c	2012-03-30 15:07:01.540553998 +0200
++++ gdb-7.4/gdb/gdbserver/remote-utils.c	2012-03-30 15:33:24.252551493 +0200
+@@ -16,6 +16,8 @@
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
+ 
++#define _WIN32_WINNT 0x501
++
+ #include "server.h"
+ #include "terminal.h"
+ #include "target.h"
+@@ -62,6 +64,9 @@
+ 
+ #if USE_WIN32API
+ #include <winsock2.h>
++#include <ws2tcpip.h>
++#else
++#include <netinet/in.h>	/* sockaddr_in{} and other Internet defns */
+ #endif
+ 
+ #if __QNX__
+@@ -106,7 +111,7 @@ int remote_debug = 0;
+ struct ui_file *gdb_stdlog;
+ 
+ static gdb_fildes_t remote_desc = INVALID_DESCRIPTOR;
+-static gdb_fildes_t listen_desc = INVALID_DESCRIPTOR;
++gdb_fildes_t *listening_sockets = NULL;
+ 
+ /* FIXME headerize? */
+ extern int using_threads;
+@@ -145,15 +150,17 @@ enable_async_notification (int fd)
+ static int
+ handle_accept_event (int err, gdb_client_data client_data)
+ {
+-  struct sockaddr_in sockaddr;
++  struct sockaddr_storage address;
+   socklen_t tmp;
++  char back_host[64], back_port[16];
++  gdb_fildes_t listen_desc = *(gdb_fildes_t *)client_data;
+ 
+   if (debug_threads)
+     fprintf (stderr, "handling possible accept event\n");
+ 
+-  tmp = sizeof (sockaddr);
+-  remote_desc = accept (listen_desc, (struct sockaddr *) &sockaddr, &tmp);
+-  if (remote_desc == -1)
++  tmp = (socklen_t) sizeof (address);
++  remote_desc = accept (listen_desc, (struct sockaddr *) &address, &tmp);
++  if (remote_desc == INVALID_DESCRIPTOR)
+     perror_with_name ("Accept failed");
+ 
+   /* Enable TCP keep alive process. */
+@@ -167,27 +174,55 @@ handle_accept_event (int err, gdb_client
+   setsockopt (remote_desc, IPPROTO_TCP, TCP_NODELAY,
+ 	      (char *) &tmp, sizeof (tmp));
+ 
++  if (listening_sockets)
++    {
++      /* We assume that all sockets have been registered, and none triggers
++         while doing this. This is true in the current single threaded
++         implementation.  */
++      gdb_fildes_t *l_sock = listening_sockets;
++      for (++l_sock; *l_sock != INVALID_DESCRIPTOR; ++l_sock)
++        {
+ #ifndef USE_WIN32API
+-  signal (SIGPIPE, SIG_IGN);	/* If we don't do this, then gdbserver simply
+-				   exits when the remote side dies.  */
++          signal (SIGPIPE, SIG_IGN);	/* If we don't do this, then gdbserver simply
++                                   exits when the remote side dies.  */
+ #endif
+ 
+-  if (run_once)
+-    {
++          if (run_once)
++            {
+ #ifndef USE_WIN32API
+-      close (listen_desc);		/* No longer need this */
++              close (*l_sock);		/* No longer need this */
+ #else
+-      closesocket (listen_desc);	/* No longer need this */
++              closesocket (*l_sock);	/* No longer need this */
+ #endif
+-    }
++            }
+ 
+-  /* Even if !RUN_ONCE no longer notice new connections.  Still keep the
++          /* Even if !RUN_ONCE no longer notice new connections.  Still keep the
+      descriptor open for add_file_handler to wait for a new connection.  */
+-  delete_file_handler (listen_desc);
++          delete_file_handler (*l_sock);
++        }
++      if (run_once)
++        {
++          free(listening_sockets);
++          listening_sockets = NULL;
++        }
++    }
+ 
+   /* Convert IP address to string.  */
+-  fprintf (stderr, "Remote debugging from host %s\n",
+-	   inet_ntoa (sockaddr.sin_addr));
++  if (getnameinfo ((struct sockaddr *) &address,
++                   (socklen_t) sizeof (address),
++                   back_host, (socklen_t) sizeof (back_host),
++                   back_port, (socklen_t) sizeof (back_port),
++                   NI_NUMERICHOST | NI_NUMERICSERV))
++    {
++      fprintf (stderr, "Error detecting originating address, trying anyway\n");
++    }
++  else
++    {
++      back_host[sizeof (back_host) - 1] = 0;
++      back_port[sizeof (back_port) - 1] = 0;
++      fprintf (stderr, "Remote debugging from host %s port %s\n",
++               back_host, back_port);
++    }
+ 
+   enable_async_notification (remote_desc);
+ 
+@@ -213,12 +248,15 @@ remote_prepare (char *name)
+ {
+   char *port_str;
+ #ifdef USE_WIN32API
+-  static int winsock_initialized;
++  static int winsock_initialized = 0;
+ #endif
+-  int port;
+-  struct sockaddr_in sockaddr;
+-  socklen_t tmp;
+-  char *port_end;
++  char *host_start, *host_end;
++  struct addrinfo hints, *ainfo, *ainfo0;
++  gdb_fildes_t *socktable = NULL;
++  gdb_fildes_t s = INVALID_DESCRIPTOR;
++  int nsock = 0, socktable_size = 0, err, port = 0;
++  char *host_str = NULL;
++  char back_host[128], back_port[32];
+ 
+   port_str = strchr (name, ':');
+   if (port_str == NULL)
+@@ -227,7 +265,23 @@ remote_prepare (char *name)
+       return;
+     }
+ 
+-  port = strtoul (port_str + 1, &port_end, 10);
+-  if (port_str[1] == '\0' || *port_end != '\0')
++  host_start = name;
++  if (host_start[0] == '[')
++    {
++      ++host_start;
++      host_end = strchr (host_start, ']');
++      if (host_end == NULL)
++        fatal ("Mismatched `[' in hostname.");
++      port_str = host_end + 1;
++      if (*port_str != ':')
++        fatal ("Missing port after hostname.");
++    }
++  else
++    {
++      port_str = strchr (name, ':');
++      host_end = port_str;
++    }
++
++  if (port_str[1] == '\0')
+     fatal ("Bad port argument: %s", name);
+ 
+@@ -241,24 +295,181 @@ remote_prepare (char *name)
+     }
+ #endif
+ 
+-  listen_desc = socket (PF_INET, SOCK_STREAM, IPPROTO_TCP);
+-  if (listen_desc == -1)
+-    perror_with_name ("Can't open socket");
++  if (host_start < host_end)
++    {
++      host_str = strdup(host_start);
++	  host_str[host_end - host_start] = 0;
++	}
++  ++port_str;
+ 
+-  /* Allow rapid reuse of this port. */
+-  tmp = 1;
+-  setsockopt (listen_desc, SOL_SOCKET, SO_REUSEADDR, (char *) &tmp,
+-	      sizeof (tmp));
++  memset(&hints, 0, sizeof(hints));
++  hints.ai_family = PF_UNSPEC;
++  hints.ai_socktype = SOCK_STREAM;
++  hints.ai_flags = AI_PASSIVE;
++
++  err = getaddrinfo(host_str, port_str, &hints, &ainfo0);
++  if (err)
++      fatal ("%s for %s", gai_strerror(err), name);
+ 
+-  sockaddr.sin_family = PF_INET;
+-  sockaddr.sin_port = htons (port);
+-  sockaddr.sin_addr.s_addr = INADDR_ANY;
+-
+-  if (bind (listen_desc, (struct sockaddr *) &sockaddr, sizeof (sockaddr))
+-      || listen (listen_desc, 1))
+-    perror_with_name ("Can't bind address");
++  for (ainfo = ainfo0; ainfo; ainfo = ainfo->ai_next)
++    {
++      int current_port, tmp;
++
++      if (getnameinfo ((struct sockaddr *) ainfo->ai_addr,
++                       (socklen_t) ainfo->ai_addrlen,
++                       back_host, (socklen_t) sizeof (back_host),
++                       back_port, (socklen_t) sizeof (back_port),
++                       NI_NUMERICHOST | NI_NUMERICSERV))
++        {
++          back_host[0] = 0;
++          back_port[0] = 0;
++        }
++      else
++        {
++          back_host[sizeof (back_host) - 1] = 0;
++          back_port[sizeof (back_port) - 1] = 0;
++        }
++
++      switch (ainfo->ai_addr->sa_family)
++        {
++        case AF_INET:
++          current_port = ntohs (((struct sockaddr_in *) ainfo->ai_addr)
++                               ->sin_port);
++          break;
++        case AF_INET6:
++          current_port = ntohs (((struct sockaddr_in6 *) ainfo->ai_addr)
++                                 ->sin6_port);
++          break;
++        default:
++          fatal ("Unexpected address family: %d for %s %s",
++                 ainfo->ai_addr->sa_family,back_host,back_port);
++        }
++
++	  if (port != 0 && current_port == 0)
++	    {
++	      /* Use the same port for all protocol/interfaces.  */
++	      switch (ainfo->ai_addr->sa_family)
++		{
++		case AF_INET:
++		  ((struct sockaddr_in *) ainfo->ai_addr)->sin_port =
++		    htons(port);
++		  break;
++		case AF_INET6:
++		  ((struct sockaddr_in6 *) ainfo->ai_addr)->sin6_port =
++		    htons(port);
++		  break;
++		}
++	    }
++      s = socket(ainfo->ai_family, ainfo->ai_socktype, ainfo->ai_protocol);
++      if (s < 0)
++        continue;
++
++      /* Allow rapid reuse of this port.  */
++      tmp = 1;
++      if (setsockopt (s, SOL_SOCKET, SO_REUSEADDR, (char *) &tmp,
++                      (socklen_t) sizeof (tmp)) != 0)
++        {
++          fprintf (stderr, "Trying to bind %s port %s.\n",
++                   back_host, back_port);
++          perror("setsockopt(s, SOL_SOCKET, SO_REUSEADDR,[1],4)");
++        }
++#ifdef IPV6_V6ONLY
++      if (ainfo->ai_addr->sa_family == AF_INET6
++          && setsockopt (s, SOL_IPV6, IPV6_V6ONLY, (char *) &tmp,
++                         (socklen_t) sizeof (tmp)) != 0)
++        {
++          fprintf (stderr, "Trying to bind %s port %s.\n",
++                   back_host, back_port);
++          perror("setsockopt(s, SOL_IPV6, IPV6_V6ONLY,[1],4)");
++        }
++#endif
++
++      if (bind (s, ainfo->ai_addr, ainfo->ai_addrlen) != 0)
++        {
++          fprintf (stderr, "Trying to bind %s port %s.\n",
++                   back_host, back_port);
++          perror ("bind failed");
++          close (s);
++          s = -1;
++          continue;
++        }
++
++      if (listen (s, 1) != 0)
++        {
++          fprintf (stderr, "Trying to bind %s port %s.\n",
++                   back_host, back_port);
++          perror ("Can't listen to a bound socket");
++          close (s);
++          s = -1;
++          continue;
++        }
++
++      {
++        struct sockaddr_storage address;
++        socklen_t alen = (socklen_t) sizeof (address);
++
++        if (getsockname (s, (struct sockaddr *) &address, &alen))
++          fatal ("Failed to get socket address %s, on soket bound to %s port %s.",
++                 strerror (errno), back_host, back_port);
++
++        if (port == 0)
++	    /* Try to recover the port set by the kernel.  */
++          switch (address.ss_family)
++            {
++            case AF_INET:
++              port = ntohs (((struct sockaddr_in *) &address)->sin_port);
++              break;
++            case AF_INET6:
++              port = ntohs (((struct sockaddr_in6 *) &address)->sin6_port);
++              break;
++            default:
++              fatal ("Unexpected address family: %d", address.ss_family);
++            }
++	
++        if (getnameinfo ((struct sockaddr *) &address,
++                         (socklen_t) sizeof (address),
++                         back_host, (socklen_t) sizeof (back_host),
++                         back_port, (socklen_t) sizeof (back_port),
++                         NI_NUMERICHOST | NI_NUMERICSERV))
++          {
++            fprintf (stderr, "Error detecting bound address.\n");
++          }
++        else
++          {
++            back_host[sizeof (back_host) - 1] = 0;
++            back_port[sizeof (back_port) - 1] = 0;
++            fprintf (stderr, "Sucessfully bound %s port %s\n",
++                     back_host, back_port);
++          }
++      }
++
++      if (socktable_size < nsock + 3)
++        {
++          socktable = xrealloc (socktable,
++                                (nsock + 10) * sizeof (gdb_fildes_t));
++          socktable[0] = INVALID_DESCRIPTOR;
++        }
++      socktable[++nsock] = s;
++  }
++
++  freeaddrinfo (ainfo0);
++  free (host_str);
++
++  if (nsock == 0)
++      fatal("Failed to bind any socket.");
++
++  /* Bound socktable from both ends, so an inner pointer can still
++     find the whole array. */
++  socktable[++nsock] = INVALID_DESCRIPTOR;
+ 
+   transport_is_reliable = 1;
++  fprintf (stderr, "Listening on port %d\n", port);
++  fflush (stderr);
++  transport_is_reliable = 1;
++  if (listening_sockets)
++    fatal ("Multiple concurrent remote_open not supported.");
++
++  listening_sockets = socktable;
+ }
+ 
+ /* Open a connection to a remote debugger.
+@@ -268,8 +479,25 @@ void
+ remote_open (char *name)
+ {
+   char *port_str;
++  char *host_start, *host_end;
++
++  host_start = name;
++  if (host_start[0] == '[')
++    {
++      ++host_start;
++      host_end = strchr (host_start, ']');
++      if (host_end == NULL)
++        fatal ("Mismatched `[' in hostname.");
++      port_str = host_end + 1;
++      if (*port_str != ':')
++        fatal ("Missing port after hostname.");
++    }
++  else
++    {
++      port_str = strchr (name, ':');
++      host_end = port_str;
++    }
+ 
+-  port_str = strchr (name, ':');
+   if (port_str == NULL)
+     {
+ #ifdef USE_WIN32API
+@@ -278,21 +506,21 @@ remote_open (char *name)
+       struct stat statbuf;
+ 
+       if (stat (name, &statbuf) == 0
+-	  && (S_ISCHR (statbuf.st_mode) || S_ISFIFO (statbuf.st_mode)))
+-	remote_desc = open (name, O_RDWR);
++          && (S_ISCHR (statbuf.st_mode) || S_ISFIFO (statbuf.st_mode)))
++        remote_desc = open (name, O_RDWR);
+       else
+-	{
+-	  errno = EINVAL;
+-	  remote_desc = -1;
+-	}
++        {
++          errno = EINVAL;
++          remote_desc = -1;
++        }
+ 
+       if (remote_desc < 0)
+-	perror_with_name ("Could not open remote device");
++        perror_with_name ("Could not open remote device");
+ 
+ #ifdef HAVE_TERMIOS
+       {
+-	struct termios termios;
+-	tcgetattr (remote_desc, &termios);
++        struct termios termios;
++        tcgetattr (remote_desc, &termios);
+ 
+ 	termios.c_iflag = 0;
+ 	termios.c_oflag = 0;
+@@ -302,14 +530,14 @@ remote_open (char *name)
+ 	termios.c_cc[VMIN] = 1;
+ 	termios.c_cc[VTIME] = 0;
+ 
+-	tcsetattr (remote_desc, TCSANOW, &termios);
++        tcsetattr (remote_desc, TCSANOW, &termios);
+       }
+ #endif
+ 
+ #ifdef HAVE_TERMIO
+       {
+-	struct termio termio;
+-	ioctl (remote_desc, TCGETA, &termio);
++        struct termio termio;
++        ioctl (remote_desc, TCGETA, &termio);
+ 
+ 	termio.c_iflag = 0;
+ 	termio.c_oflag = 0;
+@@ -319,13 +547,13 @@ remote_open (char *name)
+ 	termio.c_cc[VMIN] = 1;
+ 	termio.c_cc[VTIME] = 0;
+ 
+-	ioctl (remote_desc, TCSETA, &termio);
++        ioctl (remote_desc, TCSETA, &termio);
+       }
+ #endif
+ 
+ #ifdef HAVE_SGTTY
+       {
+-	struct sgttyb sg;
++        struct sgttyb sg;
+ 
+ 	ioctl (remote_desc, TIOCGETP, &sg);
+ 	sg.sg_flags = RAW;
+@@ -343,22 +571,17 @@ remote_open (char *name)
+     }
+   else
+     {
+-      int port;
+-      socklen_t len;
+-      struct sockaddr_in sockaddr;
+-
+-      len = sizeof (sockaddr);
+-      if (getsockname (listen_desc,
+-		       (struct sockaddr *) &sockaddr, &len) < 0
+-	  || len < sizeof (sockaddr))
+-	perror_with_name ("Can't determine port");
+-      port = ntohs (sockaddr.sin_port);
++      int isock;
+ 
+-      fprintf (stderr, "Listening on port %d\n", port);
+-      fflush (stderr);
+-
+-      /* Register the event loop handler.  */
+-      add_file_handler (listen_desc, handle_accept_event, NULL);
++      if (! listening_sockets)
++        fatal ("Listening_sockets not initialized (missing call to remote_prepare).");
++      for (isock = 1; listening_sockets[isock] != INVALID_DESCRIPTOR; ++isock)
++        {
++          /* This assumes the loop ends before any of the handlers is called.
++             This is true in the current non threaded implementation.  */
++          add_file_handler (listening_sockets[isock], handle_accept_event,
++                            listening_sockets + isock);
++        }
+     }
+ }
+ 
+Only in gdb-7.4/gdb/gdbserver: remote-utils.c.orig
+Only in gdb-7.4/gdb/gdbserver: remote-utils.c.rej
+diff -rup gdb-7.4-clean/gdb/ser-tcp.c gdb-7.4/gdb/ser-tcp.c
+--- gdb-7.4-clean/gdb/ser-tcp.c	2012-03-30 15:07:01.540553998 +0200
++++ gdb-7.4/gdb/ser-tcp.c	2012-03-30 15:08:39.484553844 +0200
+@@ -38,7 +38,9 @@
+ #include <sys/time.h>
+ 
+ #ifdef USE_WIN32API
++#define _WIN32_WINNT 0x0501
+ #include <winsock2.h>
++#include <ws2tcpip.h>
+ #ifndef ETIMEDOUT
+ #define ETIMEDOUT WSAETIMEDOUT
+ #endif
+@@ -50,6 +52,7 @@
+ #include <netdb.h>
+ #include <sys/socket.h>
+ #include <netinet/tcp.h>
++#include <netinet/in.h>
+ #endif
+ 
+ #include <signal.h>
+@@ -79,76 +82,49 @@ static int tcp_retry_limit = 15;
+ 
+ #define POLL_INTERVAL 5
+ 
+-/* Helper function to wait a while.  If SCB is non-null, wait on its
+-   file descriptor.  Otherwise just wait on a timeout, updating *POLLS.
+-   Returns -1 on timeout or interrupt, otherwise the value of select.  */
++enum {
++  ADDR_DROP,
++  ADDR_RECONNECT,
++  ADDR_WAIT,
++  ADDR_SUCCESS
++};
+ 
++/* Tries to connect to a socket */
+ static int
+-wait_for_connect (struct serial *scb, int *polls)
++check_sock_err (int fd)
+ {
+-  struct timeval t;
+-  int n;
+-
+-  /* While we wait for the connect to complete, 
+-     poll the UI so it can update or the user can 
+-     interrupt.  */
+-  if (deprecated_ui_loop_hook && deprecated_ui_loop_hook (0))
+-    {
+-      errno = EINTR;
+-      return -1;
+-    }
+-
+-  /* Check for timeout.  */
+-  if (*polls > tcp_retry_limit * POLL_INTERVAL)
+-    {
+-      errno = ETIMEDOUT;
+-      return -1;
+-    }
+-
+-  /* Back off to polling once per second after the first POLL_INTERVAL
+-     polls.  */
+-  if (*polls < POLL_INTERVAL)
+-    {
+-      t.tv_sec = 0;
+-      t.tv_usec = 1000000 / POLL_INTERVAL;
+-    }
+-  else
+-    {
+-      t.tv_sec = 1;
+-      t.tv_usec = 0;
+-    }
++  int res, err;
++  socklen_t len;
+ 
+-  if (scb)
++  len = sizeof (err);
++  /* On Windows, the fourth parameter to getsockopt is a "char *";
++     on UNIX systems it is generally "void *".  The cast to "void *"
++     is OK everywhere, since in C "void *" can be implicitly
++     converted to any pointer type.  */
++  res = getsockopt (fd, SOL_SOCKET, SO_ERROR, (void *) &err, &len);
++  if (res < 0 || err)
+     {
+-      fd_set rset, wset, eset;
+-
+-      FD_ZERO (&rset);
+-      FD_SET (scb->fd, &rset);
+-      wset = rset;
+-      eset = rset;
+-	  
+-      /* POSIX systems return connection success or failure by signalling
+-	 wset.  Windows systems return success in wset and failure in
+-	 eset.
+-     
+-	 We must call select here, rather than gdb_select, because
+-	 the serial structure has not yet been initialized - the
+-	 MinGW select wrapper will not know that this FD refers
+-	 to a socket.  */
+-      n = select (scb->fd + 1, &rset, &wset, &eset, &t);
++      /* Maybe the target still isn't ready to accept the connection.  */
++      if (tcp_auto_retry
++    #ifdef USE_WIN32API
++          && err == WSAECONNREFUSED
++    #else
++          && err == ECONNREFUSED
++    #endif
++          )
++        {
++          close (fd);
++          return ADDR_RECONNECT;
++        }
++      else
++        {
++          if (err)
++            errno = err;
++          close (fd);
++          return ADDR_DROP;
++        }
+     }
+-  else
+-    /* Use gdb_select here, since we have no file descriptors, and on
+-       Windows, plain select doesn't work in that case.  */
+-    n = gdb_select (0, NULL, NULL, NULL, &t);
+-
+-  /* If we didn't time out, only count it as one poll.  */
+-  if (n > 0 || *polls < POLL_INTERVAL)
+-    (*polls)++;
+-  else
+-    (*polls) += POLL_INTERVAL;
+-
+-  return n;
++  return ADDR_SUCCESS;
+ }
+ 
+ /* Open a tcp socket.  */
+@@ -156,18 +132,24 @@ wait_for_connect (struct serial *scb, in
+ int
+ net_open (struct serial *scb, const char *name)
+ {
+-  char *port_str, hostname[100];
+-  int n, port, tmp;
++  char *port_str, hostname[100], *name_end;
++  int n = 0, tmp;
+   int use_udp;
+   struct hostent *hostent;
+-  struct sockaddr_in sockaddr;
++  struct addrinfo hints, *ainfo, *ainfo0, *ainfo_reconnect, *ainfo_old,
++      *ainfo_tmp;
++  struct sockaddr_storage address;
++  int max_w_socks = 0, n_w_socks = 0;
++  int *waiting_socks = NULL;
+ #ifdef USE_WIN32API
+   u_long ioarg;
+ #else
+   int ioarg;
+ #endif
+   int polls = 0;
++  int err, fd = -1;
+ 
++  scb->fd = -1;
+   use_udp = 0;
+   if (strncmp (name, "udp:", 4) == 0)
+     {
+@@ -177,134 +159,286 @@ net_open (struct serial *scb, const char
+   else if (strncmp (name, "tcp:", 4) == 0)
+     name = name + 4;
+ 
+-  port_str = strchr (name, ':');
+-
+-  if (!port_str)
+-    error (_("net_open: No colon in host name!"));  /* Shouldn't ever
++  if (name[0]=='[')
++    {
++      ++name;
++      name_end = strchr(name, ']');
++      if (name_end == NULL)
++        error (_("net_open: Mismatched '['"));
++      port_str = name_end+1;
++    } else {
++      port_str = strchr (name, ':');
++      name_end = port_str;
++    }
++  if (!port_str || port_str[0] !=':')
++    error (_("net_open: No colon after host name!"));  /* Shouldn't ever
+ 						       happen.  */
+ 
+-  tmp = min (port_str - name, (int) sizeof hostname - 1);
+-  strncpy (hostname, name, tmp);	/* Don't want colon.  */
+-  hostname[tmp] = '\000';	/* Tie off host name.  */
+-  port = atoi (port_str + 1);
+-
+-  /* Default hostname is localhost.  */
+-  if (!hostname[0])
+-    strcpy (hostname, "localhost");
+-
+-  hostent = gethostbyname (hostname);
+-  if (!hostent)
++  tmp = min (name_end - name, (int) sizeof hostname - 1);
++  /* Default hostname is localhost. Keeping this but NULL should also work.  */
++  if (!name[0])
+     {
+-      fprintf_unfiltered (gdb_stderr, "%s: unknown host\n", hostname);
+-      errno = ENOENT;
+-      return -1;
++      strcpy (hostname, "localhost");
+     }
+-
+-  sockaddr.sin_family = PF_INET;
+-  sockaddr.sin_port = htons (port);
+-  memcpy (&sockaddr.sin_addr.s_addr, hostent->h_addr,
+-	  sizeof (struct in_addr));
+-
+- retry:
+-
+-  if (use_udp)
+-    scb->fd = socket (PF_INET, SOCK_DGRAM, 0);
+   else
+-    scb->fd = socket (PF_INET, SOCK_STREAM, 0);
+-
+-  if (scb->fd == -1)
+-    return -1;
++    {
++            strncpy (hostname, name, tmp);	/* Don't want colon.  */
++            hostname[tmp] = '\000';	/* Tie off host name.  */
++    }
++  ++port_str;
+   
+-  /* Set socket nonblocking.  */
+-  ioarg = 1;
+-  ioctl (scb->fd, FIONBIO, &ioarg);
++  
++  memset(&hints, 0, sizeof(hints));
++  hints.ai_family = PF_UNSPEC;
++  if (use_udp)
++    hints.ai_socktype = SOCK_DGRAM;
++  else
++    hints.ai_socktype = SOCK_STREAM;
+ 
+-  /* Use Non-blocking connect.  connect() will return 0 if connected
+-     already.  */
+-  n = connect (scb->fd, (struct sockaddr *) &sockaddr, sizeof (sockaddr));
++  err = getaddrinfo(hostname, port_str, &hints, &ainfo0);
++  if (err)
++    {
++      fprintf_unfiltered (gdb_stderr, "%s: connecting to %s on port %s\n",
++                          gai_strerror(err), hostname, port_str);
++      errno = ENOENT;
++      return -1;
++    }
+ 
+-  if (n < 0)
++  do
+     {
+-#ifdef USE_WIN32API
+-      int err = WSAGetLastError();
+-#else
+-      int err = errno;
+-#endif
++      ainfo = ainfo0;
++      ainfo_old = NULL;
++      while (ainfo)
++        {
++          int op_to_do, connect_ret;
++
++          ainfo_old = ainfo;
++          fd = socket (ainfo->ai_family, ainfo->ai_socktype,
++                       ainfo->ai_protocol);
++
++          if (fd == -1)
++            {
++              ainfo = ainfo->ai_next;
++              continue;
++            }
++
++          /* Set socket nonblocking.  */
++          ioarg = 1;
++          ioctl (fd, FIONBIO, &ioarg);
++
++          /* Use Non-blocking connect.  connect() will return 0 if connected
++         already.  */
++          connect_ret = connect (fd, ainfo->ai_addr, ainfo->ai_addrlen);
+ 
+-      /* Maybe we're waiting for the remote target to become ready to
+-	 accept connections.  */
+-      if (tcp_auto_retry
++          if (connect_ret < 0)
++            {
+ #ifdef USE_WIN32API
+-	  && err == WSAECONNREFUSED
++              int err = WSAGetLastError();
+ #else
+-	  && err == ECONNREFUSED
++              int err = errno;
+ #endif
+-	  && wait_for_connect (NULL, &polls) >= 0)
+-	{
+-	  close (scb->fd);
+-	  goto retry;
+-	}
+ 
+-      if (
+-#ifdef USE_WIN32API
+-	  /* Under Windows, calling "connect" with a non-blocking socket
+-	     results in WSAEWOULDBLOCK, not WSAEINPROGRESS.  */
+-	  err != WSAEWOULDBLOCK
+-#else
+-	  err != EINPROGRESS
+-#endif
+-	  )
+-	{
+-	  errno = err;
+-	  net_close (scb);
+-	  return -1;
+-	}
+-
+-      /* Looks like we need to wait for the connect.  */
+-      do 
+-	{
+-	  n = wait_for_connect (scb, &polls);
+-	} 
+-      while (n == 0);
+-      if (n < 0)
+-	{
+-	  net_close (scb);
+-	  return -1;
+-	}
++              /* Maybe we're waiting for the remote target to become ready to
++               accept connections.  */
++              if (tcp_auto_retry
++    #ifdef USE_WIN32API
++                  && err == WSAECONNREFUSED
++    #else
++                  && err == ECONNREFUSED
++    #endif
++                  )
++                {
++                  close (fd);
++                  op_to_do = ADDR_RECONNECT;
++                }
++              else if (
++         #ifdef USE_WIN32API
++                       /* Under Windows, calling "connect" with a non-blocking socket
++                                results in WSAEWOULDBLOCK, not WSAEINPROGRESS.  */
++                       err != WSAEWOULDBLOCK
++         #else
++                       err != EINPROGRESS
++         #endif
++                       )
++                {
++                  close (fd);
++                  op_to_do = ADDR_DROP;
++                }
++              else
++                {
++                  op_to_do = ADDR_WAIT;
++                }
++            }
++          else
++            {
++              op_to_do = check_sock_err(fd);
++            }
++          switch (op_to_do)
++            {
++            case ADDR_DROP:
++              break;
++            case ADDR_RECONNECT:
++              ainfo_tmp = ainfo->ai_next;
++              ainfo->ai_next = ainfo_reconnect;
++              ainfo_reconnect->ai_next = ainfo;
++              ainfo = ainfo_tmp;
++              ainfo_old = NULL;
++              break;
++            case ADDR_WAIT:
++              /* Looks like we need to wait for the connect.  */
++              if (n_w_socks >= max_w_socks)
++                {
++                  max_w_socks += 10;
++                  waiting_socks= xrealloc (waiting_socks, max_w_socks
++                                           * sizeof(*waiting_socks));
++                }
++              waiting_socks[n_w_socks++] = fd;
++              break;
++            case ADDR_SUCCESS:
++              break;
++            default:
++              fatal (_("Unexpected value for try_connect in net_open."));
++            }
++          if (ainfo_old)
++            {
++              ainfo = ainfo_old->ai_next;
++              ainfo_old->ai_next = NULL;
++              freeaddrinfo (ainfo_old);
++            }
++          if (op_to_do == ADDR_SUCCESS)
++            break;
++          fd = -1;
++        }
++      ainfo0 = ainfo_reconnect;
++      ainfo_reconnect = NULL;
++
++      if (fd != -1 || !(ainfo0 != NULL || n_w_socks != 0))
++        break;
++
++      do
++        {
++          struct timeval t;
++          int max_fd;
++          fd_set rset;
++          
++          /* While we wait for the connect to complete,
++               poll the UI so it can update or the user can
++               interrupt.  */
++          if (deprecated_ui_loop_hook && deprecated_ui_loop_hook (0))
++            {
++              errno = EINTR;
++              return -1;
++            }
++
++          /* Check for timeout.  */
++          if (polls > tcp_retry_limit * POLL_INTERVAL)
++            {
++              errno = ETIMEDOUT;
++              return -1;
++            }
++
++          /* Back off to polling once per second after the first POLL_INTERVAL
++               polls.  */
++          if (polls < POLL_INTERVAL)
++            {
++              t.tv_sec = 0;
++              t.tv_usec = 1000000 / POLL_INTERVAL;
++            }
++          else
++            {
++              t.tv_sec = 1;
++              t.tv_usec = 0;
++            }
++
++          max_fd=-1;
++          if (n_w_socks)
++            {
++              int ifd;
++
++              FD_ZERO (&rset);
++              for (ifd = 0; ifd < n_w_socks; ++ifd)
++                {
++                  if (waiting_socks[ifd] != -1)
++                    {
++                      FD_SET (waiting_socks[ifd], &rset);
++                      if (max_fd < waiting_socks[ifd])
++                        max_fd = waiting_socks[ifd];
++                    }
++                }
++            }
++          if (max_fd != -1)
++            {
++              int ifd;
++              fd_set wset, eset;
++              wset = rset;
++              eset = rset;
++
++              /* POSIX systems return connection success or failure by signalling
++                   wset.  Windows systems return success in wset and failure in
++                   eset.
++
++                   We must call select here, rather than gdb_select, because
++                   the serial structure has not yet been initialized - the
++                   MinGW select wrapper will not know that this FD refers
++                   to a socket.  */
++              n = select (max_fd + 1, &rset, &wset, &eset, &t);
++              if (n > 0)
++                for (ifd = 0; ifd < n_w_socks && fd == -1; ++ifd)
++                  if (FD_ISSET(waiting_socks[ifd], &rset)
++                      || FD_ISSET(waiting_socks[ifd], &wset)
++                      || FD_ISSET(waiting_socks[ifd], &eset))
++                    {
++                      int op_to_do;
++
++                      op_to_do = check_sock_err(waiting_socks[ifd]);
++                      switch (op_to_do)
++                        {
++                        case ADDR_RECONNECT:
++                          //waiting_socks[ifd] = -1;
++                          break;
++                        case ADDR_DROP:
++                          //waiting_socks[ifd] = -1;
++                          break;
++                        case ADDR_WAIT:
++                          break;
++                        case ADDR_SUCCESS:
++                          fd = waiting_socks[ifd];
++                          break;
++                        default:
++                          fatal (_("Unexpected value for try_connect in net_open."));
++                        }
++                    }
++            }
++          else
++            /* Use gdb_select here, since we have no file descriptors, and on
++                 Windows, plain select doesn't work in that case.  */
++            n = gdb_select (0, NULL, NULL, NULL, &t);
++
++          /* If we didn't time out, only count it as one poll.  */
++          if (n > 0 || polls < POLL_INTERVAL)
++            polls++;
++          else
++            polls += POLL_INTERVAL;
++        }
++      while (fd == -1 && n == 0 && ainfo0 == NULL);
+     }
++  while (fd == -1 && n >= 0);
+ 
+-  /* Got something.  Is it an error?  */
+-  {
+-    int res, err;
+-    socklen_t len;
+-
+-    len = sizeof (err);
+-    /* On Windows, the fourth parameter to getsockopt is a "char *";
+-       on UNIX systems it is generally "void *".  The cast to "void *"
+-       is OK everywhere, since in C "void *" can be implicitly
+-       converted to any pointer type.  */
+-    res = getsockopt (scb->fd, SOL_SOCKET, SO_ERROR, (void *) &err, &len);
+-    if (res < 0 || err)
+-      {
+-	/* Maybe the target still isn't ready to accept the connection.  */
+-	if (tcp_auto_retry
+-#ifdef USE_WIN32API
+-	    && err == WSAECONNREFUSED
+-#else
+-	    && err == ECONNREFUSED
+-#endif
+-	    && wait_for_connect (NULL, &polls) >= 0)
+-	  {
+-	    close (scb->fd);
+-	    goto retry;
+-	  }
+-	if (err)
+-	  errno = err;
+-	net_close (scb);
+-	return -1;
+-      }
+-  } 
++  freeaddrinfo (ainfo0);
++  if (waiting_socks)
++    {
++      int ifd;
++
++      for (ifd = 0; ifd < n_w_socks && fd == -1; ++ifd)
++        if (waiting_socks[ifd] != fd && waiting_socks[ifd] != -1)
++          close (waiting_socks[ifd]);
++    }
++  free (waiting_socks);
++
++  if (fd == -1)
++    return -1;
+ 
++  scb->fd = fd;
+   /* Turn off nonblocking.  */
+   ioarg = 0;
+   ioctl (scb->fd, FIONBIO, &ioarg);
diff --git a/dist/gdb/patches/gdb-target-debugging.patch b/dist/gdb/patches/gdb-target-debugging.patch
new file mode 100644
index 0000000000..efbd376290
--- /dev/null
+++ b/dist/gdb/patches/gdb-target-debugging.patch
@@ -0,0 +1,19 @@
+--- src/gdb/infcmd.c	2012/02/15 19:13:13
++++ src/gdb/infcmd.c	2012/02/23 08:15:04
+@@ -1636,6 +1636,7 @@
+ static void
+ finish_forward (struct symbol *function, struct frame_info *frame)
+ {
++  struct frame_id frame_id = get_frame_id (frame);
+   struct gdbarch *gdbarch = get_frame_arch (frame);
+   struct symtab_and_line sal;
+   struct thread_info *tp = inferior_thread ();
+@@ -1653,7 +1654,7 @@
+ 
+   old_chain = make_cleanup_delete_breakpoint (breakpoint);
+ 
+-  set_longjmp_breakpoint (tp, get_frame_id (frame));
++  set_longjmp_breakpoint (tp, frame_id);
+   make_cleanup (delete_longjmp_breakpoint_cleanup, &thread);
+ 
+   /* We want stop_registers, please...  */
diff --git a/dist/gdb/patches/gdb-work-around-trk-single-step.patch b/dist/gdb/patches/gdb-work-around-trk-single-step.patch
new file mode 100644
index 0000000000..069bc82a78
--- /dev/null
+++ b/dist/gdb/patches/gdb-work-around-trk-single-step.patch
@@ -0,0 +1,23 @@
+
+NOTE: Apply to --target=arm-none-symbianelf builds only.
+
+This works around the problem of TRK overshooting line-wise stepping by a few
+instructions. This is not a gdb problem, but a TRK problem, but currently
+easier to workaround on the gdb side. It's sufficient to apply for the
+arm-none-symbianelf targeted gdbs only as TRK is the only probe known to have
+this problem.
+
+--- a/gdb/infrun.c
++++ b/gdb/infrun.c
+@@ -5061,9 +5061,9 @@ process_event_stop_test:
+       return;
+     }
+
+-  if ((stop_pc == stop_pc_sal.pc)
++  if (1 /* (stop_pc == stop_pc_sal.pc)
+       && (ecs->event_thread->current_line != stop_pc_sal.line
+- 	  || ecs->event_thread->current_symtab != stop_pc_sal.symtab))
++ 	  || ecs->event_thread->current_symtab != stop_pc_sal.symtab) */)
+     {
+       /* We are at the start of a different line.  So stop.  Note that
+          we don't stop if we step into the middle of a different line.
diff --git a/dist/gdb/patches/pythonhome-7.4.patch b/dist/gdb/patches/pythonhome-7.4.patch
new file mode 100644
index 0000000000..28a6ed3e91
--- /dev/null
+++ b/dist/gdb/patches/pythonhome-7.4.patch
@@ -0,0 +1,38 @@
+*** source/gdb-7.4/gdb/python/python.c	2012-02-01 10:39:59.812953656 +0100
+--- staging/gdb-7.4/gdb/python/python.c	2012-02-01 10:33:45.842953480 +0100
+***************
+*** 32,38 ****
+  #include "serial.h"
+  #include "readline/tilde.h"
+  #include "python.h"
+! 
+  #include <ctype.h>
+  
+  /* Declared constants and enum for python stack printing.  */
+--- 32,38 ----
+  #include "serial.h"
+  #include "readline/tilde.h"
+  #include "python.h"
+! #include <libgen.h>
+  #include <ctype.h>
+  
+  /* Declared constants and enum for python stack printing.  */
+***************
+*** 1273,1278 ****
+--- 1273,1288 ----
+  			     SLASH_STRING, "python", NULL));
+  #endif
+  
++ 
++   char readlinkbuffer[BUFSIZ];
++   int readlinks = readlink("/proc/self/exe", readlinkbuffer, BUFSIZ - 1);
++   readlinkbuffer[readlinks] = 0; 
++   char *executeablepath = dirname(readlinkbuffer);
++   char *pythonhome = malloc(strlen(executeablepath) + strlen("/python/") + 2);
++   strcpy(pythonhome, executeablepath);
++   strcat(pythonhome, "/python/");
++   setenv("PYTHONHOME", pythonhome, 1);
++ 
+    Py_Initialize ();
+    PyEval_InitThreads ();
+