+2012-01-11 Richard Guenther <rguenther@suse.de>

+

+ PR tree-optimization/44061

+ * gcc.dg/pr44061.c: New testcase.

+

+2013-01-10 Richard Sandiford <rdsandiford@googlemail.com>

+

+ Update copyright years

+

+2013-01-10 Aldy Hernandez <aldyh@redhat.com>

+ Jakub Jelinek <jakub@redhat.com>

+

+ PR target/55565

+ * gcc.target/powerpc/ppc-mov-1.c: Update scan-assembler-not

+ regex.

+

+2013-01-10 Vladimir Makarov <vmakarov@redhat.com>

+

+ PR rtl-optimization/pr55672

+ * gcc.target/i386/pr55672.c: New.

+

+2013-01-10 Jeff Law <law@redhat.com>

+

+ * gcc/dg/tree-ssa/vrp06.c: Tighten expected output. Make each

+ pass/fail message unique.

+

+

+2013-01-10 Jason Merrill <jason@redhat.com>

+

+ * ada/.gitignore: New.

+

+2013-01-10 Rainer Orth <ro@CeBiTec.Uni-Bielefeld.DE>

+

+ * g++.dg/tls/thread_local-cse.C: Don't xfail on *-*-solaris2.9.

+ Add tls options.

+ * g++.dg/tls/thread_local2.C: Likewise.

+ * g++.dg/tls/thread_local2g.C: Likewise.

+ * g++.dg/tls/thread_local6.C: Likewise.

+ * g++.dg/tls/thread_local-order1.C: Add tls options.

+ * g++.dg/tls/thread_local-order2.C: Likewise.

+ * g++.dg/tls/thread_local3.C: Likewise.

+ * g++.dg/tls/thread_local3g.C: Likewise.

+ * g++.dg/tls/thread_local4.C: Likewise.

+ * g++.dg/tls/thread_local4g.C: Likewise.

+ * g++.dg/tls/thread_local5.C: Likewise.

+ * g++.dg/tls/thread_local5g.C: Likewise.

+ * g++.dg/tls/thread_local6g.C: Likewise.

+

+2013-01-10 Kostya Serebryany <kcc@google.com>

+

+ * g++.dg/asan/asan_test.cc: Sync from upstream.

+

+2013-01-10 Jakub Jelinek <jakub@redhat.com>

+

+ PR tree-optimization/55921

+ * gcc.c-torture/compile/pr55921.c: New test.

+

+2013-01-09 Jan Hubicka <jh@suse.cz>

+

+ PR tree-optimization/55569

+ * gcc.c-torture/compile/pr55569.c: New testcase.

+

+2013-01-09 Mikael Morin <mikael@gcc.gnu.org>

+

+ PR fortran/47203

+ * gfortran.dg/use_28.f90: New test.

+

+2012-01-09 Uros Bizjak <ubizjak@gmail.com>

+

+ * gfortran.dg/intrinsic_size_3.f90: Make scan-tree-dump-times

+ number matching more robust.

+

+2013-01-09 Vladimir Makarov <vmakarov@redhat.com>

+

+ PR rtl-optimization/55829

+ * gcc.target/i386/pr55829.c: New.

+

+2013-01-09 Tobias Burnus <burnus@net-b.de>

+

+ PR fortran/55758

+ * gfortran.dg/bind_c_bool_1.f90: New.

+ * gfortran.dg/do_5.f90: Add dg-warning.

+

+2013-01-09 Jan Hubicka <jh@suse.cz>

+

+ PR tree-optimiation/55875

+ * gcc.c-torture/execute/pr55875.c: New testcase.

+ * g++.dg/torture/pr55875.C: New testcase.

+

+2013-01-09 Jakub Jelinek <jakub@redhat.com>

+

+ PR c/48418

+ * c-c++-common/pr48418.c: New test.

+

+2013-01-09 Paolo Carlini <paolo.carlini@oracle.com>

+

+ PR c++/55801

+ * g++.dg/tls/thread_local-ice.C: New.

+

+2013-01-09 Andreas Schwab <schwab@suse.de>

+

+ * gcc.dg/guality/pr54693.c: Null-terminate arr.

+

+2013-01-09 Jakub Jelinek <jakub@redhat.com>

+

+ PR tree-optimization/48189

+ * gcc.dg/pr48189.c: New test.

+

+2013-01-04 Jan Hubicka <jh@suse.cz>

+

+ PR tree-optimization/55823

+ * g++.dg/ipa/devirt-10.C: New testcase.

+

+2012-01-08 Uros Bizjak <ubizjak@gmail.com>

+ Vladimir Yakovlev <vladimir.b.yakovlev@intel.com>

+

+ PR rtl-optimization/55845

+ * gcc.target/i386/pr55845.c: New test.

+

+2013-01-08 Tejas Belagod <tejas.belagod@arm.com>

+

+ * gcc.target/aarch64/vect-mull-compile.c: Explicitly scan for

+ instructions generated instead of number of occurances.

+

+2013-01-08 James Greenhalgh <james.greenhalgh@arm.com>

+

+ * gcc/testsuite/gcc.target/aarch64/vect-fcm-eq-d.c: New.

+ * gcc/testsuite/gcc.target/aarch64/vect-fcm-eq-f.c: Likewise.

+ * gcc/testsuite/gcc.target/aarch64/vect-fcm-ge-d.c: Likewise.

+ * gcc/testsuite/gcc.target/aarch64/vect-fcm-ge-f.c: Likewise.

+ * gcc/testsuite/gcc.target/aarch64/vect-fcm-gt-d.c: Likewise.

+ * gcc/testsuite/gcc.target/aarch64/vect-fcm-gt-f.c: Likewise.

+ * gcc/testsuite/gcc.target/aarch64/vect-fcm.x: Likewise.

+ * gcc/testsuite/lib/target-supports.exp

+ (check_effective_target_vect_cond): Enable for AArch64.

+

+2013-01-08 James Greenhalgh <james.greenhalgh@arm.com>

+

+ * gcc.target/aarch64/vsqrt.c (test_square_root_v2sf): Use

+ endian-safe float pool loading.

+ (test_square_root_v4sf): Likewise.

+ (test_square_root_v2df): Likewise.

+ * lib/target-supports.exp

+ (check_effective_target_vect_call_sqrtf): Add AArch64.

+

+2013-01-08 Martin Jambor <mjambor@suse.cz>

+

+ PR debug/55579

+ * gcc.dg/tree-ssa/pr55579.c: New test.

+

+2013-01-08 Rainer Orth <ro@CeBiTec.Uni-Bielefeld.DE>

+

+ * g++.dg/debug/dwarf2/pr54508.C: Allow for more whitespace after

+ asm comments.

+

+2013-01-08 Jakub Jelinek <jakub@redhat.com>

+

+ PR middle-end/55890

+ * gcc.dg/torture/pr55890-3.c: New test.

+

+ PR middle-end/55851

+ * gcc.c-torture/compile/pr55851.c: New test.

+

+ PR sanitizer/55844

+ * c-c++-common/asan/null-deref-1.c: Add -fno-shrink-wrap to

+ dg-options.

+

+2013-01-08 Paul Thomas <pault@gcc.gnu.org>

+

+ PR fortran/55618

+ * gfortran.dg/elemental_scalar_args_2.f90: New test.

+

+2013-01-07 Tobias Burnus <burnus@net-b.de>

+

+ PR fortran/55763

+ * gfortran.dg/pointer_init_2.f90: Update dg-error.

+ * gfortran.dg/pointer_init_7.f90: New.

+

+2013-01-07 Richard Biener <rguenther@suse.de>

+

+ * gcc.dg/lto/pr55525_0.c (s): Size like char *.

+

+2013-01-07 Richard Biener <rguenther@suse.de>

+

+ PR middle-end/55890

+ * gcc.dg/torture/pr55890-1.c: New testcase.

+ * gcc.dg/torture/pr55890-2.c: Likewise.

+

+2013-01-07 James Greenhalgh <james.greenhalgh@arm.com>

+

+ * gcc.target/aarch64/fmovd.c: New.

+ * gcc.target/aarch64/fmovf.c: Likewise.

+ * gcc.target/aarch64/fmovd-zero.c: Likewise.

+ * gcc.target/aarch64/fmovf-zero.c: Likewise.

+ * gcc.target/aarch64/vect-fmovd.c: Likewise.

+ * gcc.target/aarch64/vect-fmovf.c: Likewise.

+ * gcc.target/aarch64/vect-fmovd-zero.c: Likewise.

+ * gcc.target/aarch64/vect-fmovf-zero.c: Likewise.

+

+2013-01-07 Richard Biener <rguenther@suse.de>

+

+ PR tree-optimization/55888

+ PR tree-optimization/55862

+ * gcc.dg/torture/pr55888.c: New testcase.

+

+2013-01-07 Tobias Burnus <burnus@net-b.de>

+

+ PR fortran/55852

+ * gfortran.dg/intrinsic_size_3.f90: New.

+

+2012-01-07 Tobias Burnus <burnus@net-b.de>

+

+ PR fortran/55763

+ * gfortran.dg/select_type_32.f90: New.

+

+ PR fortran/53876

+ PR fortran/54990

+ PR fortran/54992

+Copyright (C) 1993-2007 Free Software Foundation, Inc.

+Copyright (C) 2006-2007 Free Software Foundation, Inc.

+Copyright (C) 2002-2004 Free Software Foundation, Inc.

+Copyright (C) 1998-2013 Free Software Foundation, Inc.

+Copyright (C) 2002-2013 Free Software Foundation, Inc.

+Copyright (C) 1997-2013 Free Software Foundation, Inc.

+# In the Ada testsuite, .a is an ada source file, not a library.

+!*.a

+/* { dg-options "-fno-omit-frame-pointer -fno-shrink-wrap" } */

+/* PR c/48418 */

+/* { dg-do compile } */

+/* { dg-options "-Wall -O2" } */

+

+int

+foo (int x)

+{

+ const int a = sizeof (int) * __CHAR_BIT__;

+ const int b = -7;

+ int c = 0;

+ c += x << a; /* { dg-warning "left shift count >= width of type" } */

+ c += x << b; /* { dg-warning "left shift count is negative" } */

+ c += x << (sizeof (int) * __CHAR_BIT__); /* { dg-warning "left shift count >= width of type" } */

+ c += x << -7; /* { dg-warning "left shift count is negative" } */

+ c += x >> a; /* { dg-warning "right shift count >= width of type" } */

+ c += x >> b; /* { dg-warning "right shift count is negative" } */

+ c += x >> (sizeof (int) * __CHAR_BIT__); /* { dg-warning "right shift count >= width of type" } */

+ c += x >> -7; /* { dg-warning "right shift count is negative" } */

+ return c;

+}

+# Copyright (C) 1997-2013 Free Software Foundation, Inc.

+Copyright (C) 2001-2013 Free Software Foundation, Inc.

+# Copyright (C) 2012-2013 Free Software Foundation, Inc.

+#include <algorithm>

+

+#ifdef __linux__

+# include <sys/prctl.h>

+# include <sys/types.h>

+# include <sys/stat.h>

+# include <fcntl.h>

+#include <unistd.h>

+#endif

+ for (int i = size - sizeof(T) + 1; i <= (int)(size + 2 * sizeof(T)); i++) {

+#if ASAN_ALLOCATOR_VERSION == 2 // Broken with the asan_allocator1

+TEST(AddressSanitizer, LargeOOBRightTest) {

+ size_t large_power_of_two = 1 << 19;

+ for (size_t i = 16; i <= 256; i *= 2) {

+ size_t size = large_power_of_two - i;

+ char *p = Ident(new char[size]);

+ EXPECT_DEATH(p[size] = 0, "is located 0 bytes to the right");

+ delete [] p;

+ }

+}

+#endif // ASAN_ALLOCATOR_VERSION == 2

+

+#ifndef __APPLE__

+void MemalignRun(size_t align, size_t size, int idx) {

+ char *p = (char *)memalign(align, size);

+ Ident(p)[idx] = 0;

+ free(p);

+}

+

+TEST(AddressSanitizer, memalign) {

+ for (int align = 16; align <= (1 << 23); align *= 2) {

+ size_t size = align * 5;

+ EXPECT_DEATH(MemalignRun(align, size, -1),

+ "is located 1 bytes to the left");

+ EXPECT_DEATH(MemalignRun(align, size, size + 1),

+ "is located 1 bytes to the right");

+ }

+}

+#endif

+

+static string RightOOBErrorMessage(int oob_distance, bool is_write) {

+ sprintf(expected_str, ASAN_PCRE_DOTALL "%s.*located %d bytes to the right",

+ is_write ? "WRITE" : "READ", oob_distance);

+static string RightOOBWriteMessage(int oob_distance) {

+ return RightOOBErrorMessage(oob_distance, /*is_write*/true);

+}

+

+static string RightOOBReadMessage(int oob_distance) {

+ return RightOOBErrorMessage(oob_distance, /*is_write*/false);

+}

+

+static string LeftOOBErrorMessage(int oob_distance, bool is_write) {

+ assert(oob_distance > 0);

+ char expected_str[100];

+ sprintf(expected_str, ASAN_PCRE_DOTALL "%s.*located %d bytes to the left",

+ is_write ? "WRITE" : "READ", oob_distance);

+ return string(expected_str);

+}

+

+static string LeftOOBWriteMessage(int oob_distance) {

+ return LeftOOBErrorMessage(oob_distance, /*is_write*/true);

+}

+

+static string LeftOOBReadMessage(int oob_distance) {

+ return LeftOOBErrorMessage(oob_distance, /*is_write*/false);

+}

+

+static string LeftOOBAccessMessage(int oob_distance) {

+ void *(*MEMSET)(void *s, int c, size_t n) = Ident(memset);

+ MEMSET(array, element, size);

+ MEMSET(array, element, size - 1);

+ MEMSET(array + length - 1, element, sizeof(T));

+ MEMSET(array, element, 1);

+ MEMSET(array - 10, element, zero);

+ MEMSET(array - 1, element, zero);

+ MEMSET(array, element, zero);

+ MEMSET(array + length, 0, zero);

+ MEMSET(array + length + 1, 0, zero);

+ EXPECT_DEATH(MEMSET(array, 0, size + 1),

+ RightOOBWriteMessage(0));

+ EXPECT_DEATH(MEMSET((char*)(array + length) - 1, element, 6),

+ RightOOBWriteMessage(0));

+ EXPECT_DEATH(MEMSET(array + 1, element, size + sizeof(T)),

+ RightOOBWriteMessage(0));

+ EXPECT_DEATH(MEMSET(array + length + 1, 0, 10),

+ RightOOBWriteMessage(sizeof(T)));

+ EXPECT_DEATH(MEMSET((char*)array - 1, element, size),

+ LeftOOBWriteMessage(1));

+ EXPECT_DEATH(MEMSET((char*)array - 5, 0, 6),

+ LeftOOBWriteMessage(5));

+ if (length >= 100) {

+ // Large OOB, we find it only if the redzone is large enough.

+ EXPECT_DEATH(memset(array - 5, element, size + 5 * sizeof(T)),

+ LeftOOBWriteMessage(5 * sizeof(T)));

+ }

+ EXPECT_DEATH(MEMSET(array - 2, 0, sizeof(T)),

+ LeftOOBWriteMessage(2 * sizeof(T)));

+ EXPECT_DEATH(MEMSET((char*)array - 2, element, size + 4),

+ LeftOOBWriteMessage(2));

+// Try to allocate two arrays of 'size' bytes that are near each other.

+// Strictly speaking we are not guaranteed to find such two pointers,

+// but given the structure of asan's allocator we will.

+static bool AllocateTwoAdjacentArrays(char **x1, char **x2, size_t size) {

+ vector<char *> v;

+ bool res = false;

+ for (size_t i = 0; i < 1000U && !res; i++) {

+ v.push_back(new char[size]);

+ if (i == 0) continue;

+ sort(v.begin(), v.end());

+ for (size_t j = 1; j < v.size(); j++) {

+ assert(v[j] > v[j-1]);

+ if ((size_t)(v[j] - v[j-1]) < size * 2) {

+ *x2 = v[j];

+ *x1 = v[j-1];

+ res = true;

+ break;

+ }

+ }

+ }

+

+ for (size_t i = 0; i < v.size(); i++) {

+ if (res && v[i] == *x1) continue;

+ if (res && v[i] == *x2) continue;

+ delete [] v[i];

+ }

+ return res;

+}

+

+TEST(AddressSanitizer, LargeOOBInMemset) {

+ for (size_t size = 200; size < 100000; size += size / 2) {

+ char *x1, *x2;

+ if (!Ident(AllocateTwoAdjacentArrays)(&x1, &x2, size))

+ continue;

+ // fprintf(stderr, " large oob memset: %p %p %zd\n", x1, x2, size);

+ // Do a memset on x1 with huge out-of-bound access that will end up in x2.

+ EXPECT_DEATH(Ident(memset)(x1, 0, size * 2),

+ "is located 0 bytes to the right");

+ delete [] x1;

+ delete [] x2;

+ return;

+ }

+ assert(0 && "Did not find two adjacent malloc-ed pointers");

+}

+

+ RightOOBWriteMessage(0));

+ RightOOBWriteMessage(0));

+ LeftOOBWriteMessage(2 * sizeof(T)));

+ LeftOOBWriteMessage(3));

+ RightOOBReadMessage(0));

+ RightOOBReadMessage(0));

+ LeftOOBReadMessage(sizeof(T)));

+ LeftOOBReadMessage(6));

+ LeftOOBWriteMessage(sizeof(T)));

+ LeftOOBReadMessage(2 * sizeof(T)));

+ return Ident(memcpy)(to, from, size);

+ return Ident(memmove)(to, from, size);

+ EXPECT_DEATH(Ident(strlen(str - 1)), LeftOOBReadMessage(1));

+ EXPECT_DEATH(Ident(strlen(str - 5)), LeftOOBReadMessage(5));

+ EXPECT_DEATH(Ident(strlen(str + length + 1)), RightOOBReadMessage(0));

+ EXPECT_DEATH(Ident(strlen(str)), RightOOBReadMessage(0));

+ EXPECT_DEATH(Ident(strlen(str + length)), RightOOBReadMessage(0));

+ EXPECT_DEATH(Ident(strnlen(str - 1, 1)), LeftOOBReadMessage(1));

+ EXPECT_DEATH(Ident(strnlen(str + size, 1)), RightOOBReadMessage(0));

+ EXPECT_DEATH(Ident(strnlen(str, size + 1)), RightOOBReadMessage(0));

+ EXPECT_DEATH(Ident(strdup(str - 1)), LeftOOBReadMessage(1));

+ EXPECT_DEATH(Ident(strdup(str + size)), RightOOBReadMessage(0));

+ EXPECT_DEATH(Ident(strdup(str)), RightOOBReadMessage(0));

+ EXPECT_DEATH(Ident(strcpy(from, "hello2")), RightOOBWriteMessage(0));

+ EXPECT_DEATH(Ident(strcpy(to - 1, from)), LeftOOBWriteMessage(1));

+ EXPECT_DEATH(Ident(strcpy(to, from - 1)), LeftOOBReadMessage(1));

+ EXPECT_DEATH(Ident(strcpy(to, from + from_size)), RightOOBReadMessage(0));

+ EXPECT_DEATH(Ident(strcpy(to + to_size, from)), RightOOBWriteMessage(0));

+ EXPECT_DEATH(Ident(strcpy(to, from)), RightOOBReadMessage(0));

+ LeftOOBReadMessage(1));

+ LeftOOBWriteMessage(1));

+ RightOOBReadMessage(0));

+ RightOOBWriteMessage(0));

+ RightOOBWriteMessage(0));

+ RightOOBWriteMessage(0));

+ RightOOBReadMessage(0));

+ EXPECT_DEATH(Ident(StrChr(str - 1, 'z')), LeftOOBReadMessage(1));

+ EXPECT_DEATH(Ident(StrChr(str + size, 'z')), RightOOBReadMessage(0));

+ EXPECT_DEATH(Ident(StrChr(str, 'a')), RightOOBReadMessage(0));

+ EXPECT_DEATH(Ident(StrChr(str - 1, 'z')), LeftOOBReadMessage(1));

+ EXPECT_DEATH(Ident(StrChr(str + size, 'z')), RightOOBReadMessage(0));

+ EXPECT_DEATH(Ident(StrChr(str, 'a')), RightOOBReadMessage(0));

+ int fill = 'o';

+ char *s1 = MallocAndMemsetString(size, fill);

+ char *s2 = MallocAndMemsetString(size, fill);

+ EXPECT_DEATH(Ident(StrCmp)(s1 - 1, s2), LeftOOBReadMessage(1));

+ EXPECT_DEATH(Ident(StrCmp)(s1, s2 - 1), LeftOOBReadMessage(1));

+ EXPECT_DEATH(Ident(StrCmp)(s1 + size, s2), RightOOBReadMessage(0));

+ EXPECT_DEATH(Ident(StrCmp)(s1, s2 + size), RightOOBReadMessage(0));

+ s1[size - 1] = fill;

+ EXPECT_DEATH(Ident(StrCmp)(s1, s1), RightOOBReadMessage(0));

+ EXPECT_DEATH(Ident(StrCmp)(s1 + size - 1, s2), RightOOBReadMessage(0));

+ EXPECT_DEATH(Ident(StrNCmp)(s1 - 1, s2, 1), LeftOOBReadMessage(1));

+ EXPECT_DEATH(Ident(StrNCmp)(s1, s2 - 1, 1), LeftOOBReadMessage(1));

+ EXPECT_DEATH(Ident(StrNCmp)(s1 + size, s2, 1), RightOOBReadMessage(0));

+ EXPECT_DEATH(Ident(StrNCmp)(s1, s2 + size, 1), RightOOBReadMessage(0));

+ EXPECT_DEATH(Ident(StrNCmp)(s1 + 1, s2 + 1, size), RightOOBReadMessage(0));

+ EXPECT_DEATH(Ident(StrNCmp)(s1 + size - 1, s2, 2), RightOOBReadMessage(0));

+ EXPECT_DEATH(Ident(memcmp)(s1 - 1, s2, 1), LeftOOBReadMessage(1));

+ EXPECT_DEATH(Ident(memcmp)(s1, s2 - 1, 1), LeftOOBReadMessage(1));

+ EXPECT_DEATH(Ident(memcmp)(s1 + size, s2, 1), RightOOBReadMessage(0));

+ EXPECT_DEATH(Ident(memcmp)(s1, s2 + size, 1), RightOOBReadMessage(0));

+ EXPECT_DEATH(Ident(memcmp)(s1 + 1, s2 + 1, size), RightOOBReadMessage(0));

+ EXPECT_DEATH(Ident(memcmp)(s1 + size - 1, s2, 2), RightOOBReadMessage(0));

+ EXPECT_DEATH(Ident(memcmp)(s1, s2, size + 1), RightOOBReadMessage(0));

+ // strcat() reads strlen(to) bytes from |to| before concatenating.

+ EXPECT_DEATH(strcat(to - 1, from + from_size - 1), LeftOOBAccessMessage(1));

+ EXPECT_DEATH(strcat(to - 1, from), LeftOOBAccessMessage(1));

+ EXPECT_DEATH(strcat(to, from - 1), LeftOOBReadMessage(1));

+ EXPECT_DEATH(strcat(to + to_size, from), RightOOBWriteMessage(0));

+ EXPECT_DEATH(strcat(to, from + from_size), RightOOBReadMessage(0));

+ EXPECT_DEATH(strcat(to, from), RightOOBReadMessage(0));

+ EXPECT_DEATH(strcat(to, from), RightOOBWriteMessage(0));

+ EXPECT_DEATH(strcat(to, from), RightOOBWriteMessage(0));

+ // strncat() reads strlen(to) bytes from |to| before concatenating.

+ EXPECT_DEATH(strncat(to - 1, from, 0), LeftOOBAccessMessage(1));

+ EXPECT_DEATH(strncat(to - 1, from, 2), LeftOOBAccessMessage(1));

+ EXPECT_DEATH(strncat(to, from - 1, 2), LeftOOBReadMessage(1));

+ EXPECT_DEATH(strncat(to + to_size, from, 2), RightOOBWriteMessage(0));

+ EXPECT_DEATH(strncat(to, from + from_size, 2), RightOOBReadMessage(0));

+ EXPECT_DEATH(strncat(to, from, from_size + 1), RightOOBReadMessage(0));

+ EXPECT_DEATH(strncat(to + 1, from, 1), RightOOBWriteMessage(0));

+ EXPECT_DEATH(strncat(to, from, from_size - 1), RightOOBWriteMessage(0));

+ EXPECT_DEATH(Atoi(array + 11), RightOOBReadMessage(1));

+ EXPECT_DEATH(Atoi(array - 1), LeftOOBReadMessage(1));

+ EXPECT_DEATH(Atoi(array), RightOOBReadMessage(0));

+ EXPECT_DEATH(Atoi(array), RightOOBReadMessage(0));

+ EXPECT_DEATH(Atoi(array), RightOOBReadMessage(0));

+ EXPECT_DEATH(Atoi(array + 9), RightOOBReadMessage(0));

+ free(array);

+ EXPECT_DEATH(Strtol(array + 3, NULL, 0), RightOOBReadMessage(0));

+ EXPECT_DEATH(Strtol(array - 1, NULL, 0), LeftOOBReadMessage(1));

+ EXPECT_DEATH(Strtol(array, NULL, 0), RightOOBReadMessage(0));

+ EXPECT_DEATH(Strtol(array, NULL, 36), RightOOBReadMessage(0));

+ EXPECT_DEATH(Strtol(array, NULL, 0), RightOOBReadMessage(0));

+ EXPECT_DEATH(Strtol(array, NULL, 0), RightOOBReadMessage(0));

+ EXPECT_DEATH(Strtol(array, NULL, 0), RightOOBReadMessage(0));

+ free(array);

+ EXPECT_DEATH(MemSet(array, 0, 101), RightOOBWriteMessage(0));

+ EXPECT_DEATH(MemTransfer(dst, src, 101), RightOOBWriteMessage(0));

+#if defined(__linux__) && !defined(ANDROID) && !defined(__ANDROID__)

+TEST(AddressSanitizer, pread) {

+ char *x = new char[10];

+ int fd = open("/proc/self/stat", O_RDONLY);

+ ASSERT_GT(fd, 0);

+ EXPECT_DEATH(pread(fd, x, 15, 0),

+ ASAN_PCRE_DOTALL

+ "AddressSanitizer: heap-buffer-overflow"

+ ".* is located 0 bytes to the right of 10-byte region");

+ close(fd);

+ delete [] x;

+}

+

+TEST(AddressSanitizer, pread64) {

+ char *x = new char[10];

+ int fd = open("/proc/self/stat", O_RDONLY);

+ ASSERT_GT(fd, 0);

+ EXPECT_DEATH(pread64(fd, x, 15, 0),

+ ASAN_PCRE_DOTALL

+ "AddressSanitizer: heap-buffer-overflow"

+ ".* is located 0 bytes to the right of 10-byte region");

+ close(fd);

+ delete [] x;

+}

+

+TEST(AddressSanitizer, read) {

+ char *x = new char[10];

+ int fd = open("/proc/self/stat", O_RDONLY);

+ ASSERT_GT(fd, 0);

+ EXPECT_DEATH(read(fd, x, 15),

+ ASAN_PCRE_DOTALL

+ "AddressSanitizer: heap-buffer-overflow"

+ ".* is located 0 bytes to the right of 10-byte region");

+ close(fd);

+ delete [] x;

+}

+

+#endif // defined(__linux__) && !defined(ANDROID) && !defined(__ANDROID__)

+

+ EXPECT_DEATH(memset(s + size - 1, 0, 2), RightOOBWriteMessage(0));

+static bool TryToSetThreadName(const char *name) {

+#if defined(__linux__) && defined(PR_SET_NAME)

+ return 0 == prctl(PR_SET_NAME, (unsigned long)name, 0, 0, 0);

+#else

+ return false;

+#endif

+}

+

+ EXPECT_EQ(true, TryToSetThreadName("AllocThr"));

+ EXPECT_EQ(true, TryToSetThreadName("FreeThr"));

+ EXPECT_EQ(true, TryToSetThreadName("UseThr"));

+void *ThreadedTestFunc(void *unused) {

+ // Check if prctl(PR_SET_NAME) is supported. Return if not.

+ if (!TryToSetThreadName("TestFunc"))

+ return 0;

+ EXPECT_DEATH(ThreadedTestSpawn(),

+ ASAN_PCRE_DOTALL

+ "WRITE .*thread T. .UseThr."

+ ".*freed by thread T. .FreeThr. here:"

+ ".*previously allocated by thread T. .AllocThr. here:"

+ ".*Thread T. .UseThr. created by T.*TestFunc"

+ ".*Thread T. .FreeThr. created by T"

+ ".*Thread T. .AllocThr. created by T"

+ "");

+ return 0;

+}

+

+TEST(AddressSanitizer, ThreadNamesTest) {

+ // Run ThreadedTestFunc in a separate thread because it tries to set a

+ // thread name and we don't want to change the main thread's name.

+ pthread_t t;

+ PTHREAD_CREATE(&t, 0, ThreadedTestFunc, 0);

+ PTHREAD_JOIN(t, 0);

+}

+

+static string MismatchStr(const string &str) {

+ return string("AddressSanitizer: alloc-dealloc-mismatch \\(") + str;

+}

+

+// This test is disabled until we enable alloc_dealloc_mismatch by default.

+// The feature is also tested by lit tests.

+TEST(AddressSanitizer, DISABLED_AllocDeallocMismatch) {

+ EXPECT_DEATH(free(Ident(new int)),

+ MismatchStr("operator new vs free"));

+ EXPECT_DEATH(free(Ident(new int[2])),

+ MismatchStr("operator new \\[\\] vs free"));

+ EXPECT_DEATH(delete (Ident(new int[2])),

+ MismatchStr("operator new \\[\\] vs operator delete"));

+ EXPECT_DEATH(delete (Ident((int*)malloc(2 * sizeof(int)))),

+ MismatchStr("malloc vs operator delete"));

+ EXPECT_DEATH(delete [] (Ident(new int)),

+ MismatchStr("operator new vs operator delete \\[\\]"));

+ EXPECT_DEATH(delete [] (Ident((int*)malloc(2 * sizeof(int)))),

+ MismatchStr("malloc vs operator delete \\[\\]"));

+}

+

+// For libdispatch tests below we check that ASan got to the shadow byte

+// legend, i.e. managed to print the thread stacks (this almost certainly

+// means that the libdispatch task creation has been intercepted correctly).

+ EXPECT_DEATH(TestGCDDispatchAsync(), "Shadow byte legend");

+ EXPECT_DEATH(TestGCDDispatchSync(), "Shadow byte legend");

+ EXPECT_DEATH(TestGCDReuseWqthreadsAsync(), "Shadow byte legend");

+ EXPECT_DEATH(TestGCDReuseWqthreadsSync(), "Shadow byte legend");

+ EXPECT_DEATH(TestGCDDispatchAfter(), "Shadow byte legend");

+ EXPECT_DEATH(TestGCDSourceEvent(), "Shadow byte legend");

+ EXPECT_DEATH(TestGCDSourceCancel(), "Shadow byte legend");

+ EXPECT_DEATH(TestGCDGroupAsync(), "Shadow byte legend");

+ const size_t kMallocSize = 100000;

+# Copyright (C) 2001-2013 Free Software Foundation, Inc.

+# Copyright (C) 2004-2013 Free Software Foundation, Inc.

+Copyright (C) 2002-2013 Free Software Foundation, Inc.

+# Copyright (C) 2002-2013 Free Software Foundation, Inc.

+# Copyright (C) 2002-2013 Free Software Foundation, Inc.

+// PR c++/55753

+// { dg-options -std=c++11 }

+

+struct A

+{

+ double r,i;

+ constexpr A(double r = 0.0, double i = 0.0): r(r), i(i) {}

+};

+

+template <typename Tp>

+struct B {

+ B() {

+ A((true ? 1.0 : A()));

+ }

+};

+# Copyright (C) 2002-2013 Free Software Foundation, Inc.

+# Copyright (C) 2007-2013 Free Software Foundation, Inc.

+// { dg-final { scan-assembler-not "\"cbase\\\\0\"\[ \t\]+\[#;/!|@\]+ +DW_AT_name" } }

+// { dg-final { scan-assembler "\"c\\\\0\"\[ \t\]+\[#;/!|@\]+ +DW_AT_name\[\r\n\]+\[\^\r\n\]+\[\r\n\]+\[\^\r\n\]+\[\r\n\]+\[\^#;/!|@\]+\[#;/!|@\]+ +DW_AT_decl_line\[\r\n\]+\[\^#;/!|@\]+\[#;/!|@\]+ +DW_AT_declaration" } }

+// { dg-final { scan-assembler-not "\"OPCODE\\\\0\"\[ \t\]+\[#;/!|@\]+ +DW_AT_name" } }

+// { dg-final { scan-assembler-not "\"bi\\\\0\"\[ \t\]+\[#;/!|@\]+ +DW_AT_name" } }

+// { dg-final { scan-assembler-not "\"si\\\\0\"\[ \t\]+\[#;/!|@\]+ +DW_AT_name" } }

+// { dg-final { scan-assembler "\"s\\\\0\"\[ \t\]+\[#;/!|@\]+ +DW_AT_name" } }

+// { dg-final { scan-assembler-not "\"s\\\\0\"\[^#;/!|@\]+\[#;/!|@\]+ +DW_AT_name\[\r\n\]+\[\^\r\n\]+\[\r\n\]+\[\^\r\n\]+\[\r\n\]+\[\^#;/!|@\]+\[#;/!|@\]+ +DW_AT_decl_line\[\r\n\]+\[ \t\]+\[#;/!|@\]+ +DW_AT_declaration" } }

+// { dg-final { scan-assembler "\"f1\\\\0\"\[ \t\]+\[#;/!|@\]+ +DW_AT_name" } }

+// { dg-final { scan-assembler "\"u\\\\0\"\[ \t\]+\[#;/!|@\]+ +DW_AT_name\[\r\n\]+\[\^\r\n\]+\[\r\n\]+\[\^\r\n\]+\[\r\n\]+\[\^#;/!|@\]+\[#;/!|@\]+ +DW_AT_decl_line\[\r\n\]+\[^#;/!|@\]+\[#;/!|@\]+ +DW_AT_declaration" } }

+// { dg-final { scan-assembler-not "\"f2\\\\0\"\[ \t\]+\[#;/!|@\]+ +DW_AT_name" } }

+// { dg-final { scan-assembler-not "\"nc\\\\0\"\[ \t\]+\# +DW_AT_name" } }

+# Copyright (C) 2005-2013 Free Software Foundation, Inc.

+# Copyright (C) 2000-2013 Free Software Foundation, Inc.

+# Copyright (C) 1997-2013 Free Software Foundation, Inc.

+# Copyright (C) 2006-2013 Free Software Foundation, Inc.

+# Copyright (C) 2009-2013 Free Software Foundation, Inc.

+// PR c++/55893

+// { dg-final { scan-assembler-not "rodata" } }

+

+struct foo

+{

+ virtual ~foo ();

+};

+

+int main ()

+{

+ static const foo tmp;

+}

+/* { dg-do compile } */

+/* { dg-options "-O3 -fdump-ipa-inline -fdump-ipa-cp" } */

+class wxPaintEvent { };

+struct wxDCBase

+{

+ wxDCBase ();

+ virtual int GetLayoutDirection() const{}

+ virtual void SetLayoutDirection(int){}

+};

+struct wxWindowDC : public wxDCBase {};

+struct wxBufferedDC : public wxDCBase

+{

+ void Init(wxDCBase*dc) {

+ InitCommon(dc);

+ }

+ void InitCommon(wxDCBase*dc) {

+ if (dc)

+ SetLayoutDirection(dc->GetLayoutDirection());

+ }

+};

+struct wxBufferedPaintDC : public wxBufferedDC {

+ wxBufferedPaintDC() {

+ Init(&m_paintdc);

+ }

+ wxWindowDC m_paintdc;

+};

+void OnPaint(wxPaintEvent & event) {

+ wxBufferedPaintDC dc;

+}

+/* IPA-CP should really discover both cases, but for time being the second is handled by inliner. */

+/* { dg-final { scan-ipa-dump-times "Discovered a virtual call to a known target" 1 "inline" } } */

+/* { dg-final { scan-ipa-dump-times "Discovered a virtual call to a known target" 1 "cp" } } */

+/* { dg-final { cleanup-ipa-dump "inline" } } */

+/* { dg-final { cleanup-ipa-dump "cp" } } */

+# Copyright (C) 2009-2013 Free Software Foundation, Inc.

+# Copyright (C) 1997-2013 Free Software Foundation, Inc.

+# Copyright (C) 2009-2013 Free Software Foundation, Inc.

+# Copyright (C) 2011-2013 Free Software Foundation, Inc.

+# Copyright (C) 1999-2013 Free Software Foundation, Inc.

+// PR c++/55878

+

+#include <typeinfo>

+

+struct S;

+

+template <typename T>

+static bool fn (S *s)

+{

+ return typeid (*s) == typeid (T);

+}

+

+struct S

+{

+};

+

+bool x = fn<S> (__null);

+// { dg-do run }

+// { dg-add-options tls }

+// PR c++/55801

+// { dg-options "-std=c++11" }

+// { dg-require-effective-target tls }

+

+class C;

+thread_local C O, O2 = O; // { dg-error "incomplete" }

+// { dg-add-options tls }

+// { dg-add-options tls }

+// { dg-do run }

+// { dg-add-options tls }

+// { dg-do run }

+// { dg-add-options tls }

+// { dg-add-options tls }

+// { dg-add-options tls }

+// { dg-add-options tls }

+// { dg-add-options tls }

+// { dg-add-options tls }

+// { dg-add-options tls }

+// { dg-do run }

+// { dg-add-options tls }

+// { dg-add-options tls }

+# Copyright (C) 2002-2013 Free Software Foundation, Inc.

+# Copyright (C) 2009-2013 Free Software Foundation, Inc.

+// { dg-do run }

+

+struct A

+{

+ short int a1;

+ unsigned char a2;

+ unsigned int a3;

+};

+

+struct B

+{

+ unsigned short b1;

+ const A *b2;

+};

+

+B b;

+

+__attribute__((noinline, noclone))

+int foo (unsigned x)

+{

+ __asm volatile ("" : "+r" (x) : : "memory");

+ return x;

+}

+

+inline void

+bar (const int &)

+{

+}

+

+__attribute__((noinline)) void

+baz ()

+{

+ const A *a = b.b2;

+ unsigned int i;

+ unsigned short n = b.b1;

+ for (i = 0; i < n; ++i)

+ if (a[i].a1 == 11)

+ {

+ if (i > 0 && (a[i - 1].a2 & 1))

+ continue;

+ bar (foo (2));

+ return;

+ }

+}

+

+int

+main ()

+{

+ A a[4] = { { 10, 0, 0 }, { 11, 1, 0 }, { 11, 1, 0 }, { 11, 1, 0 } };

+ b.b1 = 4;

+ b.b2 = a;

+ baz ();

+ return 0;

+}

+

+# Copyright (C) 2008-2013 Free Software Foundation, Inc.

+# Copyright (C) 2001-2013 Free Software Foundation, Inc.

+# Copyright (C) 2004-2013 Free Software Foundation, Inc.

+Copyright (C) 1997-2013 Free Software Foundation, Inc.

+Copyright (C) 1999-2005 Free Software Foundation, Inc.

+Copyright (C) 1998-2013 Free Software Foundation, Inc.

+# Copyright (C) 1988-2013 Free Software Foundation, Inc.

+Copyright (C) 1995-1997 Free Software Foundation, Inc.

+# Copyright (C) 1993-2013 Free Software Foundation, Inc.

+/* { dg-options "-O1 -ftree-vectorize" } */

+int *bar (void);

+

+void

+foo (void)

+{

+ long x;

+ int *y = bar ();

+ for (x = -1 / sizeof (int); x; --x, ++y)

+ *y = 0;

+}

+/* PR middle-end/55851 */

+

+enum { A = 1UL, B = -1UL } var = A;

+void foo (char *);

+

+void

+test (void)

+{

+ char vla[1][var];

+ vla[0][0] = 1;

+ foo (&vla[0][0]);

+}

+/* PR tree-optimization/55921 */

+

+typedef union

+{

+ _Complex float cf;

+ long long ll;

+} ucf;

+

+void

+foo (ucf *in, ucf *out, _Complex float r)

+{

+ int i;

+ ucf ucf1;

+ _Complex float cf;

+

+ ucf1.ll = in[i].ll;

+ __asm ("" : "=r" (cf) : "0" (ucf1.ll));

+ cf *= r;

+ __asm ("" : "=r" (ucf1.ll) : "0" (cf));

+ out[i].ll = ucf1.ll;

+}

+# Copyright (C) 2003-2013 Free Software Foundation, Inc.

+# Copyright (C) 1991-2013 Free Software Foundation, Inc.

+# Copyright (C) 1993-2013 Free Software Foundation, Inc.

+int a[250];

+__attribute__ ((noinline))

+t(int i)

+{

+ if (i==0)

+ exit(0);

+ if (i>255)

+ abort ();

+}

+main()

+{

+ unsigned int i;

+ for (i=0;;i++)

+ {

+ a[i]=t((unsigned char)(i+5));

+ }

+}

+# Copyright (C) 1993-2013 Free Software Foundation, Inc.

+Copyright (C) 1997-2013 Free Software Foundation, Inc.

+# Copyright (C) 2012-2013 Free Software Foundation, Inc.

+# Copyright (C) 2008-2013 Free Software Foundation, Inc.

+# Copyright (C) 2004-2013 Free Software Foundation, Inc.

+# Copyright (C) 2002-2013 Free Software Foundation, Inc.

+# Copyright (C) 2002-2013 Free Software Foundation, Inc.

+/* Copyright (C) 2000-2013 Free Software Foundation, Inc. */

+# Copyright (C) 1997-2013 Free Software Foundation, Inc.

+# Copyright (C) 1997-2013 Free Software Foundation, Inc.

+# Copyright (C) 2002-2013 Free Software Foundation, Inc.

+# Copyright (C) 2002-2013 Free Software Foundation, Inc.

+# Copyright (C) 2005-2013 Free Software Foundation, Inc.

+# Copyright (C) 1997-2013 Free Software Foundation, Inc.

+# Copyright (C) 1997-2013 Free Software Foundation, Inc.

+# Copyright (C) 1997-2013 Free Software Foundation, Inc.

+# Copyright (C) 2006-2013 Free Software Foundation, Inc.

+# Copyright (C) 2006-2013 Free Software Foundation, Inc.

+ arr[10] = 0;

+# Copyright (C) 1997-2013 Free Software Foundation, Inc.

+# Copyright (C) 2009-2013 Free Software Foundation, Inc.

+char s[sizeof (char *)];

+# Copyright (C) 1997-2013 Free Software Foundation, Inc.

+# Copyright (C) 1997-2013 Free Software Foundation, Inc.

+# Copyright (C) 2009-2013 Free Software Foundation, Inc.

+/* { dg-do compile } */

+/* { dg-options "-O2 -Wall" } */

+

+int a[2];

+int foo (int q)

+{

+ if (__builtin_constant_p (q))

+ {

+ if (q == 4)

+ return a[4]; /* { dg-bogus "array subscript is above array bounds" } */

+ else

+ return a[0];

+ }

+ else

+ return a[q];

+}

+/* PR tree-optimization/48189 */

+/* { dg-do compile } */

+/* { dg-options "-O --param max-predicted-iterations=0" } */

+

+struct S { int s[8]; };

+

+void

+foo (int *x, struct S *y)

+{

+ int i;

+ for (i = 0; y[i].s[i]; i++)

+ *x++ = y[i].s[i];

+}

+# Copyright (C) 2011-2013 Free Software Foundation, Inc.

+# Copyright (C) 2002-2013 Free Software Foundation, Inc.

+# Copyright (C) 2001-2013 Free Software Foundation, Inc.

+# Copyright (C) 2002-2013 Free Software Foundation, Inc.

+# Copyright (C) 2009-2013 Free Software Foundation, Inc.

+/* { dg-do compile } */

+

+typedef unsigned _GCC_ATTR_ALIGN_u32t;

+typedef _GCC_ATTR_ALIGN_u32t _Uint32t __attribute__ ((__aligned__ (4)));

+typedef unsigned int _GCC_ATTR_ALIGN_u8t __attribute__ ((__mode__ (__QI__)));

+typedef _GCC_ATTR_ALIGN_u8t _Uint8t __attribute__ ((__aligned__ (1)));

+typedef unsigned _Sizet;

+typedef _Sizet size_t;

+typedef _Uint8t uint8_t;

+typedef _Uint32t uint32_t;

+typedef enum

+{

+ PROTOBUF_C_LABEL_REQUIRED, PROTOBUF_C_LABEL_OPTIONAL,

+ PROTOBUF_C_LABEL_REPEATED

+}

+ProtobufCLabel;

+typedef enum

+{

+ PROTOBUF_C_TYPE_INT32, PROTOBUF_C_TYPE_SINT32, PROTOBUF_C_TYPE_SFIXED32,

+ PROTOBUF_C_TYPE_INT64, PROTOBUF_C_TYPE_SINT64, PROTOBUF_C_TYPE_SFIXED64,

+ PROTOBUF_C_TYPE_UINT32, PROTOBUF_C_TYPE_FIXED32, PROTOBUF_C_TYPE_UINT64,

+ PROTOBUF_C_TYPE_FIXED64, PROTOBUF_C_TYPE_FLOAT, PROTOBUF_C_TYPE_DOUBLE,

+ PROTOBUF_C_TYPE_BOOL, PROTOBUF_C_TYPE_ENUM, PROTOBUF_C_TYPE_STRING,

+ PROTOBUF_C_TYPE_BYTES, PROTOBUF_C_TYPE_MESSAGE,

+}

+ProtobufCType;

+typedef struct _ProtobufCBinaryData ProtobufCBinaryData;

+struct _ProtobufCBinaryData

+{

+ size_t len;

+};

+typedef struct _ProtobufCMessageDescriptor ProtobufCMessageDescriptor;

+typedef struct _ProtobufCFieldDescriptor ProtobufCFieldDescriptor;

+typedef struct _ProtobufCMessage ProtobufCMessage;

+struct _ProtobufCFieldDescriptor

+{

+ uint32_t id;

+ ProtobufCLabel label;

+ ProtobufCType type;

+ unsigned offset;

+};

+struct _ProtobufCMessageDescriptor

+{

+ unsigned n_fields;

+ const ProtobufCFieldDescriptor *fields;

+};

+struct _ProtobufCMessage

+{

+ const ProtobufCMessageDescriptor *descriptor;

+};

+typedef enum

+{

+ PROTOBUF_C_WIRE_TYPE_VARINT, PROTOBUF_C_WIRE_TYPE_64BIT,

+ PROTOBUF_C_WIRE_TYPE_LENGTH_PREFIXED, PROTOBUF_C_WIRE_TYPE_START_GROUP,

+ PROTOBUF_C_WIRE_TYPE_END_GROUP, PROTOBUF_C_WIRE_TYPE_32BIT

+}

+ProtobufCWireType;

+static inline size_t

+uint32_pack (uint32_t value, uint8_t * out)

+{

+ unsigned rv = 0;

+ if (value >= 0x80)

+ {

+ if (value >= 0x80)

+ {

+ value >>= 7;

+ }

+ }

+ out[rv++] = value;

+}

+

+static inline size_t

+binary_data_pack (const ProtobufCBinaryData * bd, uint8_t * out)

+{

+ size_t len = bd->len;

+ size_t rv = uint32_pack (len, out);

+ return rv + len;

+}

+

+static size_t

+required_field_pack (const ProtobufCFieldDescriptor * field,

+ const void *member, uint8_t * out)

+{

+ size_t rv = tag_pack (field->id, out);

+ switch (field->type)

+ {

+ case PROTOBUF_C_TYPE_BYTES:

+ {

+ const ProtobufCBinaryData *bd =

+ ((const ProtobufCBinaryData *) member);

+ out[0] |= PROTOBUF_C_WIRE_TYPE_LENGTH_PREFIXED;

+ return rv + binary_data_pack (bd, out + rv);

+ }

+ case PROTOBUF_C_TYPE_MESSAGE:

+ {

+ out[0] |= PROTOBUF_C_WIRE_TYPE_LENGTH_PREFIXED;

+ return rv +

+ prefixed_message_pack (*(ProtobufCMessage * const *) member,

+ out + rv);

+ }

+ }

+}

+

+size_t

+protobuf_c_message_pack (const ProtobufCMessage * message, uint8_t * out)

+{

+ unsigned i;

+ size_t rv = 0;

+ for (i = 0; i < message->descriptor->n_fields; i++)

+ {

+ const ProtobufCFieldDescriptor *field = message->descriptor->fields + i;

+ const void *member = ((const char *) message) + field->offset;

+ if (field->label == PROTOBUF_C_LABEL_REQUIRED)

+ rv += required_field_pack (field, member, out + rv);

+ }

+}

+/* { dg-do compile } */

+

+extern void *memmove(void *, void *, __SIZE_TYPE__);

+typedef int (*_TEST_fun_) ();

+static _TEST_fun_ i = (_TEST_fun_) memmove;

+main() { i(); }

+/* { dg-do compile } */

+

+extern void *memcpy();

+main() { memcpy(); }

+/* { dg-do compile } */

+

+void *memmove ();

+

+void *

+bar ()

+{

+ return memmove ();

+}

+# Copyright (C) 2008-2013 Free Software Foundation, Inc.

+# Copyright (C) 2010-2013 Free Software Foundation, Inc.

+# Copyright (C) 2001-2013 Free Software Foundation, Inc.

+/* { dg-do compile } */

+/* { dg-options "-O2 -g -fdump-tree-esra" } */

+

+struct S { int a; char b; char c; short d; };

+

+int

+foo (int x)

+{

+ struct S s = { x + 1, x + 2, x + 3, x + 4 };

+ char *p = &s.c;

+ return x;

+}

+

+/* { dg-final { scan-tree-dump "Created a debug-only replacement for s" "esra" } } */

+# Copyright (C) 1997-2013 Free Software Foundation, Inc.

+/* { dg-final { scan-tree-dump-times "Folding predicate i_\[0-9\]+.*0 to 0" 1 "vrp1" } } */

+/* { dg-final { scan-tree-dump-times "Folding predicate j_\[0-9\]+.*0 to 1" 1 "vrp1" } } */

+/* { dg-final { scan-tree-dump-times "Folding predicate i_\[0-9]+.*j_\[0-9\]+.* to 0" 1 "vrp1" { xfail *-*-* } } } */

+# Copyright (C) 1997-2013 Free Software Foundation, Inc.

+# Copyright (C) 1997-2013 Free Software Foundation, Inc.

+# Copyright (C) 1997-2013 Free Software Foundation, Inc.

+# Copyright (C) 1997-2013 Free Software Foundation, Inc.

+# Copyright (C) 1997-2013 Free Software Foundation, Inc.

+# Copyright (C) 2004-2013 Free Software Foundation, Inc.

+# Copyright (C) 1997-2013 Free Software Foundation, Inc.

+# Copyright (C) 1997-2013 Free Software Foundation, Inc.

+# Copyright (C) 1997-2013 Free Software Foundation, Inc.

+# Copyright (C) 2001-2013 Free Software Foundation, Inc.

+# Copyright (C) 2001-2013 Free Software Foundation, Inc.

+# Copyright (C) 2005-2013 Free Software Foundation, Inc.

+# Copyright (C) 1997-2013 Free Software Foundation, Inc.

+# Copyright (C) 1997-2013 Free Software Foundation, Inc.

+# Copyright (C) 2005-2013 Free Software Foundation, Inc.

+# Copyright (C) 2002-2013 Free Software Foundation, Inc.

+# Copyright (C) 1988-2013 Free Software Foundation, Inc.

+# Copyright (C) 1997-2013 Free Software Foundation, Inc.

+# Copyright (C) 2005-2013 Free Software Foundation, Inc.

+# Copyright (C) 1997-2013 Free Software Foundation, Inc.

+# Copyright (C) 2005-2013 Free Software Foundation, Inc.

+# Copyright (C) 1997-2013 Free Software Foundation, Inc.

+# Copyright (C) 1997-2013 Free Software Foundation, Inc.

+# Copyright (C) 2009-2013 Free Software Foundation, Inc.

+# Copyright (C) 2009-2013 Free Software Foundation, Inc.

+/* { dg-do compile } */

+/* { dg-options "-O2" } */

+

+void

+foo (double *output)

+{

+ *output = 0.0;

+}

+

+/* { dg-final { scan-assembler "fmov\\td\[0-9\]+, xzr" } } */

+/* { dg-do compile } */

+/* { dg-options "-O2" } */

+

+void

+foo (double *output)

+{

+ *output = 4.25;

+}

+

+/* { dg-final { scan-assembler "fmov\\td\[0-9\]+, 4\\.25" } } */

+/* { dg-do compile } */

+/* { dg-options "-O2" } */

+

+void

+foo (float *output)

+{

+ *output = 0.0;

+}

+

+/* { dg-final { scan-assembler "fmov\\ts\[0-9\]+, wzr" } } */

+/* { dg-do compile } */

+/* { dg-options "-O2" } */

+

+void

+foo (float *output)

+{

+ *output = 4.25;

+}

+

+/* { dg-final { scan-assembler "fmov\\ts\[0-9\]+, 4\\.25" } } */

+/* { dg-do run } */

+/* { dg-options "-O2 -ftree-vectorize -fdump-tree-vect-all -fno-unroll-loops --save-temps -fno-inline" } */

+

+#define FTYPE double

+#define OP ==

+#define INV_OP !=

+

+#include "vect-fcm.x"

+

+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 3 "vect" } } */

+/* { dg-final { scan-assembler-times "fcmeq\\tv\[0-9\]+\.2d, v\[0-9\]+\.2d, v\[0-9\]+\.2d" 2 } } */

+/* { dg-final { scan-assembler-times "fcmeq\\tv\[0-9\]+\.2d, v\[0-9\]+\.2d, 0" 1 } } */

+/* { dg-final { cleanup-tree-dump "vect" } } */

+/* { dg-final { cleanup-saved-temps } } */

+/* { dg-do run } */

+/* { dg-options "-O2 -ftree-vectorize -fdump-tree-vect-all -fno-unroll-loops --save-temps -fno-inline" } */

+

+#define FTYPE float

+#define OP ==

+#define INV_OP !=

+

+#include "vect-fcm.x"

+

+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 3 "vect" } } */

+/* { dg-final { scan-assembler-times "fcmeq\\tv\[0-9\]+\.\[24\]s, v\[0-9\]+\.\[24\]s, v\[0-9\]+\.\[24\]s" 2 } } */

+/* { dg-final { scan-assembler-times "fcmeq\\tv\[0-9\]+\.\[24\]s, v\[0-9\]+\.\[24\]s, 0" 1 } } */

+/* { dg-final { cleanup-tree-dump "vect" } } */

+/* { dg-final { cleanup-saved-temps } } */

+/* { dg-do run } */

+/* { dg-options "-O2 -ftree-vectorize -fdump-tree-vect-all -fno-unroll-loops --save-temps -fno-inline" } */

+

+#define FTYPE double

+#define OP >=

+#define INV_OP <

+

+#include "vect-fcm.x"

+

+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 3 "vect" } } */

+/* { dg-final { scan-assembler-times "fcmge\\tv\[0-9\]+\.2d, v\[0-9\]+\.2d, v\[0-9\]+\.2d" 2 } } */

+/* { dg-final { scan-assembler-times "fcmge\\tv\[0-9\]+\.2d, v\[0-9\]+\.2d, 0" 1 } } */

+/* { dg-final { cleanup-tree-dump "vect" } } */

+/* { dg-final { cleanup-saved-temps } } */

+/* { dg-do run } */

+/* { dg-options "-O2 -ftree-vectorize -fdump-tree-vect-all -fno-unroll-loops --save-temps -fno-inline" } */

+

+#define FTYPE float

+#define OP >=

+#define INV_OP <

+

+#include "vect-fcm.x"

+

+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 3 "vect" } } */

+/* { dg-final { scan-assembler-times "fcmge\\tv\[0-9\]+\.\[24\]s, v\[0-9\]+\.\[24\]s, v\[0-9\]+\.\[24\]s" 2 } } */

+/* { dg-final { scan-assembler-times "fcmge\\tv\[0-9\]+\.\[24\]s, v\[0-9\]+\.\[24\]s, 0" 1 } } */

+/* { dg-final { cleanup-tree-dump "vect" } } */

+/* { dg-final { cleanup-saved-temps } } */

+/* { dg-do run } */

+/* { dg-options "-O2 -ftree-vectorize -fdump-tree-vect-all -fno-unroll-loops --save-temps -fno-inline" } */

+

+#define FTYPE double

+#define OP >

+#define INV_OP <=

+

+#include "vect-fcm.x"

+

+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 3 "vect" } } */

+/* { dg-final { scan-assembler-times "fcmgt\\tv\[0-9\]+\.2d, v\[0-9\]+\.2d, v\[0-9\]+\.2d" 2 } } */

+/* { dg-final { scan-assembler-times "fcmgt\\tv\[0-9\]+\.2d, v\[0-9\]+\.2d, 0" 1 } } */

+/* { dg-final { cleanup-tree-dump "vect" } } */

+/* { dg-final { cleanup-saved-temps } } */

+/* { dg-do run } */

+/* { dg-options "-O2 -ftree-vectorize -fdump-tree-vect-all -fno-unroll-loops --save-temps -fno-inline" } */

+

+#define FTYPE float

+#define OP >

+#define INV_OP <=

+

+#include "vect-fcm.x"

+

+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 3 "vect" } } */

+/* { dg-final { scan-assembler-times "fcmgt\\tv\[0-9\]+\.\[24\]s, v\[0-9\]+\.\[24\]s, v\[0-9\]+\.\[24\]s" 2 } } */

+/* { dg-final { scan-assembler-times "fcmgt\\tv\[0-9\]+\.\[24\]s, v\[0-9\]+\.\[24\]s, 0" 1 } } */

+/* { dg-final { cleanup-tree-dump "vect" } } */

+/* { dg-final { cleanup-saved-temps } } */

+#include <stdlib.h>

+#define N 16

+

+FTYPE input1[N] =

+{2.0, 4.0, 8.0, 16.0,

+ 2.125, 4.25, 8.5, 17.0,

+ -2.0, -4.0, -8.0, -16.0,

+ -2.125, -4.25, -8.5, -17.0};

+

+FTYPE input2[N] =

+{-2.0, 4.0, -8.0, 16.0,

+ 2.125, -4.25, 8.5, -17.0,

+ 2.0, -4.0, 8.0, -16.0,

+ -2.125, 4.25, -8.5, 17.0};

+

+void

+foo (FTYPE *in1, FTYPE *in2, FTYPE *output)

+{

+ int i = 0;

+ /* Vectorizable. */

+ for (i = 0; i < N; i++)

+ output[i] = (in1[i] OP in2[i]) ? 2.0 : 4.0;

+}

+

+void

+bar (FTYPE *in1, FTYPE *in2, FTYPE *output)

+{

+ int i = 0;

+ /* Vectorizable. */

+ for (i = 0; i < N; i++)

+ output[i] = (in1[i] INV_OP in2[i]) ? 4.0 : 2.0;

+}

+

+void

+foobar (FTYPE *in1, FTYPE *in2, FTYPE *output)

+{

+ int i = 0;

+ /* Vectorizable. */

+ for (i = 0; i < N; i++)

+ output[i] = (in1[i] OP 0.0) ? 4.0 : 2.0;

+}

+

+int

+main (int argc, char **argv)

+{

+ FTYPE out1[N];

+ FTYPE out2[N];

+ int i = 0;

+ foo (input1, input2, out1);

+ bar (input1, input2, out2);

+ for (i = 0; i < N; i++)

+ if (out1[i] != out2[i])

+ abort ();

+ return 0;

+}

+

+/* { dg-do compile } */

+/* { dg-options "-O2 -ftree-vectorize -fdump-tree-vect-all" } */

+

+#define N 32

+

+void

+foo (double *output)

+{

+ int i = 0;

+ /* Vectorizable. */

+ for (i = 0; i < N; i++)

+ output[i] = 0.0;

+}

+

+/* { dg-final { scan-assembler "movi\\tv\[0-9\]+\\.2d, 0" } } */

+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */

+/* { dg-final { cleanup-tree-dump "vect" } } */

+/* { dg-do compile } */

+/* { dg-options "-O2 -ftree-vectorize -fdump-tree-vect-all" } */

+

+#define N 32

+

+void

+foo (double *output)

+{

+ int i = 0;

+ /* Vectorizable. */

+ for (i = 0; i < N; i++)

+ output[i] = 4.25;

+}

+

+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */

+/* { dg-final { scan-assembler "fmov\\tv\[0-9\]+\\.2d, 4\\.25" } } */

+/* { dg-final { cleanup-tree-dump "vect" } } */

+/* { dg-do compile } */

+/* { dg-options "-O2 -ftree-vectorize -fdump-tree-vect-all" } */

+

+#define N 32

+

+void

+foo (float *output)

+{

+ int i = 0;

+ /* Vectorizable. */

+ for (i = 0; i < N; i++)

+ output[i] = 0.0;

+}

+

+/* { dg-final { scan-assembler "movi\\tv\[0-9\]+\\.\[24\]s, 0" } } */

+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */

+/* { dg-final { cleanup-tree-dump "vect" } } */

+/* { dg-do compile } */

+/* { dg-options "-O2 -ftree-vectorize -fdump-tree-vect-all" } */

+

+#define N 32

+

+void

+foo (float *output)

+{

+ int i = 0;

+ /* Vectorizable. */

+ for (i = 0; i < N; i++)

+ output[i] = 4.25;

+}

+

+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */

+/* { dg-final { scan-assembler "fmov\\tv\[0-9\]+\\.\[24\]s, 4\\.25" } } */

+/* { dg-final { cleanup-tree-dump "vect" } } */

+/* { dg-final { scan-assembler "smull\\tv\[0-9\]+\.8h"} } */

+/* { dg-final { scan-assembler "smull\\tv\[0-9\]+\.4s"} } */

+/* { dg-final { scan-assembler "smull\\tv\[0-9\]+\.2d"} } */

+/* { dg-final { scan-assembler "umull\\tv\[0-9\]+\.8h"} } */

+/* { dg-final { scan-assembler "umull\\tv\[0-9\]+\.4s"} } */

+/* { dg-final { scan-assembler "umull\\tv\[0-9\]+\.2d"} } */

+/* { dg-final { scan-assembler "smull2\\tv\[0-9\]+\.8h"} } */

+/* { dg-final { scan-assembler "smull2\\tv\[0-9\]+\.4s"} } */

+/* { dg-final { scan-assembler "smull2\\tv\[0-9\]+\.2d"} } */

+/* { dg-final { scan-assembler "umull2\\tv\[0-9\]+\.8h"} } */

+/* { dg-final { scan-assembler "umull2\\tv\[0-9\]+\.4s"} } */

+/* { dg-final { scan-assembler "umull2\\tv\[0-9\]+\.2d"} } */

+ const float32_t pool[] = {4.0f, 9.0f};

+ float32x2_t val;

+ val = vld1_f32 (pool);

+ const float32_t pool[] = {4.0f, 9.0f, 16.0f, 25.0f};

+ float32x4_t val;

+ val = vld1q_f32 (pool);

+ const float64_t pool[] = {4.0, 9.0};

+ float64x2_t val;

+ val = vld1q_f64 (pool);

+# Copyright (C) 2005-2013 Free Software Foundation, Inc.

+# Copyright (C) 1997-2013 Free Software Foundation, Inc.

+# Copyright (C) 1997-2013 Free Software Foundation, Inc.

+# Copyright (C) 1997-2013 Free Software Foundation, Inc.

+# Copyright (C) 2008-2013 Free Software Foundation, Inc.

+# Copyright (C) 2008-2013 Free Software Foundation, Inc.

+# Copyright (C) 2007-2013 Free Software Foundation, Inc.

+# Copyright (C) 2009-2013 Free Software Foundation, Inc.

+# Copyright (C) 2005-2013 Free Software Foundation, Inc.

+# Copyright (C) 2005-2013 Free Software Foundation, Inc.

+# Copyright (C) 2007-2013 Free Software Foundation, Inc.

+# Copyright (C) 2004-2013 Free Software Foundation, Inc.

+# Copyright (C) 1997-2013 Free Software Foundation, Inc.

+# Copyright (C) 2006-2013 Free Software Foundation, Inc.

+/* { dg-do compile } */

+/* { dg-options "-O -fstack-check=generic" } */

+

+int main ()

+{

+ int x[8];

+ if (x[0] != 4)

+ __builtin_abort ();

+ return 0;

+}

+/* { dg-do compile } */

+/* { dg-options "-O2 -msse3 -fno-expensive-optimizations" } */

+

+typedef double __m128d __attribute__ ((__vector_size__ (16)));

+

+extern double p1[];

+extern double p2[];

+extern double ck[];

+extern int n;

+

+__attribute__((__noinline__, __noclone__)) int chk_pd (double *v1, double *v2)

+{

+ return v2[n] != v1[n];

+}

+

+static inline void sse3_test_movddup_reg_subsume_ldsd (double *i1, double *r)

+{

+ __m128d t1 = (__m128d){*i1, 0};

+ __m128d t2 = __builtin_ia32_shufpd (t1, t1, 0);

+ __builtin_ia32_storeupd (r, t2);

+}

+

+int sse3_test (void)

+{

+ int i = 0;

+ int fail = 0;

+ for (; i < 80; i += 1)

+ {

+ ck[0] = p1[0];

+ fail += chk_pd (ck, p2);

+ sse3_test_movddup_reg_subsume_ldsd (p1, p2);

+ }

+ return fail;

+}

+/* { dg-do run } */

+/* { dg-require-effective-target avx } */

+/* { dg-options "-O3 -ffast-math -fschedule-insns -mavx -mvzeroupper" } */

+

+#include "avx-check.h"

+

+#define N 100

+

+double

+__attribute__((noinline))

+foo (int size, double *y, double *x)

+{

+ double sum = 0.0;

+ int i;

+

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

+ sum += y[i] * x[i];

+

+ return sum;

+}

+

+static void

+__attribute__ ((noinline))

+avx_test ()

+{

+ double x[N], y[N];

+ double s;

+ int i;

+

+ for (i = 0; i < N; i++)

+ {

+ x[i] = i;

+ y[i] = i;

+ }

+

+ s = foo (N, y, x);

+

+ if (s != 328350.0)

+ abort ();

+}

+# Copyright (C) 2008-2013 Free Software Foundation, Inc.

+# Copyright (C) 1997-2013 Free Software Foundation, Inc.

+# Copyright (C) 1997-2013 Free Software Foundation, Inc.

+# Copyright (C) 2009-2013 Free Software Foundation, Inc.

+# Copyright (C) 2007-2013 Free Software Foundation, Inc.

+Copyright (C) 2008-2013 Free Software Foundation, Inc.

+# Copyright (C) 2008-2013 Free Software Foundation, Inc.

+# Copyright (C) 1997-2013 Free Software Foundation, Inc.

+# Copyright (C) 2005-2013 Free Software Foundation, Inc.

+/* { dg-final { scan-assembler-not "lfd \(f?\[0-9\]+\),\[^\n\r\]*\[\n\r\]+\[ \t]*fmr f?1,\\1\[\n\r\]+\[ \t]*blr" } } */