Update to the 20140605 snapshot of GCC 4.8.4.

Add support for "-fstack-protector-strong".  This extends the
WITH_SSP_PORTS Makefile option in FreeBSD which adds "-fstack-protector"
and "-fstack-protector-all" command-line options that add extra code to
check for buffer overflows to ports built that way, cf.
https://gcc.gnu.org/onlinedocs/gcc-4.8.3/gcc/Optimize-Options.html

While this was a good first step, those switches offer too little
protection or too much overhead and so Google contributed a balanced
"-fstack-protector-strong". [1]

PR:		186852 [1]
Submitted by:	software-freebsd@interfasys.ch [1]

1 files changed, 176 insertions, 0 deletions

diff --git a/lang/gcc48/files/patch-stackprotector-gcc_testsuite b/lang/gcc48/files/patch-stackprotector-gcc_testsuite
new file mode 100644
index 000000000000..443a7b4ef893
--- /dev/null
+++ b/lang/gcc48/files/patch-stackprotector-gcc_testsuite
@@ -0,0 +1,176 @@
+--- /dev/null
++++ gcc/testsuite/g++.dg/fstack-protector-strong.C
+@@ -0,0 +1,35 @@
++/* Test that stack protection is done on chosen functions. */
++
++/* { dg-do compile { target i?86-*-* x86_64-*-* } } */
++/* { dg-options "-O2 -fstack-protector-strong" } */
++
++class A
++{
++public:
++  A() {}
++  ~A() {}
++  void method();
++  int state;
++};
++
++/* Frame address exposed to A::method via "this". */
++int
++foo1 ()
++{
++  A a;
++  a.method ();
++  return a.state;
++}
++
++/* Possible destroying foo2's stack via &a. */
++int
++global_func (A& a);
++
++/* Frame address exposed to global_func. */
++int foo2 ()
++{
++  A a;
++  return global_func (a);
++}
++
++/* { dg-final { scan-assembler-times "stack_chk_fail" 2 } } */
+--- /dev/null
++++ gcc/testsuite/gcc.dg/fstack-protector-strong.c
+@@ -0,0 +1,135 @@
++/* Test that stack protection is done on chosen functions. */
++
++/* { dg-do compile { target i?86-*-* x86_64-*-* } } */
++/* { dg-options "-O2 -fstack-protector-strong" } */
++
++#include<string.h>
++#include<stdlib.h>
++
++extern int g0;
++extern int* pg0;
++int
++goo (int *);
++int
++hoo (int);
++
++/* Function frame address escaped function call. */
++int
++foo1 ()
++{
++  int i;
++  return goo (&i);
++}
++
++struct ArrayStruct
++{
++  int a;
++  int array[10];
++};
++
++struct AA
++{
++  int b;
++  struct ArrayStruct as;
++};
++
++/* Function frame contains array. */
++int
++foo2 ()
++{
++  struct AA aa;
++  int i;
++  for (i = 0; i < 10; ++i)
++    {
++      aa.as.array[i] = i * (i-1) + i / 2;
++    }
++  return aa.as.array[5];
++}
++
++/* Address computation based on a function frame address. */
++int
++foo3 ()
++{
++  int a;
++  int *p;
++  p = &a + 5;
++  return goo (p);
++}
++
++/* Address cast based on a function frame address. */
++int
++foo4 ()
++{
++  int a;
++  return goo (g0 << 2 ? (int *)(3 * (long)(void *)(&a)) : 0);
++}
++
++/* Address cast based on a local array. */
++int
++foo5 ()
++{
++  short array[10];
++  return goo ((int *)(array + 5));
++}
++
++struct BB
++{
++  int one;
++  int two;
++  int three;
++};
++
++/* Address computaton based on a function frame address.*/
++int
++foo6 ()
++{
++  struct BB bb;
++  return goo (&bb.one + sizeof(int));
++}
++
++/* Function frame address escaped via global variable. */
++int
++foo7 ()
++{
++  int a;
++  pg0 = &a;
++  goo (pg0);
++  return *pg0;
++}
++
++/* Check that this covers -fstack-protector. */
++int
++foo8 ()
++{
++  char base[100];
++  memcpy ((void *)base, (const void *)pg0, 105);
++  return (int)(base[32]);
++}
++
++/* Check that this covers -fstack-protector. */
++int
++foo9 ()
++{
++  char* p = alloca (100);
++  return goo ((int *)(p + 50));
++}
++
++int
++global2 (struct BB* pbb);
++
++/* Address taken on struct. */
++int
++foo10 ()
++{
++  struct BB bb;
++  int i;
++  bb.one = global2 (&bb);
++  for (i = 0; i < 10; ++i)
++    {
++      bb.two = bb.one + bb.two;
++      bb.three = bb.one + bb.two + bb.three;
++    }
++  return bb.three;
++}
++
++/* { dg-final { scan-assembler-times "stack_chk_fail" 10 } } */