automatic import of compat-libgfortran-48openeuler24.03_LTSopeneuler23.09

1 files changed, 2705 insertions, 0 deletions

diff --git a/gcc48-rh1469697-6.patch b/gcc48-rh1469697-6.patch
new file mode 100644
index 0000000..b08bb30
--- /dev/null
+++ b/gcc48-rh1469697-6.patch
@@ -0,0 +1,2705 @@
+commit dd9992d1b96b5811873c98a208c029bebb0c3577
+Author: law <law@138bc75d-0d04-0410-961f-82ee72b054a4>
+Date:   Wed Sep 20 05:35:07 2017 +0000
+
+            * config/i386/i386.c (ix86_adjust_stack_and_probe_stack_clash): New.
+            (ix86_expand_prologue): Dump stack clash info as needed.
+            Call ix86_adjust_stack_and_probe_stack_clash as needed.
+    
+            * gcc.dg/stack-check-4.c: New test.
+            * gcc.dg/stack-check-5.c: New test.
+            * gcc.dg/stack-check-6.c: New test.
+            * gcc.dg/stack-check-6a.c: New test.
+            * gcc.dg/stack-check-7.c: New test.
+            * gcc.dg/stack-check-8.c: New test.
+            * gcc.dg/stack-check-9.c: New test.
+            * gcc.dg/stack-check-10.c: New test.
+            * lib/target-supports.exp
+            (check_effective_target_supports_stack_clash_protection): Enable for
+            x86 and x86_64 targets.
+    
+    git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@252998 138bc75d-0d04-0410-961f-82ee72b054a4
+
+diff --git a/gcc/config/i386/i386.c b/gcc/config/i386/i386.c
+index d996fd160e8..a555b0774c0 100644
+--- a/gcc/config/i386/i386.c
++++ b/gcc/config/i386/i386.c
+@@ -9839,6 +9839,147 @@ release_scratch_register_on_entry (struct scratch_reg *sr)
+ 
+ #define PROBE_INTERVAL (1 << STACK_CHECK_PROBE_INTERVAL_EXP)
+ 
++/* Emit code to adjust the stack pointer by SIZE bytes while probing it.
++
++   This differs from the next routine in that it tries hard to prevent
++   attacks that jump the stack guard.  Thus it is never allowed to allocate
++   more than PROBE_INTERVAL bytes of stack space without a suitable
++   probe.  */
++
++static void
++ix86_adjust_stack_and_probe_stack_clash (const HOST_WIDE_INT size)
++{
++  struct machine_function *m = cfun->machine;
++
++  /* If this function does not statically allocate stack space, then
++     no probes are needed.  */
++  if (!size)
++    {
++      dump_stack_clash_frame_info (NO_PROBE_NO_FRAME, false);
++      return;
++    }
++
++  /* If we are a noreturn function, then we have to consider the
++     possibility that we're called via a jump rather than a call.
++
++     Thus we don't have the implicit probe generated by saving the
++     return address into the stack at the call.  Thus, the stack
++     pointer could be anywhere in the guard page.  The safe thing
++     to do is emit a probe now.
++
++     ?!? This should be revamped to work like aarch64 and s390 where
++     we track the offset from the most recent probe.  Normally that
++     offset would be zero.  For a non-return function we would reset
++     it to PROBE_INTERVAL - (STACK_BOUNDARY / BITS_PER_UNIT).   Then
++     we just probe when we cross PROBE_INTERVAL.  */
++  if (TREE_THIS_VOLATILE (cfun->decl))
++    {
++      emit_stack_probe (plus_constant (Pmode, stack_pointer_rtx,
++				       -GET_MODE_SIZE (word_mode)));
++      emit_insn (gen_blockage ());
++    }
++
++  /* If we allocate less than the size of the guard statically,
++     then no probing is necessary, but we do need to allocate
++     the stack.  */
++  if (size < (1 << PARAM_VALUE (PARAM_STACK_CLASH_PROTECTION_GUARD_SIZE)))
++    {
++      pro_epilogue_adjust_stack (stack_pointer_rtx, stack_pointer_rtx,
++			         GEN_INT (-size), -1,
++			         m->fs.cfa_reg == stack_pointer_rtx);
++      dump_stack_clash_frame_info (NO_PROBE_SMALL_FRAME, true);
++      return;
++    }
++
++  /* We're allocating a large enough stack frame that we need to
++     emit probes.  Either emit them inline or in a loop depending
++     on the size.  */
++  HOST_WIDE_INT probe_interval
++    = 1 << PARAM_VALUE (PARAM_STACK_CLASH_PROTECTION_PROBE_INTERVAL);
++  if (size <= 4 * probe_interval)
++    {
++      HOST_WIDE_INT i;
++      for (i = probe_interval; i <= size; i += probe_interval)
++	{
++	  /* Allocate PROBE_INTERVAL bytes.  */
++	  pro_epilogue_adjust_stack (stack_pointer_rtx, stack_pointer_rtx,
++				     GEN_INT (-probe_interval), -1,
++				     m->fs.cfa_reg == stack_pointer_rtx);
++
++	  /* And probe at *sp.  */
++	  emit_stack_probe (stack_pointer_rtx);
++	  emit_insn (gen_blockage ());
++	}
++
++      /* We need to allocate space for the residual, but we do not need
++	 to probe the residual.  */
++      HOST_WIDE_INT residual = (i - probe_interval - size);
++      if (residual)
++	pro_epilogue_adjust_stack (stack_pointer_rtx, stack_pointer_rtx,
++				   GEN_INT (residual), -1,
++				   m->fs.cfa_reg == stack_pointer_rtx);
++      dump_stack_clash_frame_info (PROBE_INLINE, residual != 0);
++    }
++  else
++    {
++      struct scratch_reg sr;
++      get_scratch_register_on_entry (&sr);
++
++      /* Step 1: round SIZE down to a multiple of the interval.  */
++      HOST_WIDE_INT rounded_size = size & -probe_interval;
++
++      /* Step 2: compute final value of the loop counter.  Use lea if
++	 possible.  */
++      rtx addr = plus_constant (Pmode, stack_pointer_rtx, -rounded_size);
++      rtx insn;
++      if (address_operand (addr, Pmode))
++	insn = emit_insn (gen_rtx_SET (VOIDmode, sr.reg, addr));
++      else
++	{
++	  emit_move_insn (sr.reg, GEN_INT (-rounded_size));
++	  insn = emit_insn (gen_rtx_SET (VOIDmode, sr.reg,
++					 gen_rtx_PLUS (Pmode, sr.reg,
++						       stack_pointer_rtx)));
++	}
++      if (m->fs.cfa_reg == stack_pointer_rtx)
++	{
++	  add_reg_note (insn, REG_CFA_DEF_CFA,
++			plus_constant (Pmode, sr.reg,
++				       m->fs.cfa_offset + rounded_size));
++	  RTX_FRAME_RELATED_P (insn) = 1;
++        }
++
++      /* Step 3: the loop.  */
++      rtx size_rtx = GEN_INT (rounded_size);
++      insn = emit_insn (ix86_gen_adjust_stack_and_probe (sr.reg, sr.reg,
++							 size_rtx));
++      if (m->fs.cfa_reg == stack_pointer_rtx)
++	{
++	  m->fs.cfa_offset += rounded_size;
++	  add_reg_note (insn, REG_CFA_DEF_CFA,
++			plus_constant (Pmode, stack_pointer_rtx,
++				       m->fs.cfa_offset));
++	  RTX_FRAME_RELATED_P (insn) = 1;
++        }
++      m->fs.sp_offset += rounded_size;
++      emit_insn (gen_blockage ());
++
++      /* Step 4: adjust SP if we cannot assert at compile-time that SIZE
++	 is equal to ROUNDED_SIZE.  */
++
++      if (size != rounded_size)
++	pro_epilogue_adjust_stack (stack_pointer_rtx, stack_pointer_rtx,
++				   GEN_INT (rounded_size - size), -1,
++				   m->fs.cfa_reg == stack_pointer_rtx);
++      dump_stack_clash_frame_info (PROBE_LOOP, size != rounded_size);
++
++      release_scratch_register_on_entry (&sr);
++    }
++
++  /* Make sure nothing is scheduled before we are done.  */
++  emit_insn (gen_blockage ());
++}
++
+ /* Emit code to adjust the stack pointer by SIZE bytes while probing it.  */
+ 
+ static void
+@@ -10529,12 +10670,19 @@ ix86_expand_prologue (void)
+ 
+   /* The stack has already been decremented by the instruction calling us
+      so probe if the size is non-negative to preserve the protection area.  */
+-  if (allocate >= 0 && flag_stack_check == STATIC_BUILTIN_STACK_CHECK)
++  if (allocate >= 0
++      && (flag_stack_check == STATIC_BUILTIN_STACK_CHECK
++	  || flag_stack_clash_protection))
+     {
+       /* We expect the registers to be saved when probes are used.  */
+       gcc_assert (int_registers_saved);
+ 
+-      if (STACK_CHECK_MOVING_SP)
++      if (flag_stack_clash_protection)
++	{
++	  ix86_adjust_stack_and_probe_stack_clash (allocate);
++	  allocate = 0;
++	}
++      else if (STACK_CHECK_MOVING_SP)
+ 	{
+ 	  ix86_adjust_stack_and_probe (allocate);
+ 	  allocate = 0;
+diff --git a/gcc/testsuite/gcc.dg/stack-check-10.c b/gcc/testsuite/gcc.dg/stack-check-10.c
+new file mode 100644
+index 00000000000..a86956ad692
+--- /dev/null
++++ b/gcc/testsuite/gcc.dg/stack-check-10.c
+@@ -0,0 +1,41 @@
++/* { dg-do compile } */
++/* { dg-options "-O2 -fstack-clash-protection -fdump-rtl-pro_and_epilogue -fno-optimize-sibling-calls --param stack-clash-protection-probe-interval=12 --param stack-clash-protection-guard-size=12" } */
++/* { dg-require-effective-target supports_stack_clash_protection } */
++
++int f (int *);
++
++int
++g (int a)
++{
++  return f (&a);
++}
++
++int f1 (void);
++int f2 (int);
++
++int
++f3 (void)
++{
++  return f2 (f1 ());
++}
++
++
++/* If we have caller implicit probes, then we should not need probes in either callee.
++   Else callees may need probes, particularly if non-leaf functions require a
++   frame/frame pointer.  */
++/* { dg-final { scan-rtl-dump-times "Stack clash no probe" 2 "pro_and_epilogue" { target caller_implicit_probes } } } */
++/* { dg-final { scan-rtl-dump-times "Stack clash inline probe" 1 "pro_and_epilogue" { target { ! caller_implicit_probes } } } } */
++/* { dg-final { scan-rtl-dump-times "Stack clash no probe" 1 "pro_and_epilogue" { target { ! caller_implicit_probes } } } } */
++
++/* Neither of these functions are a nonreturn function.  */
++/* { dg-final { scan-rtl-dump-times "Stack clash not noreturn" 2 "pro_and_epilogue" } } */
++
++/* If the callee realigns the stack or has a mandatory frame, then both functions
++   have a residual allocation.  Else just g() has a residual allocation.  */
++/* { dg-final { scan-rtl-dump-times "Stack clash residual allocation in prologue" 2 "pro_and_epilogue" } } */
++
++
++/* If the target has frame pointers for non-leafs, then both functions will
++   need a frame pointer.  Otherwise neither should.  */
++/* { dg-final { scan-rtl-dump-times "Stack clash no frame pointer needed" 2 "pro_and_epilogue" { target { ! frame_pointer_for_non_leaf } } } } */
++/* { dg-final { scan-rtl-dump-times "Stack clash frame pointer needed" 2 "pro_and_epilogue" { target { frame_pointer_for_non_leaf } } } } */
+diff --git a/gcc/testsuite/gcc.dg/stack-check-3.c b/gcc/testsuite/gcc.dg/stack-check-3.c
+index 58fb65649ee..f0bf7c71a5b 100644
+--- a/gcc/testsuite/gcc.dg/stack-check-3.c
++++ b/gcc/testsuite/gcc.dg/stack-check-3.c
+@@ -7,7 +7,7 @@
+    residual allocation + probe for f?.  */
+ 
+ /* { dg-do compile } */
+-/* { dg-options "-O2 -fstack-clash-protection -fdump-rtl-expand -fno-optimize-sibling-calls --param stack-clash-protection-probe-interval=4096 --param stack-clash-protection-guard-size=4096" } */
++/* { dg-options "-O2 -fstack-clash-protection -fdump-rtl-expand -fno-optimize-sibling-calls --param stack-clash-protection-probe-interval=12 --param stack-clash-protection-guard-size=12" } */
+ /* { dg-require-effective-target supports_stack_clash_protection } */
+ 
+ __attribute__((noinline, noclone)) void
+diff --git a/gcc/testsuite/gcc.dg/stack-check-4.c b/gcc/testsuite/gcc.dg/stack-check-4.c
+new file mode 100644
+index 00000000000..b0c5c61972f
+--- /dev/null
++++ b/gcc/testsuite/gcc.dg/stack-check-4.c
+@@ -0,0 +1,42 @@
++/* On targets where the call instruction is an implicit probe of *sp, we
++   elide stack probes as long as the size of the local stack is less than
++   PROBE_INTERVAL.
++
++   But if the caller were to transform a tail call into a direct jump
++   we do not have that implicit probe.  This normally isn't a problem as
++   the caller must not have a local frame for that optimization to apply.
++
++   However, a sufficiently smart compiler could realize that the caller's
++   local stack need not be torn down and thus could transform a call into
++   a jump if the target is a noreturn function, even if the caller has
++   a local frame.
++
++   To guard against that, targets that depend on *sp being probed by the
++   call itself must emit a probe if the target function is a noreturn
++   function, even if they just allocate a small amount of stack space.
++
++   Rather than try to parse RTL or assembly code, we instead require the
++   prologue code to emit information into the dump file that we can
++   scan for.   We scan for both the positive and negative cases.  */
++
++/* { dg-do compile } */
++/* { dg-options "-O2 -fstack-clash-protection -fdump-rtl-pro_and_epilogue -fno-optimize-sibling-calls" } */
++/* { dg-require-effective-target supports_stack_clash_protection } */
++
++extern void arf (char *);
++
++__attribute__ ((noreturn)) void foo1 ()
++{
++  char x[10];
++  while (1)
++    arf (x);
++}
++
++void foo2 ()
++{
++  char x[10];
++  arf (x);
++}
++/* { dg-final { scan-rtl-dump-times "Stack clash noreturn" 1 "pro_and_epilogue" } } */
++/* { dg-final { scan-rtl-dump-times "Stack clash not noreturn" 1 "pro_and_epilogue" } } */
++
+diff --git a/gcc/testsuite/gcc.dg/stack-check-5.c b/gcc/testsuite/gcc.dg/stack-check-5.c
+new file mode 100644
+index 00000000000..2171d9b6c23
+--- /dev/null
++++ b/gcc/testsuite/gcc.dg/stack-check-5.c
+@@ -0,0 +1,74 @@
++/* { dg-do compile } */
++/* { dg-options "-O2 -fstack-clash-protection -fdump-rtl-pro_and_epilogue -fno-optimize-sibling-calls --param stack-clash-protection-probe-interval=12 --param stack-clash-protection-guard-size=12" } */
++/* { dg-require-effective-target supports_stack_clash_protection } */
++
++
++extern void foo (char *);
++extern void bar (void);
++
++/* This function allocates no local stack and is a leaf.  It should have no
++   probes on any target and should not require a frame pointer.  */
++int
++f0 (int x, int y)
++{
++  asm volatile ("" : : : "memory");  
++  return x + y;
++}
++
++/* This function allocates no local stack, but is not a leaf.  Ideally it
++   should not need probing and no frame pointer.  */
++int
++f1 (int x, int y)
++{
++  asm volatile ("" : : : "memory");  
++  bar ();
++}
++
++/* This is a leaf with a small frame.  On targets with implicit probes in
++   the caller, this should not need probing.  On targets with no implicit
++   probes in the caller, it may require probes.  Ideally it should need no
++   frame pointer.  */
++void
++f2 (void)
++{
++  char buf[512];
++  asm volatile ("" : : "g" (&buf) : "memory");
++}
++
++/* This is a non-leaf with a small frame.  On targets with implicit probes in
++   the caller, this should not need probing.  On targets with no implicit
++   probes in the caller, it may require probes.  It should need no frame
++   pointer.  */
++void
++f3 (void)
++{
++  char buf[512];
++  foo (buf);
++}
++
++/* If we have caller implicit probes, then we should not need probes.
++   Else callees may need probes, particularly if non-leaf functions require a
++   frame/frame pointer.  */
++/* { dg-final { scan-rtl-dump-times "Stack clash no probe" 4 "pro_and_epilogue" { target caller_implicit_probes } } } */
++/* { dg-final { scan-rtl-dump-times "Stack clash no probe" 2 "pro_and_epilogue" { target { ! caller_implicit_probes } } } } */
++/* { dg-final { scan-rtl-dump-times "Stack clash inline probes " 2 "pro_and_epilogue" { target { ! caller_implicit_probes } } } } */
++
++/* None of these functions are marked with the noreturn attribute.  */
++/* { dg-final { scan-rtl-dump-times "Stack clash not noreturn" 4 "pro_and_epilogue" } } */
++
++/* Two functions are leafs, two are not.  Verify the target identified them
++   appropriately.  */
++/* { dg-final { scan-rtl-dump-times "Stack clash no frame pointer needed" 4 "pro_and_epilogue" { target { ! frame_pointer_for_non_leaf } } } } */
++/* { dg-final { scan-rtl-dump-times "Stack clash no frame pointer needed" 2 "pro_and_epilogue" { target { frame_pointer_for_non_leaf } } } } */
++/* { dg-final { scan-rtl-dump-times "Stack clash frame pointer needed" 2 "pro_and_epilogue" { target { frame_pointer_for_non_leaf } } } } */
++
++
++/* We have selected the size of the array in f2/f3 to be large enough
++   to not live in the red zone on targets that support it.
++
++   That allows simplification of this test considerably.
++   f1() should not require any allocations, thus no residuals.
++   All the rest of the functions require some kind of allocation,
++   either for the saved fp/rp or the array.  */
++/* { dg-final { scan-rtl-dump-times "Stack clash no residual allocation in prologue" 1 "pro_and_epilogue" } } */
++/* { dg-final { scan-rtl-dump-times "Stack clash residual allocation in prologue" 3 "pro_and_epilogue" } } */
+diff --git a/gcc/testsuite/gcc.dg/stack-check-6.c b/gcc/testsuite/gcc.dg/stack-check-6.c
+new file mode 100644
+index 00000000000..ad2021c9037
+--- /dev/null
++++ b/gcc/testsuite/gcc.dg/stack-check-6.c
+@@ -0,0 +1,55 @@
++/* { dg-do compile } */
++/* { dg-options "-O2 -fstack-clash-protection -fdump-rtl-pro_and_epilogue -fno-optimize-sibling-calls --param stack-clash-protection-probe-interval=12 --param stack-clash-protection-guard-size=12" } */
++/* { dg-require-effective-target supports_stack_clash_protection } */
++
++
++extern void foo (char *);
++extern void bar (void);
++
++
++/* This is a leaf with a frame that is large enough to require probing with
++   a residual allocation, but small enough to probe inline.  */
++void
++f4 (void)
++{
++  char buf[4096 + 512];
++  asm volatile ("" : : "g" (&buf) : "memory");
++}
++
++
++/* This is a non-leaf with a frame large enough to require probing and
++   a residual allocation, but small enough to probe inline.  */
++void
++f5 (void)
++{
++  char buf[4096 + 512];
++  foo (buf);
++}
++
++/* This is a leaf with a frame that is large enough to require probing with
++   a loop plus a residual allocation.  */
++void
++f6 (void)
++{
++  char buf[4096 * 10 + 512];
++  asm volatile ("" : : "g" (&buf) : "memory");
++}
++
++
++/* This is a non-leaf with a frame large enough to require probing with
++   a loop plus a residual allocation.  */
++void
++f7 (void)
++{
++  char buf[4096 * 10 + 512];
++  foo (buf);
++}
++
++/* { dg-final { scan-rtl-dump-times "Stack clash inline probes" 2 "pro_and_epilogue" } } */
++/* { dg-final { scan-rtl-dump-times "Stack clash probe loop" 2 "pro_and_epilogue" } } */
++/* { dg-final { scan-rtl-dump-times "Stack clash residual allocation in prologue" 4 "pro_and_epilogue" } } */
++/* { dg-final { scan-rtl-dump-times "Stack clash not noreturn" 4 "pro_and_epilogue" } } */
++
++/* { dg-final { scan-rtl-dump-times "Stack clash no frame pointer needed" 4 "pro_and_epilogue" { target { ! frame_pointer_for_non_leaf } } } } */
++/* { dg-final { scan-rtl-dump-times "Stack clash no frame pointer needed" 2 "pro_and_epilogue" { target { frame_pointer_for_non_leaf } } } } */
++/* { dg-final { scan-rtl-dump-times "Stack clash frame pointer needed" 2 "pro_and_epilogue" { target { frame_pointer_for_non_leaf } } } } */
+diff --git a/gcc/testsuite/gcc.dg/stack-check-6a.c b/gcc/testsuite/gcc.dg/stack-check-6a.c
+new file mode 100644
+index 00000000000..6f8e7128921
+--- /dev/null
++++ b/gcc/testsuite/gcc.dg/stack-check-6a.c
+@@ -0,0 +1,17 @@
++/* The goal here is to verify that increasing the size of the guard allows
++   elimination of all probing on the relevant targets.  */
++   
++/* { dg-do compile  } */
++/* { dg-options "-O2 -fstack-clash-protection -fdump-rtl-pro_and_epilogue -fno-optimize-sibling-calls --param stack-clash-protection-probe-interval=12 --param stack-clash-protection-guard-size=16" } */
++/* { dg-require-effective-target supports_stack_clash_protection  } */
++
++#include "stack-check-6.c"
++
++/* { dg-final { scan-rtl-dump-times "Stack clash inline probes" 0 "pro_and_epilogue" } } */
++/* { dg-final { scan-rtl-dump-times "Stack clash probe loop" 0 "pro_and_epilogue" } } */
++/* { dg-final { scan-rtl-dump-times "Stack clash residual allocation in prologue" 4 "pro_and_epilogue" } } */
++/* { dg-final { scan-rtl-dump-times "Stack clash not noreturn" 4 "pro_and_epilogue" } } */
++
++/* { dg-final { scan-rtl-dump-times "Stack clash no frame pointer needed" 4 "pro_and_epilogue" { target { ! frame_pointer_for_non_leaf } } } } */
++/* { dg-final { scan-rtl-dump-times "Stack clash no frame pointer needed" 2 "pro_and_epilogue" { target { frame_pointer_for_non_leaf } } } } */
++/* { dg-final { scan-rtl-dump-times "Stack clash frame pointer needed" 2 "pro_and_epilogue" { target { frame_pointer_for_non_leaf } } } } */
+diff --git a/gcc/testsuite/gcc.dg/stack-check-7.c b/gcc/testsuite/gcc.dg/stack-check-7.c
+new file mode 100644
+index 00000000000..b963a2881dc
+--- /dev/null
++++ b/gcc/testsuite/gcc.dg/stack-check-7.c
+@@ -0,0 +1,36 @@
++/* { dg-do run } */
++/* { dg-options "-O2 -fstack-clash-protection -fno-optimize-sibling-calls --param stack-clash-protection-probe-interval=12 --param stack-clash-protection-guard-size=12" } */
++/* { dg-require-effective-target supports_stack_clash_protection } */
++
++/* For further testing, this can be run under valgrind where it's crashed
++   on aarch64 and ppc64le with -fstack-check=specific.  */
++
++
++__attribute__((noinline, noclone)) void
++foo (char *p)
++{
++  asm volatile ("" : : "r" (p) : "memory");
++}
++
++__attribute__((noinline, noclone)) void
++bar (void)
++{
++  char buf[131072];
++  foo (buf);
++}
++
++__attribute__((noinline, noclone)) void
++baz (void)
++{
++  char buf[12000];
++  foo (buf);
++}
++
++int
++main ()
++{
++  bar ();
++  baz ();
++  return 0;
++}
++
+diff --git a/gcc/testsuite/gcc.dg/stack-check-8.c b/gcc/testsuite/gcc.dg/stack-check-8.c
+new file mode 100644
+index 00000000000..0ccec8b532a
+--- /dev/null
++++ b/gcc/testsuite/gcc.dg/stack-check-8.c
+@@ -0,0 +1,139 @@
++/* { dg-do run } */
++/* { dg-options "-O2 -w -fstack-clash-protection -Wno-psabi -fno-optimize-sibling-calls --param stack-clash-protection-probe-interval=12 --param stack-clash-protection-guard-size=12" } */
++/* { dg-require-effective-target supports_stack_clash_protection } */
++
++
++typedef float V __attribute__((vector_size (32)));
++
++__attribute__((noinline, noclone)) void
++foo (char *p)
++{
++  asm volatile ("" : : "r" (p) : "memory");
++}
++
++__attribute__((noinline, noclone)) int
++f0 (int x, int y)
++{
++  asm volatile ("" : : : "memory");  
++  return x + y;
++}
++
++__attribute__((noinline, noclone)) void
++f1 (void)
++{
++  char buf[64];
++  foo (buf);
++}
++
++__attribute__((noinline, noclone)) void
++f2 (void)
++{
++  char buf[12000];
++  foo (buf);
++}
++
++__attribute__((noinline, noclone)) void
++f3 (void)
++{
++  char buf[131072];
++  foo (buf);
++}
++
++__attribute__((noinline, noclone)) void
++f4 (int x)
++{
++  char vla[x];
++  foo (vla);
++}
++
++__attribute__((noinline, noclone)) void
++f5 (int x)
++{
++  char buf[12000];
++  foo (buf);
++  {
++    char vla[x];
++    foo (vla);
++  }
++  {
++    char vla[x];
++    foo (vla);
++  }
++}
++
++V v;
++
++__attribute__((noinline, noclone)) int
++f6 (int x, int y, V a, V b, V c)
++{
++  asm volatile ("" : : : "memory");  
++  v = a + b + c;
++  return x + y;
++}
++
++__attribute__((noinline, noclone)) void
++f7 (V a, V b, V c)
++{
++  char buf[64];
++  foo (buf);
++  v = a + b + c;
++}
++
++__attribute__((noinline, noclone)) void
++f8 (V a, V b, V c)
++{
++  char buf[12000];
++  foo (buf);
++  v = a + b + c;
++}
++
++__attribute__((noinline, noclone)) void
++f9 (V a, V b, V c)
++{
++  char buf[131072];
++  foo (buf);
++  v = a + b + c;
++}
++
++__attribute__((noinline, noclone)) void
++f10 (int x, V a, V b, V c)
++{
++  char vla[x];
++  foo (vla);
++  v = a + b + c;
++}
++
++__attribute__((noinline, noclone)) void
++f11 (int x, V a, V b, V c)
++{
++  char buf[12000];
++  foo (buf);
++  v = a + b + c;
++  {
++    char vla[x];
++    foo (vla);
++  }
++  {
++    char vla[x];
++    foo (vla);
++  }
++}
++
++int
++main ()
++{
++  f0 (2, 3);
++  f1 ();
++  f2 ();
++  f3 ();
++  f4 (12000);
++  f5 (12000);
++  f6 (2, 3, v, v, v);
++  f7 (v, v, v);
++  f8 (v, v, v);
++  f9 (v, v, v);
++  f10 (12000, v, v, v);
++  f11 (12000, v, v, v);
++  return 0;
++}
++
+diff --git a/gcc/testsuite/gcc.dg/stack-check-9.c b/gcc/testsuite/gcc.dg/stack-check-9.c
+new file mode 100644
+index 00000000000..b84075b9b43
+--- /dev/null
++++ b/gcc/testsuite/gcc.dg/stack-check-9.c
+@@ -0,0 +1,2022 @@
++/* { dg-do compile } */
++/* { dg-options "-O2 -fstack-clash-protection -fdump-rtl-pro_and_epilogue -fno-optimize-sibling-calls --param stack-clash-protection-probe-interval=12 --param stack-clash-protection-guard-size=12" } */
++/* { dg-require-effective-target supports_stack_clash_protection } */
++
++double f1 (void);
++double f2 (double, double);
++
++double
++f3 (void)
++{
++  double d000 = f1 ();
++  double d001 = f1 ();
++  double d002 = f1 ();
++  double d003 = f1 ();
++  double d004 = f1 ();
++  double d005 = f1 ();
++  double d006 = f1 ();
++  double d007 = f1 ();
++  double d008 = f1 ();
++  double d009 = f1 ();
++  double d010 = f1 ();
++  double d011 = f1 ();
++  double d012 = f1 ();
++  double d013 = f1 ();
++  double d014 = f1 ();
++  double d015 = f1 ();
++  double d016 = f1 ();
++  double d017 = f1 ();
++  double d018 = f1 ();
++  double d019 = f1 ();
++  double d020 = f1 ();
++  double d021 = f1 ();
++  double d022 = f1 ();
++  double d023 = f1 ();
++  double d024 = f1 ();
++  double d025 = f1 ();
++  double d026 = f1 ();
++  double d027 = f1 ();
++  double d028 = f1 ();
++  double d029 = f1 ();
++  double d030 = f1 ();
++  double d031 = f1 ();
++  double d032 = f1 ();
++  double d033 = f1 ();
++  double d034 = f1 ();
++  double d035 = f1 ();
++  double d036 = f1 ();
++  double d037 = f1 ();
++  double d038 = f1 ();
++  double d039 = f1 ();
++  double d040 = f1 ();
++  double d041 = f1 ();
++  double d042 = f1 ();
++  double d043 = f1 ();
++  double d044 = f1 ();
++  double d045 = f1 ();
++  double d046 = f1 ();
++  double d047 = f1 ();
++  double d048 = f1 ();
++  double d049 = f1 ();
++  double d050 = f1 ();
++  double d051 = f1 ();
++  double d052 = f1 ();
++  double d053 = f1 ();
++  double d054 = f1 ();
++  double d055 = f1 ();
++  double d056 = f1 ();
++  double d057 = f1 ();
++  double d058 = f1 ();
++  double d059 = f1 ();
++  double d060 = f1 ();
++  double d061 = f1 ();
++  double d062 = f1 ();
++  double d063 = f1 ();
++  double d064 = f1 ();
++  double d065 = f1 ();
++  double d066 = f1 ();
++  double d067 = f1 ();
++  double d068 = f1 ();
++  double d069 = f1 ();
++  double d070 = f1 ();
++  double d071 = f1 ();
++  double d072 = f1 ();
++  double d073 = f1 ();
++  double d074 = f1 ();
++  double d075 = f1 ();
++  double d076 = f1 ();
++  double d077 = f1 ();
++  double d078 = f1 ();
++  double d079 = f1 ();
++  double d080 = f1 ();
++  double d081 = f1 ();
++  double d082 = f1 ();
++  double d083 = f1 ();
++  double d084 = f1 ();
++  double d085 = f1 ();
++  double d086 = f1 ();
++  double d087 = f1 ();
++  double d088 = f1 ();
++  double d089 = f1 ();
++  double d090 = f1 ();
++  double d091 = f1 ();
++  double d092 = f1 ();
++  double d093 = f1 ();
++  double d094 = f1 ();
++  double d095 = f1 ();
++  double d096 = f1 ();
++  double d097 = f1 ();
++  double d098 = f1 ();
++  double d099 = f1 ();
++  double d100 = f1 ();
++  double d101 = f1 ();
++  double d102 = f1 ();
++  double d103 = f1 ();
++  double d104 = f1 ();
++  double d105 = f1 ();
++  double d106 = f1 ();
++  double d107 = f1 ();
++  double d108 = f1 ();
++  double d109 = f1 ();
++  double d110 = f1 ();
++  double d111 = f1 ();
++  double d112 = f1 ();
++  double d113 = f1 ();
++  double d114 = f1 ();
++  double d115 = f1 ();
++  double d116 = f1 ();
++  double d117 = f1 ();
++  double d118 = f1 ();
++  double d119 = f1 ();
++  double d120 = f1 ();
++  double d121 = f1 ();
++  double d122 = f1 ();
++  double d123 = f1 ();
++  double d124 = f1 ();
++  double d125 = f1 ();
++  double d126 = f1 ();
++  double d127 = f1 ();
++  double d128 = f1 ();
++  double d129 = f1 ();
++  double d130 = f1 ();
++  double d131 = f1 ();
++  double d132 = f1 ();
++  double d133 = f1 ();
++  double d134 = f1 ();
++  double d135 = f1 ();
++  double d136 = f1 ();
++  double d137 = f1 ();
++  double d138 = f1 ();
++  double d139 = f1 ();
++  double d140 = f1 ();
++  double d141 = f1 ();
++  double d142 = f1 ();
++  double d143 = f1 ();
++  double d144 = f1 ();
++  double d145 = f1 ();
++  double d146 = f1 ();
++  double d147 = f1 ();
++  double d148 = f1 ();
++  double d149 = f1 ();
++  double d150 = f1 ();
++  double d151 = f1 ();
++  double d152 = f1 ();
++  double d153 = f1 ();
++  double d154 = f1 ();
++  double d155 = f1 ();
++  double d156 = f1 ();
++  double d157 = f1 ();
++  double d158 = f1 ();
++  double d159 = f1 ();
++  double d160 = f1 ();
++  double d161 = f1 ();
++  double d162 = f1 ();
++  double d163 = f1 ();
++  double d164 = f1 ();
++  double d165 = f1 ();
++  double d166 = f1 ();
++  double d167 = f1 ();
++  double d168 = f1 ();
++  double d169 = f1 ();
++  double d170 = f1 ();
++  double d171 = f1 ();
++  double d172 = f1 ();
++  double d173 = f1 ();
++  double d174 = f1 ();
++  double d175 = f1 ();
++  double d176 = f1 ();
++  double d177 = f1 ();
++  double d178 = f1 ();
++  double d179 = f1 ();
++  double d180 = f1 ();
++  double d181 = f1 ();
++  double d182 = f1 ();
++  double d183 = f1 ();
++  double d184 = f1 ();
++  double d185 = f1 ();
++  double d186 = f1 ();
++  double d187 = f1 ();
++  double d188 = f1 ();
++  double d189 = f1 ();
++  double d190 = f1 ();
++  double d191 = f1 ();
++  double d192 = f1 ();
++  double d193 = f1 ();
++  double d194 = f1 ();
++  double d195 = f1 ();
++  double d196 = f1 ();
++  double d197 = f1 ();
++  double d198 = f1 ();
++  double d199 = f1 ();
++  double d200 = f1 ();
++  double d201 = f1 ();
++  double d202 = f1 ();
++  double d203 = f1 ();
++  double d204 = f1 ();
++  double d205 = f1 ();
++  double d206 = f1 ();
++  double d207 = f1 ();
++  double d208 = f1 ();
++  double d209 = f1 ();
++  double d210 = f1 ();
++  double d211 = f1 ();
++  double d212 = f1 ();
++  double d213 = f1 ();
++  double d214 = f1 ();
++  double d215 = f1 ();
++  double d216 = f1 ();
++  double d217 = f1 ();
++  double d218 = f1 ();
++  double d219 = f1 ();
++  double d220 = f1 ();
++  double d221 = f1 ();
++  double d222 = f1 ();
++  double d223 = f1 ();
++  double d224 = f1 ();
++  double d225 = f1 ();
++  double d226 = f1 ();
++  double d227 = f1 ();
++  double d228 = f1 ();
++  double d229 = f1 ();
++  double d230 = f1 ();
++  double d231 = f1 ();
++  double d232 = f1 ();
++  double d233 = f1 ();
++  double d234 = f1 ();
++  double d235 = f1 ();
++  double d236 = f1 ();
++  double d237 = f1 ();
++  double d238 = f1 ();
++  double d239 = f1 ();
++  double d240 = f1 ();
++  double d241 = f1 ();
++  double d242 = f1 ();
++  double d243 = f1 ();
++  double d244 = f1 ();
++  double d245 = f1 ();
++  double d246 = f1 ();
++  double d247 = f1 ();
++  double d248 = f1 ();
++  double d249 = f1 ();
++  double d250 = f1 ();
++  double d251 = f1 ();
++  double d252 = f1 ();
++  double d253 = f1 ();
++  double d254 = f1 ();
++  double d255 = f1 ();
++  double d256 = f1 ();
++  double d257 = f1 ();
++  double d258 = f1 ();
++  double d259 = f1 ();
++  double d260 = f1 ();
++  double d261 = f1 ();
++  double d262 = f1 ();
++  double d263 = f1 ();
++  double d264 = f1 ();
++  double d265 = f1 ();
++  double d266 = f1 ();
++  double d267 = f1 ();
++  double d268 = f1 ();
++  double d269 = f1 ();
++  double d270 = f1 ();
++  double d271 = f1 ();
++  double d272 = f1 ();
++  double d273 = f1 ();
++  double d274 = f1 ();
++  double d275 = f1 ();
++  double d276 = f1 ();
++  double d277 = f1 ();
++  double d278 = f1 ();
++  double d279 = f1 ();
++  double d280 = f1 ();
++  double d281 = f1 ();
++  double d282 = f1 ();
++  double d283 = f1 ();
++  double d284 = f1 ();
++  double d285 = f1 ();
++  double d286 = f1 ();
++  double d287 = f1 ();
++  double d288 = f1 ();
++  double d289 = f1 ();
++  double d290 = f1 ();
++  double d291 = f1 ();
++  double d292 = f1 ();
++  double d293 = f1 ();
++  double d294 = f1 ();
++  double d295 = f1 ();
++  double d296 = f1 ();
++  double d297 = f1 ();
++  double d298 = f1 ();
++  double d299 = f1 ();
++  double d300 = f1 ();
++  double d301 = f1 ();
++  double d302 = f1 ();
++  double d303 = f1 ();
++  double d304 = f1 ();
++  double d305 = f1 ();
++  double d306 = f1 ();
++  double d307 = f1 ();
++  double d308 = f1 ();
++  double d309 = f1 ();
++  double d310 = f1 ();
++  double d311 = f1 ();
++  double d312 = f1 ();
++  double d313 = f1 ();
++  double d314 = f1 ();
++  double d315 = f1 ();
++  double d316 = f1 ();
++  double d317 = f1 ();
++  double d318 = f1 ();
++  double d319 = f1 ();
++  double d320 = f1 ();
++  double d321 = f1 ();
++  double d322 = f1 ();
++  double d323 = f1 ();
++  double d324 = f1 ();
++  double d325 = f1 ();
++  double d326 = f1 ();
++  double d327 = f1 ();
++  double d328 = f1 ();
++  double d329 = f1 ();
++  double d330 = f1 ();
++  double d331 = f1 ();
++  double d332 = f1 ();
++  double d333 = f1 ();
++  double d334 = f1 ();
++  double d335 = f1 ();
++  double d336 = f1 ();
++  double d337 = f1 ();
++  double d338 = f1 ();
++  double d339 = f1 ();
++  double d340 = f1 ();
++  double d341 = f1 ();
++  double d342 = f1 ();
++  double d343 = f1 ();
++  double d344 = f1 ();
++  double d345 = f1 ();
++  double d346 = f1 ();
++  double d347 = f1 ();
++  double d348 = f1 ();
++  double d349 = f1 ();
++  double d350 = f1 ();
++  double d351 = f1 ();
++  double d352 = f1 ();
++  double d353 = f1 ();
++  double d354 = f1 ();
++  double d355 = f1 ();
++  double d356 = f1 ();
++  double d357 = f1 ();
++  double d358 = f1 ();
++  double d359 = f1 ();
++  double d360 = f1 ();
++  double d361 = f1 ();
++  double d362 = f1 ();
++  double d363 = f1 ();
++  double d364 = f1 ();
++  double d365 = f1 ();
++  double d366 = f1 ();
++  double d367 = f1 ();
++  double d368 = f1 ();
++  double d369 = f1 ();
++  double d370 = f1 ();
++  double d371 = f1 ();
++  double d372 = f1 ();
++  double d373 = f1 ();
++  double d374 = f1 ();
++  double d375 = f1 ();
++  double d376 = f1 ();
++  double d377 = f1 ();
++  double d378 = f1 ();
++  double d379 = f1 ();
++  double d380 = f1 ();
++  double d381 = f1 ();
++  double d382 = f1 ();
++  double d383 = f1 ();
++  double d384 = f1 ();
++  double d385 = f1 ();
++  double d386 = f1 ();
++  double d387 = f1 ();
++  double d388 = f1 ();
++  double d389 = f1 ();
++  double d390 = f1 ();
++  double d391 = f1 ();
++  double d392 = f1 ();
++  double d393 = f1 ();
++  double d394 = f1 ();
++  double d395 = f1 ();
++  double d396 = f1 ();
++  double d397 = f1 ();
++  double d398 = f1 ();
++  double d399 = f1 ();
++  double d400 = f1 ();
++  double d401 = f1 ();
++  double d402 = f1 ();
++  double d403 = f1 ();
++  double d404 = f1 ();
++  double d405 = f1 ();
++  double d406 = f1 ();
++  double d407 = f1 ();
++  double d408 = f1 ();
++  double d409 = f1 ();
++  double d410 = f1 ();
++  double d411 = f1 ();
++  double d412 = f1 ();
++  double d413 = f1 ();
++  double d414 = f1 ();
++  double d415 = f1 ();
++  double d416 = f1 ();
++  double d417 = f1 ();
++  double d418 = f1 ();
++  double d419 = f1 ();
++  double d420 = f1 ();
++  double d421 = f1 ();
++  double d422 = f1 ();
++  double d423 = f1 ();
++  double d424 = f1 ();
++  double d425 = f1 ();
++  double d426 = f1 ();
++  double d427 = f1 ();
++  double d428 = f1 ();
++  double d429 = f1 ();
++  double d430 = f1 ();
++  double d431 = f1 ();
++  double d432 = f1 ();
++  double d433 = f1 ();
++  double d434 = f1 ();
++  double d435 = f1 ();
++  double d436 = f1 ();
++  double d437 = f1 ();
++  double d438 = f1 ();
++  double d439 = f1 ();
++  double d440 = f1 ();
++  double d441 = f1 ();
++  double d442 = f1 ();
++  double d443 = f1 ();
++  double d444 = f1 ();
++  double d445 = f1 ();
++  double d446 = f1 ();
++  double d447 = f1 ();
++  double d448 = f1 ();
++  double d449 = f1 ();
++  double d450 = f1 ();
++  double d451 = f1 ();
++  double d452 = f1 ();
++  double d453 = f1 ();
++  double d454 = f1 ();
++  double d455 = f1 ();
++  double d456 = f1 ();
++  double d457 = f1 ();
++  double d458 = f1 ();
++  double d459 = f1 ();
++  double d460 = f1 ();
++  double d461 = f1 ();
++  double d462 = f1 ();
++  double d463 = f1 ();
++  double d464 = f1 ();
++  double d465 = f1 ();
++  double d466 = f1 ();
++  double d467 = f1 ();
++  double d468 = f1 ();
++  double d469 = f1 ();
++  double d470 = f1 ();
++  double d471 = f1 ();
++  double d472 = f1 ();
++  double d473 = f1 ();
++  double d474 = f1 ();
++  double d475 = f1 ();
++  double d476 = f1 ();
++  double d477 = f1 ();
++  double d478 = f1 ();
++  double d479 = f1 ();
++  double d480 = f1 ();
++  double d481 = f1 ();
++  double d482 = f1 ();
++  double d483 = f1 ();
++  double d484 = f1 ();
++  double d485 = f1 ();
++  double d486 = f1 ();
++  double d487 = f1 ();
++  double d488 = f1 ();
++  double d489 = f1 ();
++  double d490 = f1 ();
++  double d491 = f1 ();
++  double d492 = f1 ();
++  double d493 = f1 ();
++  double d494 = f1 ();
++  double d495 = f1 ();
++  double d496 = f1 ();
++  double d497 = f1 ();
++  double d498 = f1 ();
++  double d499 = f1 ();
++  double d500 = f1 ();
++  double d501 = f1 ();
++  double d502 = f1 ();
++  double d503 = f1 ();
++  double d504 = f1 ();
++  double d505 = f1 ();
++  double d506 = f1 ();
++  double d507 = f1 ();
++  double d508 = f1 ();
++  double d509 = f1 ();
++  double d510 = f1 ();
++  double d511 = f1 ();
++  double d512 = f1 ();
++  double d513 = f1 ();
++  double d514 = f1 ();
++  double d515 = f1 ();
++  double d516 = f1 ();
++  double d517 = f1 ();
++  double d518 = f1 ();
++  double d519 = f1 ();
++  double d520 = f1 ();
++  double d521 = f1 ();
++  double d522 = f1 ();
++  double d523 = f1 ();
++  double d524 = f1 ();
++  double d525 = f1 ();
++  double d526 = f1 ();
++  double d527 = f1 ();
++  double d528 = f1 ();
++  double d529 = f1 ();
++  double d530 = f1 ();
++  double d531 = f1 ();
++  double d532 = f1 ();
++  double d533 = f1 ();
++  double d534 = f1 ();
++  double d535 = f1 ();
++  double d536 = f1 ();
++  double d537 = f1 ();
++  double d538 = f1 ();
++  double d539 = f1 ();
++  double d540 = f1 ();
++  double d541 = f1 ();
++  double d542 = f1 ();
++  double d543 = f1 ();
++  double d544 = f1 ();
++  double d545 = f1 ();
++  double d546 = f1 ();
++  double d547 = f1 ();
++  double d548 = f1 ();
++  double d549 = f1 ();
++  double d550 = f1 ();
++  double d551 = f1 ();
++  double d552 = f1 ();
++  double d553 = f1 ();
++  double d554 = f1 ();
++  double d555 = f1 ();
++  double d556 = f1 ();
++  double d557 = f1 ();
++  double d558 = f1 ();
++  double d559 = f1 ();
++  double d560 = f1 ();
++  double d561 = f1 ();
++  double d562 = f1 ();
++  double d563 = f1 ();
++  double d564 = f1 ();
++  double d565 = f1 ();
++  double d566 = f1 ();
++  double d567 = f1 ();
++  double d568 = f1 ();
++  double d569 = f1 ();
++  double d570 = f1 ();
++  double d571 = f1 ();
++  double d572 = f1 ();
++  double d573 = f1 ();
++  double d574 = f1 ();
++  double d575 = f1 ();
++  double d576 = f1 ();
++  double d577 = f1 ();
++  double d578 = f1 ();
++  double d579 = f1 ();
++  double d580 = f1 ();
++  double d581 = f1 ();
++  double d582 = f1 ();
++  double d583 = f1 ();
++  double d584 = f1 ();
++  double d585 = f1 ();
++  double d586 = f1 ();
++  double d587 = f1 ();
++  double d588 = f1 ();
++  double d589 = f1 ();
++  double d590 = f1 ();
++  double d591 = f1 ();
++  double d592 = f1 ();
++  double d593 = f1 ();
++  double d594 = f1 ();
++  double d595 = f1 ();
++  double d596 = f1 ();
++  double d597 = f1 ();
++  double d598 = f1 ();
++  double d599 = f1 ();
++  double d600 = f1 ();
++  double d601 = f1 ();
++  double d602 = f1 ();
++  double d603 = f1 ();
++  double d604 = f1 ();
++  double d605 = f1 ();
++  double d606 = f1 ();
++  double d607 = f1 ();
++  double d608 = f1 ();
++  double d609 = f1 ();
++  double d610 = f1 ();
++  double d611 = f1 ();
++  double d612 = f1 ();
++  double d613 = f1 ();
++  double d614 = f1 ();
++  double d615 = f1 ();
++  double d616 = f1 ();
++  double d617 = f1 ();
++  double d618 = f1 ();
++  double d619 = f1 ();
++  double d620 = f1 ();
++  double d621 = f1 ();
++  double d622 = f1 ();
++  double d623 = f1 ();
++  double d624 = f1 ();
++  double d625 = f1 ();
++  double d626 = f1 ();
++  double d627 = f1 ();
++  double d628 = f1 ();
++  double d629 = f1 ();
++  double d630 = f1 ();
++  double d631 = f1 ();
++  double d632 = f1 ();
++  double d633 = f1 ();
++  double d634 = f1 ();
++  double d635 = f1 ();
++  double d636 = f1 ();
++  double d637 = f1 ();
++  double d638 = f1 ();
++  double d639 = f1 ();
++  double d640 = f1 ();
++  double d641 = f1 ();
++  double d642 = f1 ();
++  double d643 = f1 ();
++  double d644 = f1 ();
++  double d645 = f1 ();
++  double d646 = f1 ();
++  double d647 = f1 ();
++  double d648 = f1 ();
++  double d649 = f1 ();
++  double d650 = f1 ();
++  double d651 = f1 ();
++  double d652 = f1 ();
++  double d653 = f1 ();
++  double d654 = f1 ();
++  double d655 = f1 ();
++  double d656 = f1 ();
++  double d657 = f1 ();
++  double d658 = f1 ();
++  double d659 = f1 ();
++  double d660 = f1 ();
++  double d661 = f1 ();
++  double d662 = f1 ();
++  double d663 = f1 ();
++  double d664 = f1 ();
++  double d665 = f1 ();
++  double d666 = f1 ();
++  double d667 = f1 ();
++  double d668 = f1 ();
++  double d669 = f1 ();
++  double d670 = f1 ();
++  double d671 = f1 ();
++  double d672 = f1 ();
++  double d673 = f1 ();
++  double d674 = f1 ();
++  double d675 = f1 ();
++  double d676 = f1 ();
++  double d677 = f1 ();
++  double d678 = f1 ();
++  double d679 = f1 ();
++  double d680 = f1 ();
++  double d681 = f1 ();
++  double d682 = f1 ();
++  double d683 = f1 ();
++  double d684 = f1 ();
++  double d685 = f1 ();
++  double d686 = f1 ();
++  double d687 = f1 ();
++  double d688 = f1 ();
++  double d689 = f1 ();
++  double d690 = f1 ();
++  double d691 = f1 ();
++  double d692 = f1 ();
++  double d693 = f1 ();
++  double d694 = f1 ();
++  double d695 = f1 ();
++  double d696 = f1 ();
++  double d697 = f1 ();
++  double d698 = f1 ();
++  double d699 = f1 ();
++  double d700 = f1 ();
++  double d701 = f1 ();
++  double d702 = f1 ();
++  double d703 = f1 ();
++  double d704 = f1 ();
++  double d705 = f1 ();
++  double d706 = f1 ();
++  double d707 = f1 ();
++  double d708 = f1 ();
++  double d709 = f1 ();
++  double d710 = f1 ();
++  double d711 = f1 ();
++  double d712 = f1 ();
++  double d713 = f1 ();
++  double d714 = f1 ();
++  double d715 = f1 ();
++  double d716 = f1 ();
++  double d717 = f1 ();
++  double d718 = f1 ();
++  double d719 = f1 ();
++  double d720 = f1 ();
++  double d721 = f1 ();
++  double d722 = f1 ();
++  double d723 = f1 ();
++  double d724 = f1 ();
++  double d725 = f1 ();
++  double d726 = f1 ();
++  double d727 = f1 ();
++  double d728 = f1 ();
++  double d729 = f1 ();
++  double d730 = f1 ();
++  double d731 = f1 ();
++  double d732 = f1 ();
++  double d733 = f1 ();
++  double d734 = f1 ();
++  double d735 = f1 ();
++  double d736 = f1 ();
++  double d737 = f1 ();
++  double d738 = f1 ();
++  double d739 = f1 ();
++  double d740 = f1 ();
++  double d741 = f1 ();
++  double d742 = f1 ();
++  double d743 = f1 ();
++  double d744 = f1 ();
++  double d745 = f1 ();
++  double d746 = f1 ();
++  double d747 = f1 ();
++  double d748 = f1 ();
++  double d749 = f1 ();
++  double d750 = f1 ();
++  double d751 = f1 ();
++  double d752 = f1 ();
++  double d753 = f1 ();
++  double d754 = f1 ();
++  double d755 = f1 ();
++  double d756 = f1 ();
++  double d757 = f1 ();
++  double d758 = f1 ();
++  double d759 = f1 ();
++  double d760 = f1 ();
++  double d761 = f1 ();
++  double d762 = f1 ();
++  double d763 = f1 ();
++  double d764 = f1 ();
++  double d765 = f1 ();
++  double d766 = f1 ();
++  double d767 = f1 ();
++  double d768 = f1 ();
++  double d769 = f1 ();
++  double d770 = f1 ();
++  double d771 = f1 ();
++  double d772 = f1 ();
++  double d773 = f1 ();
++  double d774 = f1 ();
++  double d775 = f1 ();
++  double d776 = f1 ();
++  double d777 = f1 ();
++  double d778 = f1 ();
++  double d779 = f1 ();
++  double d780 = f1 ();
++  double d781 = f1 ();
++  double d782 = f1 ();
++  double d783 = f1 ();
++  double d784 = f1 ();
++  double d785 = f1 ();
++  double d786 = f1 ();
++  double d787 = f1 ();
++  double d788 = f1 ();
++  double d789 = f1 ();
++  double d790 = f1 ();
++  double d791 = f1 ();
++  double d792 = f1 ();
++  double d793 = f1 ();
++  double d794 = f1 ();
++  double d795 = f1 ();
++  double d796 = f1 ();
++  double d797 = f1 ();
++  double d798 = f1 ();
++  double d799 = f1 ();
++  double d800 = f1 ();
++  double d801 = f1 ();
++  double d802 = f1 ();
++  double d803 = f1 ();
++  double d804 = f1 ();
++  double d805 = f1 ();
++  double d806 = f1 ();
++  double d807 = f1 ();
++  double d808 = f1 ();
++  double d809 = f1 ();
++  double d810 = f1 ();
++  double d811 = f1 ();
++  double d812 = f1 ();
++  double d813 = f1 ();
++  double d814 = f1 ();
++  double d815 = f1 ();
++  double d816 = f1 ();
++  double d817 = f1 ();
++  double d818 = f1 ();
++  double d819 = f1 ();
++  double d820 = f1 ();
++  double d821 = f1 ();
++  double d822 = f1 ();
++  double d823 = f1 ();
++  double d824 = f1 ();
++  double d825 = f1 ();
++  double d826 = f1 ();
++  double d827 = f1 ();
++  double d828 = f1 ();
++  double d829 = f1 ();
++  double d830 = f1 ();
++  double d831 = f1 ();
++  double d832 = f1 ();
++  double d833 = f1 ();
++  double d834 = f1 ();
++  double d835 = f1 ();
++  double d836 = f1 ();
++  double d837 = f1 ();
++  double d838 = f1 ();
++  double d839 = f1 ();
++  double d840 = f1 ();
++  double d841 = f1 ();
++  double d842 = f1 ();
++  double d843 = f1 ();
++  double d844 = f1 ();
++  double d845 = f1 ();
++  double d846 = f1 ();
++  double d847 = f1 ();
++  double d848 = f1 ();
++  double d849 = f1 ();
++  double d850 = f1 ();
++  double d851 = f1 ();
++  double d852 = f1 ();
++  double d853 = f1 ();
++  double d854 = f1 ();
++  double d855 = f1 ();
++  double d856 = f1 ();
++  double d857 = f1 ();
++  double d858 = f1 ();
++  double d859 = f1 ();
++  double d860 = f1 ();
++  double d861 = f1 ();
++  double d862 = f1 ();
++  double d863 = f1 ();
++  double d864 = f1 ();
++  double d865 = f1 ();
++  double d866 = f1 ();
++  double d867 = f1 ();
++  double d868 = f1 ();
++  double d869 = f1 ();
++  double d870 = f1 ();
++  double d871 = f1 ();
++  double d872 = f1 ();
++  double d873 = f1 ();
++  double d874 = f1 ();
++  double d875 = f1 ();
++  double d876 = f1 ();
++  double d877 = f1 ();
++  double d878 = f1 ();
++  double d879 = f1 ();
++  double d880 = f1 ();
++  double d881 = f1 ();
++  double d882 = f1 ();
++  double d883 = f1 ();
++  double d884 = f1 ();
++  double d885 = f1 ();
++  double d886 = f1 ();
++  double d887 = f1 ();
++  double d888 = f1 ();
++  double d889 = f1 ();
++  double d890 = f1 ();
++  double d891 = f1 ();
++  double d892 = f1 ();
++  double d893 = f1 ();
++  double d894 = f1 ();
++  double d895 = f1 ();
++  double d896 = f1 ();
++  double d897 = f1 ();
++  double d898 = f1 ();
++  double d899 = f1 ();
++  double d900 = f1 ();
++  double d901 = f1 ();
++  double d902 = f1 ();
++  double d903 = f1 ();
++  double d904 = f1 ();
++  double d905 = f1 ();
++  double d906 = f1 ();
++  double d907 = f1 ();
++  double d908 = f1 ();
++  double d909 = f1 ();
++  double d910 = f1 ();
++  double d911 = f1 ();
++  double d912 = f1 ();
++  double d913 = f1 ();
++  double d914 = f1 ();
++  double d915 = f1 ();
++  double d916 = f1 ();
++  double d917 = f1 ();
++  double d918 = f1 ();
++  double d919 = f1 ();
++  double d920 = f1 ();
++  double d921 = f1 ();
++  double d922 = f1 ();
++  double d923 = f1 ();
++  double d924 = f1 ();
++  double d925 = f1 ();
++  double d926 = f1 ();
++  double d927 = f1 ();
++  double d928 = f1 ();
++  double d929 = f1 ();
++  double d930 = f1 ();
++  double d931 = f1 ();
++  double d932 = f1 ();
++  double d933 = f1 ();
++  double d934 = f1 ();
++  double d935 = f1 ();
++  double d936 = f1 ();
++  double d937 = f1 ();
++  double d938 = f1 ();
++  double d939 = f1 ();
++  double d940 = f1 ();
++  double d941 = f1 ();
++  double d942 = f1 ();
++  double d943 = f1 ();
++  double d944 = f1 ();
++  double d945 = f1 ();
++  double d946 = f1 ();
++  double d947 = f1 ();
++  double d948 = f1 ();
++  double d949 = f1 ();
++  double d950 = f1 ();
++  double d951 = f1 ();
++  double d952 = f1 ();
++  double d953 = f1 ();
++  double d954 = f1 ();
++  double d955 = f1 ();
++  double d956 = f1 ();
++  double d957 = f1 ();
++  double d958 = f1 ();
++  double d959 = f1 ();
++  double d960 = f1 ();
++  double d961 = f1 ();
++  double d962 = f1 ();
++  double d963 = f1 ();
++  double d964 = f1 ();
++  double d965 = f1 ();
++  double d966 = f1 ();
++  double d967 = f1 ();
++  double d968 = f1 ();
++  double d969 = f1 ();
++  double d970 = f1 ();
++  double d971 = f1 ();
++  double d972 = f1 ();
++  double d973 = f1 ();
++  double d974 = f1 ();
++  double d975 = f1 ();
++  double d976 = f1 ();
++  double d977 = f1 ();
++  double d978 = f1 ();
++  double d979 = f1 ();
++  double d980 = f1 ();
++  double d981 = f1 ();
++  double d982 = f1 ();
++  double d983 = f1 ();
++  double d984 = f1 ();
++  double d985 = f1 ();
++  double d986 = f1 ();
++  double d987 = f1 ();
++  double d988 = f1 ();
++  double d989 = f1 ();
++  double d990 = f1 ();
++  double d991 = f1 ();
++  double d992 = f1 ();
++  double d993 = f1 ();
++  double d994 = f1 ();
++  double d995 = f1 ();
++  double d996 = f1 ();
++  double d997 = f1 ();
++  double d998 = f1 ();
++  double d999 = f1 ();
++
++  double x = 0;
++  x = f2 (x, d000);
++  x = f2 (x, d001);
++  x = f2 (x, d002);
++  x = f2 (x, d003);
++  x = f2 (x, d004);
++  x = f2 (x, d005);
++  x = f2 (x, d006);
++  x = f2 (x, d007);
++  x = f2 (x, d008);
++  x = f2 (x, d009);
++  x = f2 (x, d010);
++  x = f2 (x, d011);
++  x = f2 (x, d012);
++  x = f2 (x, d013);
++  x = f2 (x, d014);
++  x = f2 (x, d015);
++  x = f2 (x, d016);
++  x = f2 (x, d017);
++  x = f2 (x, d018);
++  x = f2 (x, d019);
++  x = f2 (x, d020);
++  x = f2 (x, d021);
++  x = f2 (x, d022);
++  x = f2 (x, d023);
++  x = f2 (x, d024);
++  x = f2 (x, d025);
++  x = f2 (x, d026);
++  x = f2 (x, d027);
++  x = f2 (x, d028);
++  x = f2 (x, d029);
++  x = f2 (x, d030);
++  x = f2 (x, d031);
++  x = f2 (x, d032);
++  x = f2 (x, d033);
++  x = f2 (x, d034);
++  x = f2 (x, d035);
++  x = f2 (x, d036);
++  x = f2 (x, d037);
++  x = f2 (x, d038);
++  x = f2 (x, d039);
++  x = f2 (x, d040);
++  x = f2 (x, d041);
++  x = f2 (x, d042);
++  x = f2 (x, d043);
++  x = f2 (x, d044);
++  x = f2 (x, d045);
++  x = f2 (x, d046);
++  x = f2 (x, d047);
++  x = f2 (x, d048);
++  x = f2 (x, d049);
++  x = f2 (x, d050);
++  x = f2 (x, d051);
++  x = f2 (x, d052);
++  x = f2 (x, d053);
++  x = f2 (x, d054);
++  x = f2 (x, d055);
++  x = f2 (x, d056);
++  x = f2 (x, d057);
++  x = f2 (x, d058);
++  x = f2 (x, d059);
++  x = f2 (x, d060);
++  x = f2 (x, d061);
++  x = f2 (x, d062);
++  x = f2 (x, d063);
++  x = f2 (x, d064);
++  x = f2 (x, d065);
++  x = f2 (x, d066);
++  x = f2 (x, d067);
++  x = f2 (x, d068);
++  x = f2 (x, d069);
++  x = f2 (x, d070);
++  x = f2 (x, d071);
++  x = f2 (x, d072);
++  x = f2 (x, d073);
++  x = f2 (x, d074);
++  x = f2 (x, d075);
++  x = f2 (x, d076);
++  x = f2 (x, d077);
++  x = f2 (x, d078);
++  x = f2 (x, d079);
++  x = f2 (x, d080);
++  x = f2 (x, d081);
++  x = f2 (x, d082);
++  x = f2 (x, d083);
++  x = f2 (x, d084);
++  x = f2 (x, d085);
++  x = f2 (x, d086);
++  x = f2 (x, d087);
++  x = f2 (x, d088);
++  x = f2 (x, d089);
++  x = f2 (x, d090);
++  x = f2 (x, d091);
++  x = f2 (x, d092);
++  x = f2 (x, d093);
++  x = f2 (x, d094);
++  x = f2 (x, d095);
++  x = f2 (x, d096);
++  x = f2 (x, d097);
++  x = f2 (x, d098);
++  x = f2 (x, d099);
++  x = f2 (x, d100);
++  x = f2 (x, d101);
++  x = f2 (x, d102);
++  x = f2 (x, d103);
++  x = f2 (x, d104);
++  x = f2 (x, d105);
++  x = f2 (x, d106);
++  x = f2 (x, d107);
++  x = f2 (x, d108);
++  x = f2 (x, d109);
++  x = f2 (x, d110);
++  x = f2 (x, d111);
++  x = f2 (x, d112);
++  x = f2 (x, d113);
++  x = f2 (x, d114);
++  x = f2 (x, d115);
++  x = f2 (x, d116);
++  x = f2 (x, d117);
++  x = f2 (x, d118);
++  x = f2 (x, d119);
++  x = f2 (x, d120);
++  x = f2 (x, d121);
++  x = f2 (x, d122);
++  x = f2 (x, d123);
++  x = f2 (x, d124);
++  x = f2 (x, d125);
++  x = f2 (x, d126);
++  x = f2 (x, d127);
++  x = f2 (x, d128);
++  x = f2 (x, d129);
++  x = f2 (x, d130);
++  x = f2 (x, d131);
++  x = f2 (x, d132);
++  x = f2 (x, d133);
++  x = f2 (x, d134);
++  x = f2 (x, d135);
++  x = f2 (x, d136);
++  x = f2 (x, d137);
++  x = f2 (x, d138);
++  x = f2 (x, d139);
++  x = f2 (x, d140);
++  x = f2 (x, d141);
++  x = f2 (x, d142);
++  x = f2 (x, d143);
++  x = f2 (x, d144);
++  x = f2 (x, d145);
++  x = f2 (x, d146);
++  x = f2 (x, d147);
++  x = f2 (x, d148);
++  x = f2 (x, d149);
++  x = f2 (x, d150);
++  x = f2 (x, d151);
++  x = f2 (x, d152);
++  x = f2 (x, d153);
++  x = f2 (x, d154);
++  x = f2 (x, d155);
++  x = f2 (x, d156);
++  x = f2 (x, d157);
++  x = f2 (x, d158);
++  x = f2 (x, d159);
++  x = f2 (x, d160);
++  x = f2 (x, d161);
++  x = f2 (x, d162);
++  x = f2 (x, d163);
++  x = f2 (x, d164);
++  x = f2 (x, d165);
++  x = f2 (x, d166);
++  x = f2 (x, d167);
++  x = f2 (x, d168);
++  x = f2 (x, d169);
++  x = f2 (x, d170);
++  x = f2 (x, d171);
++  x = f2 (x, d172);
++  x = f2 (x, d173);
++  x = f2 (x, d174);
++  x = f2 (x, d175);
++  x = f2 (x, d176);
++  x = f2 (x, d177);
++  x = f2 (x, d178);
++  x = f2 (x, d179);
++  x = f2 (x, d180);
++  x = f2 (x, d181);
++  x = f2 (x, d182);
++  x = f2 (x, d183);
++  x = f2 (x, d184);
++  x = f2 (x, d185);
++  x = f2 (x, d186);
++  x = f2 (x, d187);
++  x = f2 (x, d188);
++  x = f2 (x, d189);
++  x = f2 (x, d190);
++  x = f2 (x, d191);
++  x = f2 (x, d192);
++  x = f2 (x, d193);
++  x = f2 (x, d194);
++  x = f2 (x, d195);
++  x = f2 (x, d196);
++  x = f2 (x, d197);
++  x = f2 (x, d198);
++  x = f2 (x, d199);
++  x = f2 (x, d200);
++  x = f2 (x, d201);
++  x = f2 (x, d202);
++  x = f2 (x, d203);
++  x = f2 (x, d204);
++  x = f2 (x, d205);
++  x = f2 (x, d206);
++  x = f2 (x, d207);
++  x = f2 (x, d208);
++  x = f2 (x, d209);
++  x = f2 (x, d210);
++  x = f2 (x, d211);
++  x = f2 (x, d212);
++  x = f2 (x, d213);
++  x = f2 (x, d214);
++  x = f2 (x, d215);
++  x = f2 (x, d216);
++  x = f2 (x, d217);
++  x = f2 (x, d218);
++  x = f2 (x, d219);
++  x = f2 (x, d220);
++  x = f2 (x, d221);
++  x = f2 (x, d222);
++  x = f2 (x, d223);
++  x = f2 (x, d224);
++  x = f2 (x, d225);
++  x = f2 (x, d226);
++  x = f2 (x, d227);
++  x = f2 (x, d228);
++  x = f2 (x, d229);
++  x = f2 (x, d230);
++  x = f2 (x, d231);
++  x = f2 (x, d232);
++  x = f2 (x, d233);
++  x = f2 (x, d234);
++  x = f2 (x, d235);
++  x = f2 (x, d236);
++  x = f2 (x, d237);
++  x = f2 (x, d238);
++  x = f2 (x, d239);
++  x = f2 (x, d240);
++  x = f2 (x, d241);
++  x = f2 (x, d242);
++  x = f2 (x, d243);
++  x = f2 (x, d244);
++  x = f2 (x, d245);
++  x = f2 (x, d246);
++  x = f2 (x, d247);
++  x = f2 (x, d248);
++  x = f2 (x, d249);
++  x = f2 (x, d250);
++  x = f2 (x, d251);
++  x = f2 (x, d252);
++  x = f2 (x, d253);
++  x = f2 (x, d254);
++  x = f2 (x, d255);
++  x = f2 (x, d256);
++  x = f2 (x, d257);
++  x = f2 (x, d258);
++  x = f2 (x, d259);
++  x = f2 (x, d260);
++  x = f2 (x, d261);
++  x = f2 (x, d262);
++  x = f2 (x, d263);
++  x = f2 (x, d264);
++  x = f2 (x, d265);
++  x = f2 (x, d266);
++  x = f2 (x, d267);
++  x = f2 (x, d268);
++  x = f2 (x, d269);
++  x = f2 (x, d270);
++  x = f2 (x, d271);
++  x = f2 (x, d272);
++  x = f2 (x, d273);
++  x = f2 (x, d274);
++  x = f2 (x, d275);
++  x = f2 (x, d276);
++  x = f2 (x, d277);
++  x = f2 (x, d278);
++  x = f2 (x, d279);
++  x = f2 (x, d280);
++  x = f2 (x, d281);
++  x = f2 (x, d282);
++  x = f2 (x, d283);
++  x = f2 (x, d284);
++  x = f2 (x, d285);
++  x = f2 (x, d286);
++  x = f2 (x, d287);
++  x = f2 (x, d288);
++  x = f2 (x, d289);
++  x = f2 (x, d290);
++  x = f2 (x, d291);
++  x = f2 (x, d292);
++  x = f2 (x, d293);
++  x = f2 (x, d294);
++  x = f2 (x, d295);
++  x = f2 (x, d296);
++  x = f2 (x, d297);
++  x = f2 (x, d298);
++  x = f2 (x, d299);
++  x = f2 (x, d300);
++  x = f2 (x, d301);
++  x = f2 (x, d302);
++  x = f2 (x, d303);
++  x = f2 (x, d304);
++  x = f2 (x, d305);
++  x = f2 (x, d306);
++  x = f2 (x, d307);
++  x = f2 (x, d308);
++  x = f2 (x, d309);
++  x = f2 (x, d310);
++  x = f2 (x, d311);
++  x = f2 (x, d312);
++  x = f2 (x, d313);
++  x = f2 (x, d314);
++  x = f2 (x, d315);
++  x = f2 (x, d316);
++  x = f2 (x, d317);
++  x = f2 (x, d318);
++  x = f2 (x, d319);
++  x = f2 (x, d320);
++  x = f2 (x, d321);
++  x = f2 (x, d322);
++  x = f2 (x, d323);
++  x = f2 (x, d324);
++  x = f2 (x, d325);
++  x = f2 (x, d326);
++  x = f2 (x, d327);
++  x = f2 (x, d328);
++  x = f2 (x, d329);
++  x = f2 (x, d330);
++  x = f2 (x, d331);
++  x = f2 (x, d332);
++  x = f2 (x, d333);
++  x = f2 (x, d334);
++  x = f2 (x, d335);
++  x = f2 (x, d336);
++  x = f2 (x, d337);
++  x = f2 (x, d338);
++  x = f2 (x, d339);
++  x = f2 (x, d340);
++  x = f2 (x, d341);
++  x = f2 (x, d342);
++  x = f2 (x, d343);
++  x = f2 (x, d344);
++  x = f2 (x, d345);
++  x = f2 (x, d346);
++  x = f2 (x, d347);
++  x = f2 (x, d348);
++  x = f2 (x, d349);
++  x = f2 (x, d350);
++  x = f2 (x, d351);
++  x = f2 (x, d352);
++  x = f2 (x, d353);
++  x = f2 (x, d354);
++  x = f2 (x, d355);
++  x = f2 (x, d356);
++  x = f2 (x, d357);
++  x = f2 (x, d358);
++  x = f2 (x, d359);
++  x = f2 (x, d360);
++  x = f2 (x, d361);
++  x = f2 (x, d362);
++  x = f2 (x, d363);
++  x = f2 (x, d364);
++  x = f2 (x, d365);
++  x = f2 (x, d366);
++  x = f2 (x, d367);
++  x = f2 (x, d368);
++  x = f2 (x, d369);
++  x = f2 (x, d370);
++  x = f2 (x, d371);
++  x = f2 (x, d372);
++  x = f2 (x, d373);
++  x = f2 (x, d374);
++  x = f2 (x, d375);
++  x = f2 (x, d376);
++  x = f2 (x, d377);
++  x = f2 (x, d378);
++  x = f2 (x, d379);
++  x = f2 (x, d380);
++  x = f2 (x, d381);
++  x = f2 (x, d382);
++  x = f2 (x, d383);
++  x = f2 (x, d384);
++  x = f2 (x, d385);
++  x = f2 (x, d386);
++  x = f2 (x, d387);
++  x = f2 (x, d388);
++  x = f2 (x, d389);
++  x = f2 (x, d390);
++  x = f2 (x, d391);
++  x = f2 (x, d392);
++  x = f2 (x, d393);
++  x = f2 (x, d394);
++  x = f2 (x, d395);
++  x = f2 (x, d396);
++  x = f2 (x, d397);
++  x = f2 (x, d398);
++  x = f2 (x, d399);
++  x = f2 (x, d400);
++  x = f2 (x, d401);
++  x = f2 (x, d402);
++  x = f2 (x, d403);
++  x = f2 (x, d404);
++  x = f2 (x, d405);
++  x = f2 (x, d406);
++  x = f2 (x, d407);
++  x = f2 (x, d408);
++  x = f2 (x, d409);
++  x = f2 (x, d410);
++  x = f2 (x, d411);
++  x = f2 (x, d412);
++  x = f2 (x, d413);
++  x = f2 (x, d414);
++  x = f2 (x, d415);
++  x = f2 (x, d416);
++  x = f2 (x, d417);
++  x = f2 (x, d418);
++  x = f2 (x, d419);
++  x = f2 (x, d420);
++  x = f2 (x, d421);
++  x = f2 (x, d422);
++  x = f2 (x, d423);
++  x = f2 (x, d424);
++  x = f2 (x, d425);
++  x = f2 (x, d426);
++  x = f2 (x, d427);
++  x = f2 (x, d428);
++  x = f2 (x, d429);
++  x = f2 (x, d430);
++  x = f2 (x, d431);
++  x = f2 (x, d432);
++  x = f2 (x, d433);
++  x = f2 (x, d434);
++  x = f2 (x, d435);
++  x = f2 (x, d436);
++  x = f2 (x, d437);
++  x = f2 (x, d438);
++  x = f2 (x, d439);
++  x = f2 (x, d440);
++  x = f2 (x, d441);
++  x = f2 (x, d442);
++  x = f2 (x, d443);
++  x = f2 (x, d444);
++  x = f2 (x, d445);
++  x = f2 (x, d446);
++  x = f2 (x, d447);
++  x = f2 (x, d448);
++  x = f2 (x, d449);
++  x = f2 (x, d450);
++  x = f2 (x, d451);
++  x = f2 (x, d452);
++  x = f2 (x, d453);
++  x = f2 (x, d454);
++  x = f2 (x, d455);
++  x = f2 (x, d456);
++  x = f2 (x, d457);
++  x = f2 (x, d458);
++  x = f2 (x, d459);
++  x = f2 (x, d460);
++  x = f2 (x, d461);
++  x = f2 (x, d462);
++  x = f2 (x, d463);
++  x = f2 (x, d464);
++  x = f2 (x, d465);
++  x = f2 (x, d466);
++  x = f2 (x, d467);
++  x = f2 (x, d468);
++  x = f2 (x, d469);
++  x = f2 (x, d470);
++  x = f2 (x, d471);
++  x = f2 (x, d472);
++  x = f2 (x, d473);
++  x = f2 (x, d474);
++  x = f2 (x, d475);
++  x = f2 (x, d476);
++  x = f2 (x, d477);
++  x = f2 (x, d478);
++  x = f2 (x, d479);
++  x = f2 (x, d480);
++  x = f2 (x, d481);
++  x = f2 (x, d482);
++  x = f2 (x, d483);
++  x = f2 (x, d484);
++  x = f2 (x, d485);
++  x = f2 (x, d486);
++  x = f2 (x, d487);
++  x = f2 (x, d488);
++  x = f2 (x, d489);
++  x = f2 (x, d490);
++  x = f2 (x, d491);
++  x = f2 (x, d492);
++  x = f2 (x, d493);
++  x = f2 (x, d494);
++  x = f2 (x, d495);
++  x = f2 (x, d496);
++  x = f2 (x, d497);
++  x = f2 (x, d498);
++  x = f2 (x, d499);
++  x = f2 (x, d500);
++  x = f2 (x, d501);
++  x = f2 (x, d502);
++  x = f2 (x, d503);
++  x = f2 (x, d504);
++  x = f2 (x, d505);
++  x = f2 (x, d506);
++  x = f2 (x, d507);
++  x = f2 (x, d508);
++  x = f2 (x, d509);
++  x = f2 (x, d510);
++  x = f2 (x, d511);
++  x = f2 (x, d512);
++  x = f2 (x, d513);
++  x = f2 (x, d514);
++  x = f2 (x, d515);
++  x = f2 (x, d516);
++  x = f2 (x, d517);
++  x = f2 (x, d518);
++  x = f2 (x, d519);
++  x = f2 (x, d520);
++  x = f2 (x, d521);
++  x = f2 (x, d522);
++  x = f2 (x, d523);
++  x = f2 (x, d524);
++  x = f2 (x, d525);
++  x = f2 (x, d526);
++  x = f2 (x, d527);
++  x = f2 (x, d528);
++  x = f2 (x, d529);
++  x = f2 (x, d530);
++  x = f2 (x, d531);
++  x = f2 (x, d532);
++  x = f2 (x, d533);
++  x = f2 (x, d534);
++  x = f2 (x, d535);
++  x = f2 (x, d536);
++  x = f2 (x, d537);
++  x = f2 (x, d538);
++  x = f2 (x, d539);
++  x = f2 (x, d540);
++  x = f2 (x, d541);
++  x = f2 (x, d542);
++  x = f2 (x, d543);
++  x = f2 (x, d544);
++  x = f2 (x, d545);
++  x = f2 (x, d546);
++  x = f2 (x, d547);
++  x = f2 (x, d548);
++  x = f2 (x, d549);
++  x = f2 (x, d550);
++  x = f2 (x, d551);
++  x = f2 (x, d552);
++  x = f2 (x, d553);
++  x = f2 (x, d554);
++  x = f2 (x, d555);
++  x = f2 (x, d556);
++  x = f2 (x, d557);
++  x = f2 (x, d558);
++  x = f2 (x, d559);
++  x = f2 (x, d560);
++  x = f2 (x, d561);
++  x = f2 (x, d562);
++  x = f2 (x, d563);
++  x = f2 (x, d564);
++  x = f2 (x, d565);
++  x = f2 (x, d566);
++  x = f2 (x, d567);
++  x = f2 (x, d568);
++  x = f2 (x, d569);
++  x = f2 (x, d570);
++  x = f2 (x, d571);
++  x = f2 (x, d572);
++  x = f2 (x, d573);
++  x = f2 (x, d574);
++  x = f2 (x, d575);
++  x = f2 (x, d576);
++  x = f2 (x, d577);
++  x = f2 (x, d578);
++  x = f2 (x, d579);
++  x = f2 (x, d580);
++  x = f2 (x, d581);
++  x = f2 (x, d582);
++  x = f2 (x, d583);
++  x = f2 (x, d584);
++  x = f2 (x, d585);
++  x = f2 (x, d586);
++  x = f2 (x, d587);
++  x = f2 (x, d588);
++  x = f2 (x, d589);
++  x = f2 (x, d590);
++  x = f2 (x, d591);
++  x = f2 (x, d592);
++  x = f2 (x, d593);
++  x = f2 (x, d594);
++  x = f2 (x, d595);
++  x = f2 (x, d596);
++  x = f2 (x, d597);
++  x = f2 (x, d598);
++  x = f2 (x, d599);
++  x = f2 (x, d600);
++  x = f2 (x, d601);
++  x = f2 (x, d602);
++  x = f2 (x, d603);
++  x = f2 (x, d604);
++  x = f2 (x, d605);
++  x = f2 (x, d606);
++  x = f2 (x, d607);
++  x = f2 (x, d608);
++  x = f2 (x, d609);
++  x = f2 (x, d610);
++  x = f2 (x, d611);
++  x = f2 (x, d612);
++  x = f2 (x, d613);
++  x = f2 (x, d614);
++  x = f2 (x, d615);
++  x = f2 (x, d616);
++  x = f2 (x, d617);
++  x = f2 (x, d618);
++  x = f2 (x, d619);
++  x = f2 (x, d620);
++  x = f2 (x, d621);
++  x = f2 (x, d622);
++  x = f2 (x, d623);
++  x = f2 (x, d624);
++  x = f2 (x, d625);
++  x = f2 (x, d626);
++  x = f2 (x, d627);
++  x = f2 (x, d628);
++  x = f2 (x, d629);
++  x = f2 (x, d630);
++  x = f2 (x, d631);
++  x = f2 (x, d632);
++  x = f2 (x, d633);
++  x = f2 (x, d634);
++  x = f2 (x, d635);
++  x = f2 (x, d636);
++  x = f2 (x, d637);
++  x = f2 (x, d638);
++  x = f2 (x, d639);
++  x = f2 (x, d640);
++  x = f2 (x, d641);
++  x = f2 (x, d642);
++  x = f2 (x, d643);
++  x = f2 (x, d644);
++  x = f2 (x, d645);
++  x = f2 (x, d646);
++  x = f2 (x, d647);
++  x = f2 (x, d648);
++  x = f2 (x, d649);
++  x = f2 (x, d650);
++  x = f2 (x, d651);
++  x = f2 (x, d652);
++  x = f2 (x, d653);
++  x = f2 (x, d654);
++  x = f2 (x, d655);
++  x = f2 (x, d656);
++  x = f2 (x, d657);
++  x = f2 (x, d658);
++  x = f2 (x, d659);
++  x = f2 (x, d660);
++  x = f2 (x, d661);
++  x = f2 (x, d662);
++  x = f2 (x, d663);
++  x = f2 (x, d664);
++  x = f2 (x, d665);
++  x = f2 (x, d666);
++  x = f2 (x, d667);
++  x = f2 (x, d668);
++  x = f2 (x, d669);
++  x = f2 (x, d670);
++  x = f2 (x, d671);
++  x = f2 (x, d672);
++  x = f2 (x, d673);
++  x = f2 (x, d674);
++  x = f2 (x, d675);
++  x = f2 (x, d676);
++  x = f2 (x, d677);
++  x = f2 (x, d678);
++  x = f2 (x, d679);
++  x = f2 (x, d680);
++  x = f2 (x, d681);
++  x = f2 (x, d682);
++  x = f2 (x, d683);
++  x = f2 (x, d684);
++  x = f2 (x, d685);
++  x = f2 (x, d686);
++  x = f2 (x, d687);
++  x = f2 (x, d688);
++  x = f2 (x, d689);
++  x = f2 (x, d690);
++  x = f2 (x, d691);
++  x = f2 (x, d692);
++  x = f2 (x, d693);
++  x = f2 (x, d694);
++  x = f2 (x, d695);
++  x = f2 (x, d696);
++  x = f2 (x, d697);
++  x = f2 (x, d698);
++  x = f2 (x, d699);
++  x = f2 (x, d700);
++  x = f2 (x, d701);
++  x = f2 (x, d702);
++  x = f2 (x, d703);
++  x = f2 (x, d704);
++  x = f2 (x, d705);
++  x = f2 (x, d706);
++  x = f2 (x, d707);
++  x = f2 (x, d708);
++  x = f2 (x, d709);
++  x = f2 (x, d710);
++  x = f2 (x, d711);
++  x = f2 (x, d712);
++  x = f2 (x, d713);
++  x = f2 (x, d714);
++  x = f2 (x, d715);
++  x = f2 (x, d716);
++  x = f2 (x, d717);
++  x = f2 (x, d718);
++  x = f2 (x, d719);
++  x = f2 (x, d720);
++  x = f2 (x, d721);
++  x = f2 (x, d722);
++  x = f2 (x, d723);
++  x = f2 (x, d724);
++  x = f2 (x, d725);
++  x = f2 (x, d726);
++  x = f2 (x, d727);
++  x = f2 (x, d728);
++  x = f2 (x, d729);
++  x = f2 (x, d730);
++  x = f2 (x, d731);
++  x = f2 (x, d732);
++  x = f2 (x, d733);
++  x = f2 (x, d734);
++  x = f2 (x, d735);
++  x = f2 (x, d736);
++  x = f2 (x, d737);
++  x = f2 (x, d738);
++  x = f2 (x, d739);
++  x = f2 (x, d740);
++  x = f2 (x, d741);
++  x = f2 (x, d742);
++  x = f2 (x, d743);
++  x = f2 (x, d744);
++  x = f2 (x, d745);
++  x = f2 (x, d746);
++  x = f2 (x, d747);
++  x = f2 (x, d748);
++  x = f2 (x, d749);
++  x = f2 (x, d750);
++  x = f2 (x, d751);
++  x = f2 (x, d752);
++  x = f2 (x, d753);
++  x = f2 (x, d754);
++  x = f2 (x, d755);
++  x = f2 (x, d756);
++  x = f2 (x, d757);
++  x = f2 (x, d758);
++  x = f2 (x, d759);
++  x = f2 (x, d760);
++  x = f2 (x, d761);
++  x = f2 (x, d762);
++  x = f2 (x, d763);
++  x = f2 (x, d764);
++  x = f2 (x, d765);
++  x = f2 (x, d766);
++  x = f2 (x, d767);
++  x = f2 (x, d768);
++  x = f2 (x, d769);
++  x = f2 (x, d770);
++  x = f2 (x, d771);
++  x = f2 (x, d772);
++  x = f2 (x, d773);
++  x = f2 (x, d774);
++  x = f2 (x, d775);
++  x = f2 (x, d776);
++  x = f2 (x, d777);
++  x = f2 (x, d778);
++  x = f2 (x, d779);
++  x = f2 (x, d780);
++  x = f2 (x, d781);
++  x = f2 (x, d782);
++  x = f2 (x, d783);
++  x = f2 (x, d784);
++  x = f2 (x, d785);
++  x = f2 (x, d786);
++  x = f2 (x, d787);
++  x = f2 (x, d788);
++  x = f2 (x, d789);
++  x = f2 (x, d790);
++  x = f2 (x, d791);
++  x = f2 (x, d792);
++  x = f2 (x, d793);
++  x = f2 (x, d794);
++  x = f2 (x, d795);
++  x = f2 (x, d796);
++  x = f2 (x, d797);
++  x = f2 (x, d798);
++  x = f2 (x, d799);
++  x = f2 (x, d800);
++  x = f2 (x, d801);
++  x = f2 (x, d802);
++  x = f2 (x, d803);
++  x = f2 (x, d804);
++  x = f2 (x, d805);
++  x = f2 (x, d806);
++  x = f2 (x, d807);
++  x = f2 (x, d808);
++  x = f2 (x, d809);
++  x = f2 (x, d810);
++  x = f2 (x, d811);
++  x = f2 (x, d812);
++  x = f2 (x, d813);
++  x = f2 (x, d814);
++  x = f2 (x, d815);
++  x = f2 (x, d816);
++  x = f2 (x, d817);
++  x = f2 (x, d818);
++  x = f2 (x, d819);
++  x = f2 (x, d820);
++  x = f2 (x, d821);
++  x = f2 (x, d822);
++  x = f2 (x, d823);
++  x = f2 (x, d824);
++  x = f2 (x, d825);
++  x = f2 (x, d826);
++  x = f2 (x, d827);
++  x = f2 (x, d828);
++  x = f2 (x, d829);
++  x = f2 (x, d830);
++  x = f2 (x, d831);
++  x = f2 (x, d832);
++  x = f2 (x, d833);
++  x = f2 (x, d834);
++  x = f2 (x, d835);
++  x = f2 (x, d836);
++  x = f2 (x, d837);
++  x = f2 (x, d838);
++  x = f2 (x, d839);
++  x = f2 (x, d840);
++  x = f2 (x, d841);
++  x = f2 (x, d842);
++  x = f2 (x, d843);
++  x = f2 (x, d844);
++  x = f2 (x, d845);
++  x = f2 (x, d846);
++  x = f2 (x, d847);
++  x = f2 (x, d848);
++  x = f2 (x, d849);
++  x = f2 (x, d850);
++  x = f2 (x, d851);
++  x = f2 (x, d852);
++  x = f2 (x, d853);
++  x = f2 (x, d854);
++  x = f2 (x, d855);
++  x = f2 (x, d856);
++  x = f2 (x, d857);
++  x = f2 (x, d858);
++  x = f2 (x, d859);
++  x = f2 (x, d860);
++  x = f2 (x, d861);
++  x = f2 (x, d862);
++  x = f2 (x, d863);
++  x = f2 (x, d864);
++  x = f2 (x, d865);
++  x = f2 (x, d866);
++  x = f2 (x, d867);
++  x = f2 (x, d868);
++  x = f2 (x, d869);
++  x = f2 (x, d870);
++  x = f2 (x, d871);
++  x = f2 (x, d872);
++  x = f2 (x, d873);
++  x = f2 (x, d874);
++  x = f2 (x, d875);
++  x = f2 (x, d876);
++  x = f2 (x, d877);
++  x = f2 (x, d878);
++  x = f2 (x, d879);
++  x = f2 (x, d880);
++  x = f2 (x, d881);
++  x = f2 (x, d882);
++  x = f2 (x, d883);
++  x = f2 (x, d884);
++  x = f2 (x, d885);
++  x = f2 (x, d886);
++  x = f2 (x, d887);
++  x = f2 (x, d888);
++  x = f2 (x, d889);
++  x = f2 (x, d890);
++  x = f2 (x, d891);
++  x = f2 (x, d892);
++  x = f2 (x, d893);
++  x = f2 (x, d894);
++  x = f2 (x, d895);
++  x = f2 (x, d896);
++  x = f2 (x, d897);
++  x = f2 (x, d898);
++  x = f2 (x, d899);
++  x = f2 (x, d900);
++  x = f2 (x, d901);
++  x = f2 (x, d902);
++  x = f2 (x, d903);
++  x = f2 (x, d904);
++  x = f2 (x, d905);
++  x = f2 (x, d906);
++  x = f2 (x, d907);
++  x = f2 (x, d908);
++  x = f2 (x, d909);
++  x = f2 (x, d910);
++  x = f2 (x, d911);
++  x = f2 (x, d912);
++  x = f2 (x, d913);
++  x = f2 (x, d914);
++  x = f2 (x, d915);
++  x = f2 (x, d916);
++  x = f2 (x, d917);
++  x = f2 (x, d918);
++  x = f2 (x, d919);
++  x = f2 (x, d920);
++  x = f2 (x, d921);
++  x = f2 (x, d922);
++  x = f2 (x, d923);
++  x = f2 (x, d924);
++  x = f2 (x, d925);
++  x = f2 (x, d926);
++  x = f2 (x, d927);
++  x = f2 (x, d928);
++  x = f2 (x, d929);
++  x = f2 (x, d930);
++  x = f2 (x, d931);
++  x = f2 (x, d932);
++  x = f2 (x, d933);
++  x = f2 (x, d934);
++  x = f2 (x, d935);
++  x = f2 (x, d936);
++  x = f2 (x, d937);
++  x = f2 (x, d938);
++  x = f2 (x, d939);
++  x = f2 (x, d940);
++  x = f2 (x, d941);
++  x = f2 (x, d942);
++  x = f2 (x, d943);
++  x = f2 (x, d944);
++  x = f2 (x, d945);
++  x = f2 (x, d946);
++  x = f2 (x, d947);
++  x = f2 (x, d948);
++  x = f2 (x, d949);
++  x = f2 (x, d950);
++  x = f2 (x, d951);
++  x = f2 (x, d952);
++  x = f2 (x, d953);
++  x = f2 (x, d954);
++  x = f2 (x, d955);
++  x = f2 (x, d956);
++  x = f2 (x, d957);
++  x = f2 (x, d958);
++  x = f2 (x, d959);
++  x = f2 (x, d960);
++  x = f2 (x, d961);
++  x = f2 (x, d962);
++  x = f2 (x, d963);
++  x = f2 (x, d964);
++  x = f2 (x, d965);
++  x = f2 (x, d966);
++  x = f2 (x, d967);
++  x = f2 (x, d968);
++  x = f2 (x, d969);
++  x = f2 (x, d970);
++  x = f2 (x, d971);
++  x = f2 (x, d972);
++  x = f2 (x, d973);
++  x = f2 (x, d974);
++  x = f2 (x, d975);
++  x = f2 (x, d976);
++  x = f2 (x, d977);
++  x = f2 (x, d978);
++  x = f2 (x, d979);
++  x = f2 (x, d980);
++  x = f2 (x, d981);
++  x = f2 (x, d982);
++  x = f2 (x, d983);
++  x = f2 (x, d984);
++  x = f2 (x, d985);
++  x = f2 (x, d986);
++  x = f2 (x, d987);
++  x = f2 (x, d988);
++  x = f2 (x, d989);
++  x = f2 (x, d990);
++  x = f2 (x, d991);
++  x = f2 (x, d992);
++  x = f2 (x, d993);
++  x = f2 (x, d994);
++  x = f2 (x, d995);
++  x = f2 (x, d996);
++  x = f2 (x, d997);
++  x = f2 (x, d998);
++  x = f2 (x, d999);
++  return x;
++}
++
++/* { dg-final { scan-rtl-dump-times "Stack clash inline probes" 1 "pro_and_epilogue" } } */
++/* { dg-final { scan-rtl-dump-times "Stack clash residual allocation in prologue" 1 "pro_and_epilogue" } } */
++/* { dg-final { scan-rtl-dump-times "Stack clash not noreturn" 1 "pro_and_epilogue" } } */
++
++/* f3 is not a leaf
++/* { dg-final { scan-rtl-dump-times "Stack clash no frame pointer needed" 1 "pro_and_epilogue" { target { ! frame_pointer_for_non_leaf } } } } */
++/* { dg-final { scan-rtl-dump-times "Stack clash frame pointer needed" 1 "pro_and_epilogue" { target { frame_pointer_for_non_leaf } } } } */
+diff --git a/gcc/testsuite/lib/target-supports.exp b/gcc/testsuite/lib/target-supports.exp
+index 821cea9cb33..2c669a9822f 100644
+--- a/gcc/testsuite/lib/target-supports.exp
++++ b/gcc/testsuite/lib/target-supports.exp
+@@ -5421,11 +5421,15 @@ proc check_effective_target_autoincdec { } {
+ proc check_effective_target_supports_stack_clash_protection { } {
+ 
+    # Temporary until the target bits are fully ACK'd.
+-#  if { [istarget aarch*-*-*] || [istarget x86_64-*-*]
+-#       || [istarget i?86-*-*] || [istarget s390*-*-*]
++#  if { [istarget aarch*-*-*]
++#       || [istarget s390*-*-*]
+ #       || [istarget powerpc*-*-*] || [istarget rs6000*-*-*] } {
+ #	return 1
+ #  }
++
++    if { [istarget x86_64-*-*] || [istarget i?86-*-*] } {
++	return 1
++    }
+   return 0
+ }
+