commit gcc-4.4.3 which is used to build gcc-4.4.3 Android toolchain in master.

The source is based on fsf gcc-4.4.3 and contains local patches which
are recorded in gcc-4.4.3/README.google.

Change-Id: Id8c6d6927df274ae9749196a1cc24dbd9abc9887

1 files changed, 263 insertions, 0 deletions

diff --git a/gcc-4.4.3/libjava/include/dwarf2-signal.h b/gcc-4.4.3/libjava/include/dwarf2-signal.h
new file mode 100644
index 000000000..43f0cbe91
--- /dev/null
+++ b/gcc-4.4.3/libjava/include/dwarf2-signal.h
@@ -0,0 +1,263 @@
+// dwarf2-signal.h - Catch runtime signals and turn them into exceptions.
+
+/* Copyright (C) 2000, 2001  Free Software Foundation
+
+   This file is part of libgcj.
+
+   Use this file for a target for which the dwarf2 unwinder in libgcc
+   can unwind through signal handlers.
+
+This software is copyrighted work licensed under the terms of the
+Libgcj License.  Please consult the file "LIBGCJ_LICENSE" for
+details.  */
+
+#ifndef JAVA_SIGNAL_H
+#define JAVA_SIGNAL_H 1
+
+#include <signal.h>
+#include <sys/syscall.h>
+
+#define HANDLE_SEGV 1
+#undef HANDLE_FPE
+
+#define SIGNAL_HANDLER(_name)	\
+static void _Jv_##_name (int, siginfo_t *_sip, void *_p)
+
+class java::lang::Throwable;
+
+// Unwind the stack to the point at which the signal was generated and
+// then throw an exception.  With the dwarf2 unwinder we don't usually
+// need to do anything, with some minor exceptions.
+
+#ifdef __alpha__
+#define MAKE_THROW_FRAME(_exception)					\
+do									\
+{									\
+  /* Alpha either leaves PC pointing at a faulting instruction or the	\
+   following instruction, depending on the signal.  SEGV always does	\
+   the former, so we adjust the saved PC to point to the following	\
+   instruction; this is what the handler in libgcc expects.  */		\
+  struct sigcontext *_sc = (struct sigcontext *)_p;			\
+  _sc->sc_pc += 4;							\
+}									\
+while (0)
+
+#elif defined(__ia64__)
+
+#define MAKE_THROW_FRAME(_exception)					\
+do									\
+{									\
+  /* IA-64 either leaves PC pointing at a faulting instruction or the	\
+   following instruction, depending on the signal.  SEGV always does	\
+   the former, so we adjust the saved PC to point to the following	\
+   instruction; this is what the handler in libgcc expects.  */		\
+  /* Note that we are lying to the unwinder here, which expects the	\
+   faulting pc, not pc+1.  But we claim the unwind information can't	\
+   be changed by such a ld or st instruction, so it doesn't matter. */	\
+  struct sigcontext *_sc = (struct sigcontext *)_p;			\
+  _sc->sc_ip++;								\
+}									\
+while (0)
+#elif defined(__sparc__)
+/* We could do the unwind of the signal frame quickly by hand here like
+   sparc-signal.h does under Solaris, but that makes debugging unwind
+   failures almost impossible.  */
+#if !defined(__arch64__)
+#define MAKE_THROW_FRAME(_exception)					\
+do									\
+{									\
+  /* Sparc-32 leaves PC pointing at a faulting instruction		\
+   always.								\
+   We advance the PC one instruction past the exception causing PC.	\
+   This is done because FDEs are found with "context->ra - 1" in the	\
+   unwinder.								\
+   Also, the dwarf2 unwind machinery is going to add 8 to the		\
+   PC it uses on Sparc.  So we adjust the PC here.  We do it here	\
+   because we run once for such an exception, however the Sparc specific\
+   unwind can run multiple times for the same exception and it would	\
+   adjust the PC more than once resulting in a bogus value.  */		\
+  struct sig_regs {							\
+    unsigned int psr, pc, npc, y, u_regs[16];				\
+  } *regp;								\
+  unsigned int insn;							\
+  __asm__ __volatile__("ld [%%i7 + 8], %0" : "=r" (insn));		\
+  /* mov __NR_sigaction, %g1; Old signal stack layout */		\
+  if (insn == 0x821020d8)						\
+    regp = (struct sig_regs *) _sip;					\
+  else									\
+    /* mov __NR_rt_sigaction, %g1; New signal stack layout */		\
+    regp = (struct sig_regs *) (_sip + 1);				\
+  regp->pc = ((regp->pc + 4) - 8);					\
+}									\
+while (0)
+#else
+#define MAKE_THROW_FRAME(_exception)					\
+do									\
+{									\
+  /* Sparc-64 leaves PC pointing at a faulting instruction		\
+   always.								\
+   We advance the PC one instruction past the exception causing PC.	\
+   This is done because FDEs are found with "context->ra - 1" in the	\
+   unwinder.								\
+   Also, the dwarf2 unwind machinery is going to add 8 to the		\
+   PC it uses on Sparc.  So we adjust the PC here.  We do it here	\
+   because we run once for such an exception, however the Sparc specific\
+   unwind can run multiple times for the same exception and it would	\
+   adjust the PC more than once resulting in a bogus value.  */		\
+  struct pt_regs {							\
+    unsigned long u_regs[16];						\
+    unsigned long tstate, tpc, tnpc;					\
+    unsigned int y, fprs;						\
+  } *regp = (struct pt_regs *) (_sip + 1);				\
+  regp->tpc = ((regp->tpc + 4) - 8);					\
+}									\
+while (0)
+#endif
+#else
+#define MAKE_THROW_FRAME(_exception)		\
+do						\
+{						\
+  (void)_p;					\
+}						\
+while (0)
+#endif
+
+#if defined(__sparc__)
+#if defined(__arch64__)
+extern "C" {
+    static void __rt_sigreturn_stub(void)
+    {
+      __asm__("mov %0, %%g1\n\t"
+	      "ta  0x6d\n\t"
+	      : /* no outputs */
+	      : "i" (__NR_rt_sigreturn));
+    }
+    struct kernel_sigaction
+    {
+      void (*k_sa_sigaction)(int,siginfo_t *,void *);
+      unsigned long k_sa_flags;
+      void (*k_sa_restorer)(void);
+      sigset_t k_sa_mask;
+    };
+}
+#define INIT_SEGV						\
+do								\
+  {								\
+    struct kernel_sigaction act;				\
+    unsigned long stub = ((unsigned long)&__rt_sigreturn_stub); \
+    act.k_sa_sigaction = _Jv_catch_segv;      			\
+    sigemptyset (&act.k_sa_mask);				\
+    act.k_sa_flags = SA_SIGINFO;	       			\
+    act.k_sa_restorer = NULL;					\
+    syscall (SYS_rt_sigaction, SIGSEGV, &act, NULL,		\
+             stub - 8, _NSIG / 8);				\
+  }								\
+while (0)  
+
+#define INIT_FPE						\
+do								\
+  { 								\
+    struct kernel_sigaction act;				\
+    unsigned long stub = ((unsigned long)&__rt_sigreturn_stub); \
+    act.k_sa_sigaction = _Jv_catch_fpe;				\
+    sigemptyset (&act.k_sa_mask);				\
+    act.k_sa_flags = SA_SIGINFO;		       		\
+    act.k_sa_restorer = NULL;					\
+    syscall (SYS_rt_sigaction, SIGFPE, &act, NULL,		\
+             stub - 8, _NSIG / 8);				\
+  }								\
+while (0)  
+#else /* __arch64__ */
+
+extern "C" {
+    struct kernel_sigaction
+    {
+      void (*k_sa_sigaction)(int,siginfo_t *,void *);
+      unsigned long k_sa_mask, k_sa_flags;
+      void (*k_sa_restorer)(void);
+    };
+}
+
+#define INIT_SEGV						\
+do								\
+  {								\
+    struct kernel_sigaction act;				\
+    act.k_sa_sigaction = _Jv_catch_segv;      			\
+    act.k_sa_mask = 0;						\
+    act.k_sa_flags = SA_SIGINFO;	       			\
+    act.k_sa_restorer = NULL;					\
+    syscall (SYS_sigaction, -SIGSEGV, &act, NULL);		\
+  }								\
+while (0)  
+
+#define INIT_FPE						\
+do								\
+  { 								\
+    struct kernel_sigaction act;				\
+    act.k_sa_sigaction = _Jv_catch_fpe;				\
+    act.k_sa_mask = 0;						\
+    act.k_sa_flags = SA_SIGINFO;		       		\
+    act.k_sa_restorer = NULL;					\
+    syscall (SYS_sigaction, -SIGFPE, &act, NULL);		\
+  }								\
+while (0)  
+#endif
+#elif !defined(__ia64__)
+#define INIT_SEGV						\
+do								\
+  {								\
+    struct sigaction act;					\
+    act.sa_sigaction = _Jv_catch_segv;      			\
+    sigemptyset (&act.sa_mask);					\
+    act.sa_flags = SA_SIGINFO;	       				\
+    syscall (SYS_sigaction, SIGSEGV, &act, NULL);		\
+  }								\
+while (0)  
+
+#define INIT_FPE						\
+do								\
+  { 								\
+    struct sigaction act;					\
+    act.sa_sigaction = _Jv_catch_fpe;				\
+    sigemptyset (&act.sa_mask);					\
+    act.sa_flags = SA_SIGINFO;		       			\
+    syscall (SYS_sigaction, SIGFPE, &act, NULL);		\
+  }								\
+while (0)  
+
+/* We use syscall(SYS_sigaction) in INIT_SEGV and INIT_FPE instead of
+ * sigaction() because on some systems the pthreads wrappers for
+ * signal handlers are not compiled with unwind information, so it's
+ * not possible to unwind through them.  This is a problem that will
+ * go away once all systems have pthreads libraries that are
+ * compiled with full unwind info.  */
+
+#else  /* __ia64__ */
+
+// On IA64, unwind information is mandatory, so we can unwind
+// correctly through glibc frames.  Thus we call the ordinary
+// sigaction.
+
+#define INIT_SEGV						\
+do								\
+  {								\
+    struct sigaction act;					\
+    act.sa_sigaction = _Jv_catch_segv;      			\
+    sigemptyset (&act.sa_mask);					\
+    act.sa_flags = SA_SIGINFO;	       				\
+    sigaction (SIGSEGV, &act, NULL);				\
+  }								\
+while (0)  
+
+#define INIT_FPE						\
+do								\
+  { 								\
+    struct sigaction act;					\
+    act.sa_sigaction = _Jv_catch_fpe;				\
+    sigemptyset (&act.sa_mask);					\
+    act.sa_flags = SA_SIGINFO;		       			\
+    sigaction (SIGFPE, &act, NULL);				\
+  }								\
+while (0)  
+#endif /* __ia64__ || __sparc__ */
+#endif /* JAVA_SIGNAL_H */