--- libgfortran/Makefile.am.jj	2014-04-11 14:53:47.007361552 +0200

+++ libgfortran/Makefile.am	2014-05-09 15:14:49.855968357 +0200

@@ -34,6 +34,7 @@ LTLDFLAGS = $(shell $(SHELL) $(top_srcdi

 	    $(lt_host_flags)

 toolexeclib_LTLIBRARIES = libgfortran.la

+noinst_LTLIBRARIES = libgfortran_nonshared.la

 toolexeclib_DATA = libgfortran.spec

 libgfortran_la_LINK = $(LINK) $(libgfortran_la_LDFLAGS)

 libgfortran_la_LDFLAGS = -version-info `grep -v '^\#' $(srcdir)/libtool-version` \

@@ -848,6 +849,196 @@ libgfortran_la_SOURCES = $(prereq_SRC)

 endif

+if LIBGFOR_BUILD_QUAD

+nonshared_generated_quad_F90_SRC = \

+nonshared-_abs_c16.F90 \

+nonshared-_abs_r16.F90 \

+nonshared-_acosh_r16.F90 \

+nonshared-_acos_r16.F90 \

+nonshared-_aimag_c16.F90 \

+nonshared-_aint_r16.F90 \

+nonshared-_anint_r16.F90 \

+nonshared-_asinh_r16.F90 \

+nonshared-_asin_r16.F90 \

+nonshared-_atan2_r16.F90 \

+nonshared-_atanh_r16.F90 \

+nonshared-_atan_r16.F90 \

+nonshared-_conjg_c16.F90 \

+nonshared-_cos_c16.F90 \

+nonshared-_cosh_r16.F90 \

+nonshared-_cos_r16.F90 \

+nonshared-_dim_r16.F90 \

+nonshared-_exp_c16.F90 \

+nonshared-_exp_r16.F90 \

+nonshared-_log10_r16.F90 \

+nonshared-_log_c16.F90 \

+nonshared-_log_r16.F90 \

+nonshared-_mod_r16.F90 \

+nonshared-_sign_r16.F90 \

+nonshared-_sin_c16.F90 \

+nonshared-_sinh_r16.F90 \

+nonshared-_sin_r16.F90 \

+nonshared-_sqrt_c16.F90 \

+nonshared-_sqrt_r16.F90 \

+nonshared-_tanh_r16.F90 \

+nonshared-_tan_r16.F90

+nonshared_generated_quad_C_SRC = \

+nonshared-exponent_r16.c \

+nonshared-fraction_r16.c \

+nonshared-matmul_c16.c \

+nonshared-matmul_r16.c \

+nonshared-maxloc0_16_r16.c \

+nonshared-maxloc0_4_r16.c \

+nonshared-maxloc0_8_r16.c \

+nonshared-maxloc1_16_r16.c \

+nonshared-maxloc1_4_r16.c \

+nonshared-maxloc1_8_r16.c \

+nonshared-maxval_r16.c \

+nonshared-minloc0_16_r16.c \

+nonshared-minloc0_4_r16.c \

+nonshared-minloc0_8_r16.c \

+nonshared-minloc1_16_r16.c \

+nonshared-minloc1_4_r16.c \

+nonshared-minloc1_8_r16.c \

+nonshared-minval_r16.c \

+nonshared-nearest_r16.c \

+nonshared-pow_c16_i16.c \

+nonshared-pow_c16_i4.c \

+nonshared-pow_c16_i8.c \

+nonshared-pow_r16_i16.c \

+nonshared-pow_r16_i4.c \

+nonshared-pow_r16_i8.c \

+nonshared-product_c16.c \

+nonshared-product_r16.c \

+nonshared-reshape_c16.c \

+nonshared-reshape_r16.c \

+nonshared-rrspacing_r16.c \

+nonshared-set_exponent_r16.c \

+nonshared-spacing_r16.c \

+nonshared-sum_c16.c \

+nonshared-sum_r16.c \

+nonshared-transpose_c16.c \

+nonshared-transpose_r16.c

+nonshared_generated_special_quad_F90_SRC = \

+nonshared-misc_specifics.F90

+nonshared_quad_SRC = \

+$(srcdir)/intrinsics/nonshared-iso_c_generated_procs.c \

+$(srcdir)/intrinsics/nonshared-cpu_time.c \

+$(srcdir)/intrinsics/nonshared-erfc_scaled.c \

+$(srcdir)/intrinsics/nonshared-random.c

+else

+nonshared_generated_quad_F90_SRC =

+nonshared_generated_quad_C_SRC =

+nonshared_generated_special_quad_F90_SRC =

+nonshared_quad_SRC =

+endif

+

+nonshared_generated_F90_SRC = \

+$(nonshared_generated_quad_F90_SRC)

+nonshared_generated_special_F90_SRC = \

+$(nonshared_generated_special_quad_F90_SRC)

+nonshared_intrinsics_special_F90_SRC = \

+nonshared-selected_real_kind.F90

+nonshared_generated_C_SRC = \

+$(nonshared_generated_quad_C_SRC) \

+nonshared-bessel_r10.c \

+nonshared-bessel_r16.c \

+nonshared-bessel_r4.c \

+nonshared-bessel_r8.c \

+nonshared-iall_i1.c \

+nonshared-iall_i2.c \

+nonshared-iall_i4.c \

+nonshared-iall_i8.c \

+nonshared-iall_i16.c \

+nonshared-iany_i1.c \

+nonshared-iany_i2.c \

+nonshared-iany_i4.c \

+nonshared-iany_i8.c \

+nonshared-iany_i16.c \

+nonshared-iparity_i1.c \

+nonshared-iparity_i2.c \

+nonshared-iparity_i4.c \

+nonshared-iparity_i8.c \

+nonshared-iparity_i16.c \

+nonshared-norm2_r10.c \

+nonshared-norm2_r16.c \

+nonshared-norm2_r4.c \

+nonshared-norm2_r8.c \

+nonshared-parity_l16.c \

+nonshared-parity_l1.c \

+nonshared-parity_l2.c \

+nonshared-parity_l4.c \

+nonshared-parity_l8.c

+

+nonshared_intrinsics_C_SRC = \

+nonshared-extends_type_of.c

+

+nonshared_runtime_C_SRC = \

+nonshared-bounds.c

+

+$(patsubst %.c,%.lo,$(nonshared_generated_C_SRC) $(nonshared)): \

+nonshared-%.lo: $(srcdir)/generated/%.c

+	$(LTCOMPILE) -c -o $@ $< -DLIBGFORTRAN_NONSHARED

+

+$(patsubst %.c,%.o,$(nonshared_generated_C_SRC) $(nonshared)): \

+nonshared-%.o: $(srcdir)/generated/%.c

+	$(COMPILE) -c -o $@ $< -DLIBGFORTRAN_NONSHARED

+

+$(patsubst %.F90,%.lo,$(nonshared_generated_F90_SRC) $(nonshared)): \

+nonshared-%.lo: $(srcdir)/generated/%.F90

+	$(LTPPFCCOMPILE) -c -o $@ $< -DLIBGFORTRAN_NONSHARED -fallow-leading-underscore

+

+$(patsubst %.F90,%.o,$(nonshared_generated_F90_SRC) $(nonshared)): \

+nonshared-%.o: $(srcdir)/generated/%.F90

+	$(PPFCCOMPILE) -c -o $@ $< -DLIBGFORTRAN_NONSHARED -fallow-leading-underscore

+

+$(patsubst %.c,%.lo,$(nonshared_intrinsics_C_SRC) $(nonshared)): \

+nonshared-%.lo: $(srcdir)/intrinsics/%.c

+	$(LTCOMPILE) -c -o $@ $< -DLIBGFORTRAN_NONSHARED

+

+$(patsubst %.c,%.o,$(nonshared_intrinsics_C_SRC) $(nonshared)): \

+nonshared-%.o: $(srcdir)/intrinsics/%.c

+	$(COMPILE) -c -o $@ $< -DLIBGFORTRAN_NONSHARED

+

+$(patsubst %.c,%.lo,$(nonshared_runtime_C_SRC) $(nonshared)): \

+nonshared-%.lo: $(srcdir)/runtime/%.c

+	$(LTCOMPILE) -c -o $@ $< -DLIBGFORTRAN_NONSHARED

+

+$(patsubst %.c,%.o,$(nonshared_runtime_C_SRC) $(nonshared)): \

+nonshared-%.o: $(srcdir)/runtime/%.c

+	$(COMPILE) -c -o $@ $< -DLIBGFORTRAN_NONSHARED

+

+$(patsubst %.F90,%.lo,$(nonshared_generated_special_F90_SRC) $(nonshared)): \

+nonshared-%.lo: $(srcdir)/generated/nonshared-%.F90

+	$(LTPPFCCOMPILE) -c -o $@ $< -fallow-leading-underscore

+

+$(patsubst %.F90,%.o,$(nonshared_generated_special_F90_SRC) $(nonshared)): \

+nonshared-%.o: $(srcdir)/generated/nonshared-%.F90

+	$(PPFCCOMPILE) -c -o $@ $< -fallow-leading-underscore

+

+$(patsubst %.F90,%.lo,$(nonshared_intrinsics_special_F90_SRC) $(nonshared)): \

+nonshared-%.lo: $(srcdir)/intrinsics/nonshared-%.F90

+	$(LTPPFCCOMPILE) -c -o $@ $< -fallow-leading-underscore

+

+$(patsubst %.F90,%.o,$(nonshared_intrinsics_special_F90_SRC) $(nonshared)): \

+nonshared-%.o: $(srcdir)/intrinsics/nonshared-%.F90

+	$(PPFCCOMPILE) -c -o $@ $< -fallow-leading-underscore

+

+libgfortran_nonshared_la_SOURCES = \

+$(nonshared_generated_F90_SRC) \

+$(nonshared_generated_C_SRC) \

+$(nonshared_intrinsics_C_SRC) \

+$(nonshared_runtime_C_SRC) \

+$(nonshared_quad_SRC) \

+$(nonshared_generated_special_F90_SRC) \

+$(nonshared_intrinsics_special_F90_SRC) \

+$(srcdir)/intrinsics/nonshared-execute_command_line.c \

+$(srcdir)/intrinsics/nonshared-shift.c \

+$(srcdir)/io/nonshared-transfer.c \

+$(srcdir)/io/nonshared-ftell2.c \

+$(srcdir)/runtime/nonshared-backtrace.c

+$(srcdir)/runtime/nonshared-stop.c

+

 I_M4_DEPS=m4/iparm.m4

 I_M4_DEPS0=$(I_M4_DEPS) m4/iforeach.m4

 I_M4_DEPS1=$(I_M4_DEPS) m4/ifunction.m4

--- libgfortran/libgfortran.h.jj	2014-08-01 10:16:01.000000000 +0200

+++ libgfortran/libgfortran.h	2014-08-01 15:21:26.371033136 +0200

@@ -191,7 +191,7 @@ extern int __mingw_snprintf (char *, siz

 # define internal_proto(x)	sym_rename(x, IPREFIX(x))

 #endif

-#if defined(HAVE_ATTRIBUTE_VISIBILITY) && defined(HAVE_ATTRIBUTE_ALIAS)

+#if defined(HAVE_ATTRIBUTE_VISIBILITY) && defined(HAVE_ATTRIBUTE_ALIAS) && !defined(LIBGFORTRAN_NONSHARED)

 # define export_proto(x)	sym_rename(x, PREFIX(x))

 # define export_proto_np(x)	extern char swallow_semicolon

 # define iexport_proto(x)	internal_proto(x)

@@ -275,6 +275,10 @@ typedef GFC_UINTEGER_4 gfc_char4_t;

 extern int big_endian;

 internal_proto(big_endian);

+#ifdef LIBGFORTRAN_NONSHARED

+#define big_endian (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__)

+#endif

+

 #define GFOR_POINTER_TO_L1(p, kind) \

   (big_endian * (kind - 1) + (GFC_LOGICAL_1 *)(p))

@@ -1395,4 +1399,63 @@ void cshift0_c16 (gfc_array_c16 *, const

 internal_proto(cshift0_c16);

 #endif

+#ifdef LIBGFORTRAN_NONSHARED

+#include <stdlib.h>

+#include <string.h>              

+#include <errno.h>

+

+#define internal_malloc_size nonshared_internal_malloc_size

+#define xmalloc nonshared_internal_xmalloc

+#define xmallocarray nonshared_internal_xmallocarray

+#define reshape_packed nonshared_reshape_packed

+static inline __attribute__((__always_inline__, __unused__))

+void *

+internal_malloc_size (size_t size)

+{

+  void *p;

+

+  if (size == 0)

+    return NULL;

+

+  p = (void *) malloc (size);

+  if (p == NULL)

+    os_error ("Memory allocation failed");

+  return p;

+}

+

+static inline __attribute__((__always_inline__, __unused__))

+void *

+xmalloc (size_t size)

+{

+  return internal_malloc_size (size ? size : 1);

+}

+

+static inline __attribute__((__always_inline__, __unused__))

+void *

+xmallocarray (size_t nmemb, size_t size)

+{

+  if (!nmemb || !size)

+    size = nmemb = 1;

+  else if (__builtin_expect ((nmemb | size)

+			     >= (((size_t) 1) << (__CHAR_BIT__

+						  * sizeof (size_t) / 2)), 0)

+	   && nmemb > __SIZE_MAX__ / size)

+    {

+      errno = ENOMEM;

+      os_error ("Integer overflow in xmallocarray");

+    }

+

+  return internal_malloc_size (nmemb * size);

+}

+

+static inline __attribute__((__always_inline__, __unused__))

+#include "intrinsics/reshape_packed.c"

+

+struct no_bounds_check { int bounds_check; };

+#define compile_options ((struct no_bounds_check) { .bounds_check = 0 })

+

+#define internal_error(x, y...) runtime_error (y)

+

+#endif

+

 #endif  /* LIBGFOR_H  */

--- libgfortran/runtime/nonshared-stop.c.jj	2014-05-09 15:14:49.863968070 +0200

+++ libgfortran/runtime/nonshared-stop.c	2014-05-09 15:14:49.863968070 +0200

@@ -0,0 +1,93 @@

+/* Implementation of the STOP statement.

+   Copyright 2002-2014 Free Software Foundation, Inc.

+   Contributed by Paul Brook <paul@nowt.org>

+

+This file is part of the GNU Fortran 95 runtime library (libgfortran).

+

+Libgfortran is free software; you can redistribute it and/or

+modify it under the terms of the GNU General Public

+License as published by the Free Software Foundation; either

+version 3 of the License, or (at your option) any later version.

+

+Libgfortran is distributed in the hope that it will be useful,

+but WITHOUT ANY WARRANTY; without even the implied warranty of

+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

+GNU General Public License for more details.

+

+Under Section 7 of GPL version 3, you are granted additional

+permissions described in the GCC Runtime Library Exception, version

+3.1, as published by the Free Software Foundation.

+

+You should have received a copy of the GNU General Public License and

+a copy of the GCC Runtime Library Exception along with this program;

+see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see

+<http://www.gnu.org/licenses/>.  */

+

+#define LIBGFORTRAN_NONSHARED

+#include "libgfortran.h"

+#include <unistd.h>

+#include <stdlib.h>

+

+/* A numeric STOP statement.  */

+

+extern void stop_numeric (GFC_INTEGER_4)

+  __attribute__ ((noreturn));

+export_proto(stop_numeric);

+

+/* A Fortran 2008 numeric STOP statement.  */

+

+extern void stop_numeric_f08 (GFC_INTEGER_4)

+  __attribute__ ((noreturn));

+export_proto(stop_numeric_f08);

+

+void

+stop_numeric_f08 (GFC_INTEGER_4 code)

+{

+  /* Unfortunately we can't do much here.  */

+  if (code == -1)

+    code = -1 ^ 256;

+  stop_numeric (code);

+}

+

+

+/* Per Fortran 2008, section 8.4:  "Execution of a STOP statement initiates

+   normal termination of execution. Execution of an ERROR STOP statement

+   initiates error termination of execution."  Thus, error_stop_string returns

+   a nonzero exit status code.  */

+

+extern void error_stop_string (const char *, GFC_INTEGER_4)

+  __attribute__ ((noreturn));

+export_proto(error_stop_string);

+

+void

+error_stop_string (const char *string, GFC_INTEGER_4 len)

+{

+  (void) string;

+  (void) len;

+  stop_numeric (1);

+}

+

+

+/* A numeric ERROR STOP statement.  */

+

+extern void error_stop_numeric (GFC_INTEGER_4)

+  __attribute__ ((noreturn));

+export_proto(error_stop_numeric);

+

+void

+error_stop_numeric (GFC_INTEGER_4 code)

+{

+  stop_numeric (code);

+}

+

+__attribute__((visibility ("hidden"))) void

+stop_string (const char *string, GFC_INTEGER_4 len)

+{

+  if (string)

+    {

+      (void) write (STDERR_FILENO, "STOP ", 5);

+      (void) write (STDERR_FILENO, string, len);

+      (void) write (STDERR_FILENO, "\n", 1);

+    }

+  exit (0);

+}

--- libgfortran/runtime/nonshared-backtrace.c.jj	2014-05-09 15:14:49.863968070 +0200

+++ libgfortran/runtime/nonshared-backtrace.c	2014-05-09 15:17:27.141178917 +0200

@@ -0,0 +1,326 @@

+/* Copyright (C) 2006-2014 Free Software Foundation, Inc.

+   Contributed by François-Xavier Coudert

+

+This file is part of the GNU Fortran runtime library (libgfortran).

+

+Libgfortran is free software; you can redistribute it and/or modify

+it under the terms of the GNU General Public License as published by

+the Free Software Foundation; either version 3, or (at your option)

+any later version.

+

+Libgfortran is distributed in the hope that it will be useful,

+but WITHOUT ANY WARRANTY; without even the implied warranty of

+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

+GNU General Public License for more details.

+

+Under Section 7 of GPL version 3, you are granted additional

+permissions described in the GCC Runtime Library Exception, version

+3.1, as published by the Free Software Foundation.

+

+You should have received a copy of the GNU General Public License and

+a copy of the GCC Runtime Library Exception along with this program;

+see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see

+<http://www.gnu.org/licenses/>.  */

+

+#include "libgfortran.h"

+

+#include <string.h>

+#include <stdlib.h>

+

+#ifdef HAVE_UNISTD_H

+#include <unistd.h>

+#endif

+

+#ifdef HAVE_SYS_WAIT_H

+#include <sys/wait.h>

+#endif

+

+#include <limits.h>

+

+#include "unwind.h"

+

+

+/* Macros for common sets of capabilities: can we fork and exec, and

+   can we use pipes to communicate with the subprocess.  */

+#define CAN_FORK (defined(HAVE_FORK) && defined(HAVE_EXECVE) \

+		  && defined(HAVE_WAIT))

+#define CAN_PIPE (CAN_FORK && defined(HAVE_PIPE) \

+		  && defined(HAVE_DUP2) && defined(HAVE_CLOSE))

+

+#ifndef PATH_MAX

+#define PATH_MAX 4096

+#endif

+

+#define estr_write(str) write (STDERR_FILENO, str, strlen (str))

+

+

+/* GDB style #NUM index for each stack frame.  */

+

+static void 

+bt_header (int num)

+{

+  char buf[32];

+  snprintf (buf, sizeof buf, "#%d  ", num);

+  estr_write (buf);

+}

+

+

+/* fgets()-like function that reads a line from a fd, without

+   needing to malloc() a buffer, and does not use locks, hence should

+   be async-signal-safe.  */

+

+static char *

+fd_gets (char *s, int size, int fd)

+{

+  for (int i = 0; i < size; i++)

+    {

+      char c;

+      ssize_t nread = read (fd, &c, 1);

+      if (nread == 1)

+	{

+	  s[i] = c;

+	  if (c == '\n')

+	    {

+	      if (i + 1 < size)

+		s[i+1] = '\0';

+	      else

+		s[i] = '\0';

+	      break;

+	    }

+	}

+      else

+	{

+	  s[i] = '\0';

+	  if (i == 0)

+	    return NULL;

+	  break;

+	}

+    }

+  return s;

+}

+

+

+/* Struct containing backtrace state.  */

+typedef struct

+{

+  int frame_number;

+  int direct_output;

+  int outfd;

+  int infd;

+  int error;

+}

+bt_state;

+

+static inline const char *

+nonshared_gfc_xtoa (GFC_UINTEGER_LARGEST n, char *buffer,

+		    size_t len __attribute__((unused)))

+{

+  int digit;

+  char *p;

+

+  if (n == 0)

+    return "0";

+

+  p = buffer + GFC_XTOA_BUF_SIZE - 1;

+  *p = '\0';

+

+  while (n != 0)

+    {

+      digit = n & 0xF;

+      if (digit > 9)

+        digit += 'A' - '0' - 10;

+

+      *--p = '0' + digit;

+      n >>= 4;

+    }

+

+  return p;

+}

+#define gfc_xtoa nonshared_gfc_xtoa

+

+static _Unwind_Reason_Code

+trace_function (struct _Unwind_Context *context, void *state_ptr)

+{

+  bt_state* state = (bt_state*) state_ptr;

+  _Unwind_Ptr ip;

+#ifdef HAVE_GETIPINFO

+  int ip_before_insn = 0;

+  ip = _Unwind_GetIPInfo (context, &ip_before_insn);

+  

+  /* If the unwinder gave us a 'return' address, roll it back a little

+     to ensure we get the correct line number for the call itself.  */

+  if (! ip_before_insn)

+    --ip;

+#else  

+  ip = _Unwind_GetIP (context);

+#endif

+

+  if (state->direct_output)

+    {

+      char buf[32];

+      bt_header(state->frame_number);

+      snprintf (buf, sizeof buf, "%p\n", (void*) ip);

+      estr_write (buf);

+    }

+  else

+    {

+      char addr_buf[GFC_XTOA_BUF_SIZE], func[1024], file[PATH_MAX];

+      char *p;

+      const char* addr = gfc_xtoa (ip, addr_buf, sizeof (addr_buf));

+      write (state->outfd, addr, strlen (addr));

+      write (state->outfd, "\n", 1);

+

+      if (! fd_gets (func, sizeof(func), state->infd))

+	{

+	  state->error = 1;

+	  goto done;

+	}

+      if (! fd_gets (file, sizeof(file), state->infd))

+	{

+	  state->error = 1;

+	  goto done;

+	}

+	    

+	for (p = func; *p != '\n' && *p != '\r'; p++)

+	  ;

+	*p = '\0';

+	

+	/* _start is a setup routine that calls main(), and main() is

+	   the frontend routine that calls some setup stuff and then

+	   calls MAIN__, so at this point we should stop.  */

+	if (strcmp (func, "_start") == 0 || strcmp (func, "main") == 0)

+	  return _URC_END_OF_STACK;

+	

+	bt_header (state->frame_number);

+	estr_write ("0x");

+	estr_write (addr);

+

+	if (func[0] != '?' && func[1] != '?')

+	  {

+	    estr_write (" in ");

+	    estr_write (func);

+	  }

+	

+	if (strncmp (file, "??", 2) == 0)

+	  estr_write ("\n");

+	else

+	  {

+	    estr_write (" at ");

+	    estr_write (file);

+	  }

+    }

+

+ done:

+

+  state->frame_number++;

+  

+  return _URC_NO_REASON;

+}

+

+

+/* Display the backtrace.  */

+

+void

+backtrace (void)

+{

+  bt_state state;

+  state.frame_number = 0;

+  state.error = 0;

+

+#if CAN_PIPE

+

+#ifndef PATH_MAX

+#define PATH_MAX 1024

+#endif

+

+#ifndef DIR_SEPARATOR

+#define DIR_SEPARATOR '/'

+#endif

+

+  char exe_path[PATH_MAX];

+

+  /* Reading the /proc/self/exe symlink is Linux-specific(?), but if

+     it works it gives the correct answer.  */

+#ifdef HAVE_READLINK

+  int len;

+  if ((len = readlink ("/proc/self/exe", exe_path, sizeof (exe_path) - 1)) != -1)

+    exe_path[len] = '\0';

+  else

+#endif

+    goto fallback_noerr;

+

+  /* We attempt to extract file and line information from addr2line.  */

+  do

+  {

+    /* Local variables.  */

+    int f[2], pid, inp[2];

+

+    /* Don't output an error message if something goes wrong, we'll simply

+       fall back to printing the addresses.  */

+    if (pipe (f) != 0)

+      break;

+    if (pipe (inp) != 0)

+      break;

+    if ((pid = fork ()) == -1)

+      break;

+

+    if (pid == 0)

+      {

+	/* Child process.  */

+#define NUM_FIXEDARGS 7

+	char *arg[NUM_FIXEDARGS];

+

+	close (f[0]);

+

+	close (inp[1]);

+	if (dup2 (inp[0], STDIN_FILENO) == -1)

+	  _exit (1);

+	close (inp[0]);

+

+	close (STDERR_FILENO);

+

+	if (dup2 (f[1], STDOUT_FILENO) == -1)

+	  _exit (1);

+	close (f[1]);

+

+	arg[0] = (char *) "addr2line";

+	arg[1] = (char *) "-e";

+	arg[2] = exe_path;

+	arg[3] = (char *) "-f";

+	arg[4] = (char *) "-s";

+	arg[5] = (char *) "-C";

+	arg[6] = NULL;

+	execvp ("addr2line", arg);

+	_exit (1);

+#undef NUM_FIXEDARGS

+      }

+

+    /* Father process.  */

+    close (f[1]);

+    close (inp[0]);

+

+    state.outfd = inp[1];

+    state.infd = f[0];

+    state.direct_output = 0;

+    _Unwind_Backtrace (trace_function, &state);

+    if (state.error)

+      goto fallback;

+    close (inp[1]);

+    close (f[0]);

+    wait (NULL);

+    return;

+

+fallback:

+    estr_write ("** Something went wrong while running addr2line. **\n"

+		"** Falling back to a simpler backtrace scheme. **\n");

+  }

+  while (0);

+

+fallback_noerr:

+#endif /* CAN_PIPE */

+

+  /* Fallback to the simple backtrace without addr2line.  */

+  state.direct_output = 1;

+  _Unwind_Backtrace (trace_function, &state);

+}

+iexport(backtrace);

--- libgfortran/Makefile.in.jj	2014-04-11 14:53:46.285365320 +0200

+++ libgfortran/Makefile.in	2014-05-09 15:14:49.882967623 +0200