From 09dd802b33d1fc82a9234a83dc80ec8a5c6154a6 Mon Sep 17 00:00:00 2001 From: gfunck Date: Fri, 6 May 2011 18:02:08 +0000 Subject: [PATCH] 2011-05-06 Gary Funck Add files left out in previous merge of trunk version 173471. git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/branches/gupc@173498 138bc75d-0d04-0410-961f-82ee72b054a4 --- gcc/c-typeck.c | 5 +- gcc/gimplify.c | 9 +- gcc/testsuite/c-c++-common/raw-string-11.c | 13 +++ gcc/testsuite/g++.dg/cpp0x/initlist48.C | 11 +++ gcc/testsuite/g++.dg/cpp0x/initlist49.C | 18 ++++ .../g++.dg/cpp0x/regress/template-const2.C | 14 +++ gcc/testsuite/g++.dg/cpp0x/sfinae17.C | 31 +++++++ gcc/testsuite/g++.dg/cpp0x/sfinae18.C | 17 ++++ gcc/testsuite/g++.dg/ext/complex8.C | 67 +++++++++++++++ gcc/testsuite/g++.dg/ext/is_literal_type1.C | 11 +++ gcc/testsuite/g++.dg/ext/underlying_type1.C | 18 ++++ gcc/testsuite/g++.dg/ext/underlying_type10.C | 32 +++++++ gcc/testsuite/g++.dg/ext/underlying_type2.C | 9 ++ gcc/testsuite/g++.dg/ext/underlying_type3.C | 33 ++++++++ gcc/testsuite/g++.dg/ext/underlying_type4.C | 25 ++++++ gcc/testsuite/g++.dg/ext/underlying_type5.C | 43 ++++++++++ gcc/testsuite/g++.dg/ext/underlying_type6.C | 31 +++++++ gcc/testsuite/g++.dg/ext/underlying_type7.C | 24 ++++++ gcc/testsuite/g++.dg/ext/underlying_type8.C | 46 ++++++++++ gcc/testsuite/g++.dg/ext/underlying_type9.C | 30 +++++++ gcc/testsuite/g++.dg/inherit/pr48798.C | 4 + gcc/testsuite/g++.dg/init/ctor10.C | 9 ++ gcc/testsuite/g++.dg/init/new30.C | 15 ++++ gcc/testsuite/g++.dg/lookup/koenig13.C | 16 ++++ gcc/testsuite/g++.dg/parse/ambig6.C | 12 +++ gcc/testsuite/g++.dg/pr48772.C | 35 ++++++++ gcc/testsuite/g++.dg/prof-robust-1.C | 24 ++++++ gcc/testsuite/g++.dg/template/inherit7.C | 21 +++++ gcc/testsuite/g++.dg/warn/Wnull-conversion-1.C | 15 ++++ gcc/testsuite/g++.dg/warn/Wnull-conversion-2.C | 45 ++++++++++ gcc/testsuite/gcc.c-torture/compile/pr48734.c | 11 +++ gcc/testsuite/gcc.c-torture/compile/pr48742.c | 15 ++++ gcc/testsuite/gcc.c-torture/compile/pr48767.c | 7 ++ gcc/testsuite/gcc.c-torture/execute/pr48809.c | 60 +++++++++++++ gcc/testsuite/gcc.dg/pr15347.c | 10 +++ gcc/testsuite/gcc.dg/pr48685.c | 11 +++ gcc/testsuite/gcc.dg/pr48768.c | 38 +++++++++ gcc/testsuite/gcc.dg/torture/pr48694-1.c | 14 +++ gcc/testsuite/gcc.dg/torture/pr48694-2.c | 20 +++++ gcc/testsuite/gcc.dg/torture/pr48731.c | 24 ++++++ gcc/testsuite/gcc.dg/tree-prof/prof-robust-1.c | 25 ++++++ gcc/testsuite/gcc.dg/tree-ssa/alias_bug.c | 61 +++++++++++++ gcc/testsuite/gcc.dg/tree-ssa/inline-10.c | 38 +++++++++ gcc/testsuite/gcc.dg/tree-ssa/inline-9.c | 24 ++++++ gcc/testsuite/gcc.dg/tree-ssa/integer-addr.c | 29 +++++++ gcc/testsuite/gcc.dg/tree-ssa/ssa-dom-thread-4.c | 63 ++++++++++++++ gcc/testsuite/gcc.dg/tree-ssa/vrp56.c | 42 +++++++++ gcc/testsuite/gcc.dg/tree-ssa/vrp57.c | 17 ++++ gcc/testsuite/gcc.dg/uninit-suppress.c | 16 ++++ gcc/testsuite/gcc.dg/uninit-suppress_2.c | 16 ++++ gcc/testsuite/gcc.dg/vect/pr48765.c | 82 ++++++++++++++++++ gcc/testsuite/gcc.target/powerpc/pr48258-1.c | 57 +++++++++++++ gcc/testsuite/gcc.target/powerpc/pr48258-2.c | 58 +++++++++++++ gcc/testsuite/gfortran.dg/coarray_19.f90 | 27 ++++++ gcc/testsuite/gfortran.dg/import9.f90 | 30 +++++++ gcc/testsuite/gfortran.dg/interface_35.f90 | 79 +++++++++++++++++ gcc/testsuite/gfortran.dg/interface_36.f90 | 28 ++++++ gcc/testsuite/gfortran.dg/round_3.f08 | 99 ++++++++++++++++++++++ gcc/testsuite/gfortran.dg/typebound_proc_22.f90 | 49 +++++++++++ gcc/testsuite/gfortran.dg/whole_file_34.f90 | 12 +++ libgo/go/syslog/syslog_libc.go | 37 ++++++++ libgo/syscalls/socket_irix.go | 84 ++++++++++++++++++ .../testsuite/26_numerics/complex/cons/48760.cc | 56 ++++++++++++ .../26_numerics/complex/cons/48760_c++0x.cc | 58 +++++++++++++ 64 files changed, 1969 insertions(+), 11 deletions(-) create mode 100644 gcc/testsuite/c-c++-common/raw-string-11.c create mode 100644 gcc/testsuite/g++.dg/cpp0x/initlist48.C create mode 100644 gcc/testsuite/g++.dg/cpp0x/initlist49.C create mode 100644 gcc/testsuite/g++.dg/cpp0x/regress/template-const2.C create mode 100644 gcc/testsuite/g++.dg/cpp0x/sfinae17.C create mode 100644 gcc/testsuite/g++.dg/cpp0x/sfinae18.C create mode 100644 gcc/testsuite/g++.dg/ext/complex8.C create mode 100644 gcc/testsuite/g++.dg/ext/is_literal_type1.C create mode 100644 gcc/testsuite/g++.dg/ext/underlying_type1.C create mode 100644 gcc/testsuite/g++.dg/ext/underlying_type10.C create mode 100644 gcc/testsuite/g++.dg/ext/underlying_type2.C create mode 100644 gcc/testsuite/g++.dg/ext/underlying_type3.C create mode 100644 gcc/testsuite/g++.dg/ext/underlying_type4.C create mode 100644 gcc/testsuite/g++.dg/ext/underlying_type5.C create mode 100644 gcc/testsuite/g++.dg/ext/underlying_type6.C create mode 100644 gcc/testsuite/g++.dg/ext/underlying_type7.C create mode 100644 gcc/testsuite/g++.dg/ext/underlying_type8.C create mode 100644 gcc/testsuite/g++.dg/ext/underlying_type9.C create mode 100644 gcc/testsuite/g++.dg/inherit/pr48798.C create mode 100644 gcc/testsuite/g++.dg/init/ctor10.C create mode 100644 gcc/testsuite/g++.dg/init/new30.C create mode 100644 gcc/testsuite/g++.dg/lookup/koenig13.C create mode 100644 gcc/testsuite/g++.dg/parse/ambig6.C create mode 100644 gcc/testsuite/g++.dg/pr48772.C create mode 100644 gcc/testsuite/g++.dg/prof-robust-1.C create mode 100644 gcc/testsuite/g++.dg/template/inherit7.C create mode 100644 gcc/testsuite/g++.dg/warn/Wnull-conversion-1.C create mode 100644 gcc/testsuite/g++.dg/warn/Wnull-conversion-2.C create mode 100644 gcc/testsuite/gcc.c-torture/compile/pr48734.c create mode 100644 gcc/testsuite/gcc.c-torture/compile/pr48742.c create mode 100644 gcc/testsuite/gcc.c-torture/compile/pr48767.c create mode 100644 gcc/testsuite/gcc.c-torture/execute/pr48809.c create mode 100644 gcc/testsuite/gcc.dg/pr15347.c create mode 100644 gcc/testsuite/gcc.dg/pr48685.c create mode 100644 gcc/testsuite/gcc.dg/pr48768.c create mode 100644 gcc/testsuite/gcc.dg/torture/pr48694-1.c create mode 100644 gcc/testsuite/gcc.dg/torture/pr48694-2.c create mode 100644 gcc/testsuite/gcc.dg/torture/pr48731.c create mode 100644 gcc/testsuite/gcc.dg/tree-prof/prof-robust-1.c create mode 100644 gcc/testsuite/gcc.dg/tree-ssa/alias_bug.c create mode 100644 gcc/testsuite/gcc.dg/tree-ssa/inline-10.c create mode 100644 gcc/testsuite/gcc.dg/tree-ssa/inline-9.c create mode 100644 gcc/testsuite/gcc.dg/tree-ssa/integer-addr.c create mode 100644 gcc/testsuite/gcc.dg/tree-ssa/ssa-dom-thread-4.c create mode 100644 gcc/testsuite/gcc.dg/tree-ssa/vrp56.c create mode 100644 gcc/testsuite/gcc.dg/tree-ssa/vrp57.c create mode 100644 gcc/testsuite/gcc.dg/uninit-suppress.c create mode 100644 gcc/testsuite/gcc.dg/uninit-suppress_2.c create mode 100644 gcc/testsuite/gcc.dg/vect/pr48765.c create mode 100644 gcc/testsuite/gcc.target/powerpc/pr48258-1.c create mode 100644 gcc/testsuite/gcc.target/powerpc/pr48258-2.c create mode 100644 gcc/testsuite/gfortran.dg/coarray_19.f90 create mode 100644 gcc/testsuite/gfortran.dg/import9.f90 create mode 100644 gcc/testsuite/gfortran.dg/interface_35.f90 create mode 100644 gcc/testsuite/gfortran.dg/interface_36.f90 create mode 100644 gcc/testsuite/gfortran.dg/round_3.f08 create mode 100644 gcc/testsuite/gfortran.dg/typebound_proc_22.f90 create mode 100644 gcc/testsuite/gfortran.dg/whole_file_34.f90 create mode 100644 libgo/go/syslog/syslog_libc.go create mode 100644 libgo/syscalls/socket_irix.go create mode 100644 libstdc++-v3/testsuite/26_numerics/complex/cons/48760.cc create mode 100644 libstdc++-v3/testsuite/26_numerics/complex/cons/48760_c++0x.cc diff --git a/gcc/c-typeck.c b/gcc/c-typeck.c index 0dec172a7e1..2eef0ba02d5 100644 --- a/gcc/c-typeck.c +++ b/gcc/c-typeck.c @@ -3883,10 +3883,7 @@ build_unary_op (location_t location, /* If the lvalue is const or volatile, merge that into the type to which the address will point. This is only needed - for function types. - - By checking for all tree qualifiers, we also handle the UPC - defined qualifiers (`shared', `strict', `relaxed') here. */ + for function types. */ if ((DECL_P (arg) || REFERENCE_CLASS_P (arg)) && (TREE_READONLY (arg) || TREE_THIS_VOLATILE (arg)) && TREE_CODE (argtype) == FUNCTION_TYPE) diff --git a/gcc/gimplify.c b/gcc/gimplify.c index 22a70dd7e68..812fc1f2524 100644 --- a/gcc/gimplify.c +++ b/gcc/gimplify.c @@ -428,14 +428,9 @@ create_tmp_var_raw (tree type, const char *prefix) { tree tmp_var; - /* Make the type of the variable writable. */ - int type_quals = TYPE_QUALS (type) - & ~(TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE); - /* Temps. cannot be UPC shared values. */ + /* Temps. cannot be UPC shared qualified. */ if (upc_shared_type_p (type)) - type_quals &= ~(TYPE_QUAL_SHARED | TYPE_QUAL_RELAXED | TYPE_QUAL_STRICT); - - type = build_qualified_type (type, type_quals); + type = upc_get_unshared_type (type); tmp_var = build_decl (input_location, VAR_DECL, prefix ? create_tmp_var_name (prefix) : NULL, diff --git a/gcc/testsuite/c-c++-common/raw-string-11.c b/gcc/testsuite/c-c++-common/raw-string-11.c new file mode 100644 index 00000000000..49ceba225b3 --- /dev/null +++ b/gcc/testsuite/c-c++-common/raw-string-11.c @@ -0,0 +1,13 @@ +// PR preprocessor/48740 +// { dg-options "-std=gnu99 -trigraphs -save-temps" { target c } } +// { dg-options "-std=c++0x -save-temps" { target c++ } } +// { dg-do run } + +int main () +{ + return __builtin_memcmp (R"raw(foo%sbar%sfred%sbob?????)raw", + "foo%sbar%sfred%sbob?""?""?""?""?", + sizeof ("foo%sbar%sfred%sbob?""?""?""?""?")); +} + +// { dg-final { cleanup-saved-temps } } diff --git a/gcc/testsuite/g++.dg/cpp0x/initlist48.C b/gcc/testsuite/g++.dg/cpp0x/initlist48.C new file mode 100644 index 00000000000..9eb451a8277 --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp0x/initlist48.C @@ -0,0 +1,11 @@ +// PR c++/48726 +// { dg-options -std=c++0x } + +#include + +struct Foo{ + int i; +}; +typedef std::unique_ptr up; + +std::initializer_list il{up{new Foo}, up{new Foo}}; diff --git a/gcc/testsuite/g++.dg/cpp0x/initlist49.C b/gcc/testsuite/g++.dg/cpp0x/initlist49.C new file mode 100644 index 00000000000..752c4331afb --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp0x/initlist49.C @@ -0,0 +1,18 @@ +// Test for non-trivial list-initialization with array new. +// { dg-options -std=c++0x } +// { dg-do run } + +struct A +{ + enum E { c_string, number } e; + A(const char *): e(c_string) {} + A(int): e(number) {} +}; + +int main() +{ + A* ap = new A[2]{1, ""}; + if (ap[0].e != A::number || ap[1].e != A::c_string) + return 1; + delete[] ap; +} diff --git a/gcc/testsuite/g++.dg/cpp0x/regress/template-const2.C b/gcc/testsuite/g++.dg/cpp0x/regress/template-const2.C new file mode 100644 index 00000000000..25354b3a54a --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp0x/regress/template-const2.C @@ -0,0 +1,14 @@ +// PR c++/48707 +// { dg-options -std=c++0x } + +struct A { + static int a(); +}; + +template +struct B: A { + static int const b; +}; + +template +int const B::b=B::a(); diff --git a/gcc/testsuite/g++.dg/cpp0x/sfinae17.C b/gcc/testsuite/g++.dg/cpp0x/sfinae17.C new file mode 100644 index 00000000000..dbbd9efe410 --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp0x/sfinae17.C @@ -0,0 +1,31 @@ +// PR c++/48530 +// { dg-options -std=c++0x } + +template +char f(int); + +template +char (&f(...))[2]; + +struct DelDtor { + ~DelDtor() = delete; +}; + +static_assert(sizeof(f(0)) != 1, "Error"); + +struct A +{ + static DelDtor *p; +}; + +template +char g(int); + +template +char (&g(...))[2]; + +static_assert(sizeof(g(0)) != 1, "Error"); diff --git a/gcc/testsuite/g++.dg/cpp0x/sfinae18.C b/gcc/testsuite/g++.dg/cpp0x/sfinae18.C new file mode 100644 index 00000000000..bb54335e6cc --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp0x/sfinae18.C @@ -0,0 +1,17 @@ +// PR c++/48530 +// { dg-options -std=c++0x } + +template +char f(int); + +template +char (&f(...))[2]; + +struct DelDtor { + DelDtor() = default; + ~DelDtor() = delete; +}; + +static_assert(sizeof(f(0)) != 1, "Error"); diff --git a/gcc/testsuite/g++.dg/ext/complex8.C b/gcc/testsuite/g++.dg/ext/complex8.C new file mode 100644 index 00000000000..9b8ac1b186f --- /dev/null +++ b/gcc/testsuite/g++.dg/ext/complex8.C @@ -0,0 +1,67 @@ +// PR libstdc++/48760 +// { dg-options -std=c++0x } +// { dg-do run } + +constexpr _Complex int i{1,2}; +constexpr _Complex int j{3}; + +#define SA(X) static_assert((X),#X) + +SA(__real i == 1); +SA(__imag i == 2); +SA(__real j == 3); +SA(__imag j == 0); + +struct A +{ + _Complex int c; + constexpr A(int i, int j): c{i,j} { } + constexpr A(int i): c{i} { } +}; + +constexpr A a1(1,2); +constexpr A a2(3); + +SA(__real a1.c == 1); +SA(__imag a1.c == 2); +SA(__real a2.c == 3); +SA(__imag a2.c == 0); + +typedef _Complex int ci; + +SA((__real ci{1,2} == 1)); +SA((__imag ci{1,2} == 2)); +SA((__real ci{3} == 3)); +SA((__imag ci{3} == 0)); + +struct B +{ + _Complex int c; + int i; +}; + +constexpr B b1 = { { 1,2 }, 42 }; +constexpr B b2 = { { 3 }, 24 }; +// No brace elision for complex. +constexpr B b3 = { 5, 6 }; + +SA(__real b1.c == 1); +SA(__imag b1.c == 2); +SA(b1.i == 42); +SA(__real b2.c == 3); +SA(__imag b2.c == 0); +SA(b2.i == 24); +SA(__real b3.c == 5); +SA(__imag b3.c == 0); +SA(b3.i == 6); + +int main() +{ + ci* p = new ci{1,2}; + if (__real *p != 1 || __imag *p != 2) + return 1; + delete p; + p = new ci{3}; + if (__real *p != 3 || __imag *p != 0) + return 1; +} diff --git a/gcc/testsuite/g++.dg/ext/is_literal_type1.C b/gcc/testsuite/g++.dg/ext/is_literal_type1.C new file mode 100644 index 00000000000..21570d2d6ec --- /dev/null +++ b/gcc/testsuite/g++.dg/ext/is_literal_type1.C @@ -0,0 +1,11 @@ +// PR c++/48771 +// { dg-do compile } +// { dg-options "-std=c++0x" } + +struct NonLiteral { + NonLiteral(); + ~NonLiteral(); +}; + +static_assert(__is_literal_type(NonLiteral&), "Error"); +static_assert(__is_literal_type(NonLiteral&&), "Error"); diff --git a/gcc/testsuite/g++.dg/ext/underlying_type1.C b/gcc/testsuite/g++.dg/ext/underlying_type1.C new file mode 100644 index 00000000000..a8f68d3d60a --- /dev/null +++ b/gcc/testsuite/g++.dg/ext/underlying_type1.C @@ -0,0 +1,18 @@ +// { dg-do compile } + +struct B { }; +union U { }; + +template + struct underlying_type + { typedef __underlying_type(T) type; }; // { dg-error "not an enumeration" } + +__underlying_type(int) i1; // { dg-error "not an enumeration|invalid" } +__underlying_type(A) i2; // { dg-error "expected" } +__underlying_type(B) i3; // { dg-error "not an enumeration|invalid" } +__underlying_type(U) i4; // { dg-error "not an enumeration|invalid" } + +underlying_type::type i5; +underlying_type::type i6; // { dg-error "not declared|template|expected" } +underlying_type::type i7; +underlying_type::type i8; diff --git a/gcc/testsuite/g++.dg/ext/underlying_type10.C b/gcc/testsuite/g++.dg/ext/underlying_type10.C new file mode 100644 index 00000000000..cb57407fe88 --- /dev/null +++ b/gcc/testsuite/g++.dg/ext/underlying_type10.C @@ -0,0 +1,32 @@ +// { dg-do run } +// { dg-options "-std=c++0x" } + +#include + +enum E1 : unsigned { E1_en = 1 }; +enum E2 : char { E2_en = 1 }; +enum class E3 { a = -1 }; +enum class E4 : unsigned char { c = 1 }; +enum class E5 : int { a = -1, b = 1 }; +enum class E6 : long { c = __LONG_MAX__ }; + +template + struct underlying_type + { typedef __underlying_type(T) type; }; + +template + void + test(T t, typename underlying_type::type v) + { + assert( t == T(v) ); + } + +int main() +{ + test(E1::E1_en, 1); + test(E2::E2_en, 1); + test(E3::a, -1); + test(E4::c, 1); + test(E5::a, -1); + test(E6::c, __LONG_MAX__); +} diff --git a/gcc/testsuite/g++.dg/ext/underlying_type2.C b/gcc/testsuite/g++.dg/ext/underlying_type2.C new file mode 100644 index 00000000000..0e4519876d2 --- /dev/null +++ b/gcc/testsuite/g++.dg/ext/underlying_type2.C @@ -0,0 +1,9 @@ +// { dg-do compile } + +enum E1 { }; +enum E2 { a = -1, b = 1 }; +enum E3 { c = __LONG_MAX__ }; + +__underlying_type(E1) e1 = 0; +__underlying_type(E2) e2 = b; +__underlying_type(E3) e3 = __LONG_MAX__; diff --git a/gcc/testsuite/g++.dg/ext/underlying_type3.C b/gcc/testsuite/g++.dg/ext/underlying_type3.C new file mode 100644 index 00000000000..b78cc7dd3f6 --- /dev/null +++ b/gcc/testsuite/g++.dg/ext/underlying_type3.C @@ -0,0 +1,33 @@ +// { dg-do compile } +// { dg-options "-std=c++0x" } + +template + struct is_same + { static const bool value = false; }; + +template + struct is_same + { static const bool value = true; }; + +enum E1 : unsigned { }; +enum E2 : char { }; +enum class E3 { }; +enum class E4 : unsigned char { c = 1 }; +enum class E5 : int { a = -1, b = 1 }; +enum class E6 : long { c = __LONG_MAX__ }; + +__underlying_type(E1) i1 = __INT_MAX__ * 2U + 1; +__underlying_type(E2) i2 = (char(-1) < 0 + ? __SCHAR_MAX__ + : __SCHAR_MAX__ * 2U + 1); +__underlying_type(E3) i3 = __INT_MAX__; +__underlying_type(E4) i4 = __SCHAR_MAX__ * 2U + 1; +__underlying_type(E5) i5 = int(E5::b); +__underlying_type(E6) i6 = __LONG_MAX__; + +static_assert(is_same<__underlying_type(E1), unsigned>::value, "Error"); +static_assert(is_same<__underlying_type(E2), char>::value, "Error"); +static_assert(is_same<__underlying_type(E3), int>::value, "Error"); +static_assert(is_same<__underlying_type(E4), unsigned char>::value, "Error"); +static_assert(is_same<__underlying_type(E5), int>::value, "Error"); +static_assert(is_same<__underlying_type(E6), long>::value, "Error"); diff --git a/gcc/testsuite/g++.dg/ext/underlying_type4.C b/gcc/testsuite/g++.dg/ext/underlying_type4.C new file mode 100644 index 00000000000..b80ed57694b --- /dev/null +++ b/gcc/testsuite/g++.dg/ext/underlying_type4.C @@ -0,0 +1,25 @@ +// { dg-do compile } + +#include + +using namespace std::tr1; + +enum E1 { }; +enum E2 { a = -1, b = 1 }; +enum E3 { c = __LONG_MAX__ }; + +typedef __underlying_type(E1) UTE1; +typedef __underlying_type(E2) UTE2; +typedef __underlying_type(E3) UTE3; + +template + struct underlying_type + { typedef __underlying_type(T) type; }; + +int test1[is_same::type, UTE1>::value ? 1 : -1]; +int test2[is_same::type, UTE2>::value ? 1 : -1]; +int test3[is_same::type, UTE3>::value ? 1 : -1]; + +int test4[is_integral::type>::value ? 1 : -1]; +int test5[is_integral::type>::value ? 1 : -1]; +int test6[is_integral::type>::value ? 1 : -1]; diff --git a/gcc/testsuite/g++.dg/ext/underlying_type5.C b/gcc/testsuite/g++.dg/ext/underlying_type5.C new file mode 100644 index 00000000000..a9c19924b95 --- /dev/null +++ b/gcc/testsuite/g++.dg/ext/underlying_type5.C @@ -0,0 +1,43 @@ +// { dg-do compile } +// { dg-options "-std=c++0x" } + +template + struct is_same + { static const bool value = false; }; + +template + struct is_same + { static const bool value = true; }; + +enum E1 : unsigned { }; +enum E2 : char { }; +enum class E3 { }; +enum class E4 : unsigned char { c = 1 }; +enum class E5 : int { a = -1, b = 1 }; +enum class E6 : long { c = __LONG_MAX__ }; + +typedef __underlying_type(E1) UTE1; +typedef __underlying_type(E2) UTE2; +typedef __underlying_type(E3) UTE3; +typedef __underlying_type(E4) UTE4; +typedef __underlying_type(E5) UTE5; +typedef __underlying_type(E6) UTE6; + +template + struct underlying_type + { typedef __underlying_type(T) type; }; + +static_assert(is_same::type, UTE1>::value, "Error"); +static_assert(is_same::type, UTE2>::value, "Error"); +static_assert(is_same::type, UTE3>::value, "Error"); +static_assert(is_same::type, UTE4>::value, "Error"); +static_assert(is_same::type, UTE5>::value, "Error"); +static_assert(is_same::type, UTE6>::value, "Error"); + +static_assert(is_same::type, unsigned>::value, "Error"); +static_assert(is_same::type, char>::value, "Error"); +static_assert(is_same::type, int>::value, "Error"); +static_assert(is_same::type, + unsigned char>::value, "Error"); +static_assert(is_same::type, int>::value, "Error"); +static_assert(is_same::type, long>::value, "Error"); diff --git a/gcc/testsuite/g++.dg/ext/underlying_type6.C b/gcc/testsuite/g++.dg/ext/underlying_type6.C new file mode 100644 index 00000000000..50f528856d7 --- /dev/null +++ b/gcc/testsuite/g++.dg/ext/underlying_type6.C @@ -0,0 +1,31 @@ +// { dg-do compile } +// { dg-options "-std=c++0x" } + +template + struct is_same + { static const bool value = false; }; + +template + struct is_same + { static const bool value = true; }; + +enum E1 : unsigned { }; +enum E2 : char { }; +enum class E3 { }; +enum class E4 : unsigned char { c = 1 }; +enum class E5 : int { a = -1, b = 1 }; +enum class E6 : long { c = __LONG_MAX__ }; + +template + struct test + { + static_assert(is_same::value, "Error"); + }; + +template class test; +template class test; +template class test; +template class test; +template class test; +template class test; diff --git a/gcc/testsuite/g++.dg/ext/underlying_type7.C b/gcc/testsuite/g++.dg/ext/underlying_type7.C new file mode 100644 index 00000000000..872fe52b00e --- /dev/null +++ b/gcc/testsuite/g++.dg/ext/underlying_type7.C @@ -0,0 +1,24 @@ +// { dg-do compile } +// { dg-options "-std=c++0x" } + +enum E1 : unsigned { E1_en = 1 }; +enum E2 : char { E2_en = 1 }; +enum class E3 { a = -1 }; +enum class E4 : unsigned char { c = 1 }; +enum class E5 : int { a = -1, b = 1 }; +enum class E6 : long { c = __LONG_MAX__ }; + +template + void + test(T, __underlying_type(T)) // { dg-message "sorry, unimplemented: mangling" } + { } + +int main() +{ + test(E1::E1_en, 1); + test(E2::E2_en, 1); + test(E3::a, -1); + test(E4::c, 1); + test(E5::a, -1); + test(E6::c, __LONG_MAX__); +} diff --git a/gcc/testsuite/g++.dg/ext/underlying_type8.C b/gcc/testsuite/g++.dg/ext/underlying_type8.C new file mode 100644 index 00000000000..0bbed2b489c --- /dev/null +++ b/gcc/testsuite/g++.dg/ext/underlying_type8.C @@ -0,0 +1,46 @@ +// { dg-do compile } +// { dg-options "-std=c++0x" } + +enum E1 : unsigned { E1_en = 1 }; +enum E2 : char { E2_en = 1 }; +enum class E3 { a = -1 }; +enum class E4 : unsigned char { c = 1 }; +enum class E5 : int { a = -1, b = 1 }; +enum class E6 : long { c = __LONG_MAX__ }; + +template + struct is_same + { static const bool value = false; }; + +template + struct is_same + { static const bool value = true; }; + +template + struct underlying_type; + +template + void + test(T, U, typename underlying_type::type); + +template + struct underlying_type + { typedef __underlying_type(T) type; }; + +template + void + test(T, U, typename underlying_type::type) + { + static_assert(is_same::type, U>::value, + "Error"); + } + +int main() +{ + test(E1::E1_en, unsigned(), 1); + test(E2::E2_en, char(), 1); + test(E3::a, int(), -1); + test(E4::c, (unsigned char)(1), 1); + test(E5::a, int(), -1); + test(E6::c, long(), __LONG_MAX__); +} diff --git a/gcc/testsuite/g++.dg/ext/underlying_type9.C b/gcc/testsuite/g++.dg/ext/underlying_type9.C new file mode 100644 index 00000000000..9ffd24439a4 --- /dev/null +++ b/gcc/testsuite/g++.dg/ext/underlying_type9.C @@ -0,0 +1,30 @@ +// { dg-do compile } +// { dg-options "-std=c++0x" } + +template + struct is_same + { static const bool value = false; }; + +template + struct is_same + { static const bool value = true; }; + +enum E1 : unsigned { }; +enum E2 : char { }; +enum class E3 { }; +enum class E4 : unsigned char { c = 1 }; +enum class E5 : int { a = -1, b = 1 }; +enum class E6 : long { c = __LONG_MAX__ }; + +template + struct test + { + static_assert(is_same::value, "Error"); + }; + +test<__underlying_type(E1), unsigned> t1; +test<__underlying_type(E2), char> t2; +test<__underlying_type(E3), int> t3; +test<__underlying_type(E4), unsigned char> t4; +test<__underlying_type(E5), int> t5; +test<__underlying_type(E6), long> t6; diff --git a/gcc/testsuite/g++.dg/inherit/pr48798.C b/gcc/testsuite/g++.dg/inherit/pr48798.C new file mode 100644 index 00000000000..cc9921e69b8 --- /dev/null +++ b/gcc/testsuite/g++.dg/inherit/pr48798.C @@ -0,0 +1,4 @@ +// PR c++/48798 + +typedef struct A {} const t; +struct B : t {}; diff --git a/gcc/testsuite/g++.dg/init/ctor10.C b/gcc/testsuite/g++.dg/init/ctor10.C new file mode 100644 index 00000000000..91cc2501209 --- /dev/null +++ b/gcc/testsuite/g++.dg/init/ctor10.C @@ -0,0 +1,9 @@ +// PR c++/48606 +// { dg-do compile } +// { dg-options "-fkeep-inline-functions" } + +struct S +{ + int &ref; + S() : ref() {}; // { dg-error "value-initialization of" } +}; diff --git a/gcc/testsuite/g++.dg/init/new30.C b/gcc/testsuite/g++.dg/init/new30.C new file mode 100644 index 00000000000..24582d8fb1c --- /dev/null +++ b/gcc/testsuite/g++.dg/init/new30.C @@ -0,0 +1,15 @@ +// PR c++/40975 + +struct data_type +{ + // constructor required to reproduce compiler bug + data_type() {} +}; + +struct ptr_type +{ + // array new as default argument required to reproduce compiler bug + ptr_type (data_type* ptr = new data_type[1]) { delete[] ptr; } +}; + +ptr_type obj; diff --git a/gcc/testsuite/g++.dg/lookup/koenig13.C b/gcc/testsuite/g++.dg/lookup/koenig13.C new file mode 100644 index 00000000000..625a181f621 --- /dev/null +++ b/gcc/testsuite/g++.dg/lookup/koenig13.C @@ -0,0 +1,16 @@ +// PR c++/42687 +// DR 705 + +namespace N +{ + struct S { }; + void f(const S &) { } +} + +void f(const N::S &) { } + +int main() +{ + N::S v; + (f)(v); // no ambiguity: ADL is prevented with (), only ::f is considered +} diff --git a/gcc/testsuite/g++.dg/parse/ambig6.C b/gcc/testsuite/g++.dg/parse/ambig6.C new file mode 100644 index 00000000000..8f37feaea68 --- /dev/null +++ b/gcc/testsuite/g++.dg/parse/ambig6.C @@ -0,0 +1,12 @@ +// PR c++/48046 + +namespace N1 { typedef int T; } // { dg-error "" } +namespace N2 { typedef float T; } // { dg-error "" } + +int main() +{ + using namespace N1; + using namespace N2; + + static T t; // { dg-error "" } +} diff --git a/gcc/testsuite/g++.dg/pr48772.C b/gcc/testsuite/g++.dg/pr48772.C new file mode 100644 index 00000000000..39c1094e810 --- /dev/null +++ b/gcc/testsuite/g++.dg/pr48772.C @@ -0,0 +1,35 @@ +// { dg-do compile } +// { dg-options "-O -fnon-call-exceptions -fno-tree-ccp -fno-tree-dce" } + +extern "C" void abort (); + +struct A +{ + void foo () + { + this->bar (); + } + virtual void bar () + { + abort (); + } + ~A () + { + } +}; + +struct B:A +{ + virtual void bar () + { + } +}; + +int +main () +{ + B b; + b.foo (); + return 0; +} + diff --git a/gcc/testsuite/g++.dg/prof-robust-1.C b/gcc/testsuite/g++.dg/prof-robust-1.C new file mode 100644 index 00000000000..a5d8cb3c470 --- /dev/null +++ b/gcc/testsuite/g++.dg/prof-robust-1.C @@ -0,0 +1,24 @@ +/* { dg-options "-O2 -fno-weak" } */ + +#include + +namespace { + namespace { + + class MyClass { + public: + void foo() const; + ~MyClass() { foo(); } + }; + + void MyClass::foo() const { printf("Goodbye World\n"); } + + } + + static MyClass variable; + +} + +int main() { + return 0; +} diff --git a/gcc/testsuite/g++.dg/template/inherit7.C b/gcc/testsuite/g++.dg/template/inherit7.C new file mode 100644 index 00000000000..67afbca6bf0 --- /dev/null +++ b/gcc/testsuite/g++.dg/template/inherit7.C @@ -0,0 +1,21 @@ +// Origin: PR c++/48656 +// { dg-options "-std=c++0x" } +// { dg-do compile } + +struct A { + int f(); + int f(int); +}; + +template struct B : A +{ +}; + +template struct C : B +{ + void + g() + { + A::f(); + } +}; diff --git a/gcc/testsuite/g++.dg/warn/Wnull-conversion-1.C b/gcc/testsuite/g++.dg/warn/Wnull-conversion-1.C new file mode 100644 index 00000000000..511f091f2cf --- /dev/null +++ b/gcc/testsuite/g++.dg/warn/Wnull-conversion-1.C @@ -0,0 +1,15 @@ +// { dg-do compile } +// { dg-options "-Wconversion-null" } + +#include + +void func1(int* ptr); + +void func2() { + int* t = false; // { dg-warning "converting 'false' to pointer" } + int* p; + p = false; // { dg-warning "converting 'false' to pointer" } + int* r = sizeof(char) / 2; + func1(false); // { dg-warning "converting 'false' to pointer" } + int i = NULL; // { dg-warning "converting to non-pointer" } +} diff --git a/gcc/testsuite/g++.dg/warn/Wnull-conversion-2.C b/gcc/testsuite/g++.dg/warn/Wnull-conversion-2.C new file mode 100644 index 00000000000..92a87d1e76c --- /dev/null +++ b/gcc/testsuite/g++.dg/warn/Wnull-conversion-2.C @@ -0,0 +1,45 @@ +// { dg-do compile } +// { dg-options "-Wconversion-null" } + +#include + +class Foo { + public: + template + static void Compare(const T1& expected, const T2& actual) { } + + template + static void Compare(const T1& expected, T2* actual) { } + +}; + +template +class Foo2 { + public: + Foo2(int x); + template void Bar(T2 y); +}; + +template void func(T3 x) { } + +typedef Foo2 MyFooType; + +void func1(long int a) { + MyFooType *foo2 = new MyFooType(NULL); // { dg-warning "passing NULL to" } + foo2->Bar(a); + func(NULL); + func(NULL); // { dg-warning "passing NULL to" } + func(NULL); +} + +int x = 1; + +main() +{ + int *p = &x; + + Foo::Compare(0, *p); + Foo::Compare(NULL, p); // { dg-warning "passing NULL to" } + Foo::Compare(NULL, p); + func1(NULL); // { dg-warning "passing NULL to" } +} diff --git a/gcc/testsuite/gcc.c-torture/compile/pr48734.c b/gcc/testsuite/gcc.c-torture/compile/pr48734.c new file mode 100644 index 00000000000..b20ea80fb3f --- /dev/null +++ b/gcc/testsuite/gcc.c-torture/compile/pr48734.c @@ -0,0 +1,11 @@ +/* PR tree-optimization/48734 */ + +unsigned int +foo (int x, unsigned int y, unsigned int z) +{ + z &= (x == -__INT_MAX__ - 1 ? x : -x) > y; + z &= (x == -__INT_MAX__ - 1 ? x : -x) > y; + z &= (x == -__INT_MAX__ - 1 ? x : -x) > y; + z &= (x == -__INT_MAX__ - 1 ? x : -x) > y; + return z; +} diff --git a/gcc/testsuite/gcc.c-torture/compile/pr48742.c b/gcc/testsuite/gcc.c-torture/compile/pr48742.c new file mode 100644 index 00000000000..0a670f3c990 --- /dev/null +++ b/gcc/testsuite/gcc.c-torture/compile/pr48742.c @@ -0,0 +1,15 @@ +/* PR c/48742 */ + +void baz (int); + +int +foo (void) +{ + return 1 / 0 > 0; +} + +void +bar (void) +{ + baz (1 <= 2 % (3 >> 1 > 5 / 6 == 3)); +} diff --git a/gcc/testsuite/gcc.c-torture/compile/pr48767.c b/gcc/testsuite/gcc.c-torture/compile/pr48767.c new file mode 100644 index 00000000000..66cb34885d0 --- /dev/null +++ b/gcc/testsuite/gcc.c-torture/compile/pr48767.c @@ -0,0 +1,7 @@ +/* PR target/48767 */ + +void +foo (__builtin_va_list ap) +{ + __builtin_va_arg (ap, void); +} diff --git a/gcc/testsuite/gcc.c-torture/execute/pr48809.c b/gcc/testsuite/gcc.c-torture/execute/pr48809.c new file mode 100644 index 00000000000..80de5bc8a3e --- /dev/null +++ b/gcc/testsuite/gcc.c-torture/execute/pr48809.c @@ -0,0 +1,60 @@ +/* PR tree-optimization/48809 */ + +extern void abort (void); + +int +foo (signed char x) +{ + int y = 0; + switch (x) + { + case 0: y = 1; break; + case 1: y = 7; break; + case 2: y = 2; break; + case 3: y = 19; break; + case 4: y = 5; break; + case 5: y = 17; break; + case 6: y = 31; break; + case 7: y = 8; break; + case 8: y = 28; break; + case 9: y = 16; break; + case 10: y = 31; break; + case 11: y = 12; break; + case 12: y = 15; break; + case 13: y = 111; break; + case 14: y = 17; break; + case 15: y = 10; break; + case 16: y = 31; break; + case 17: y = 7; break; + case 18: y = 2; break; + case 19: y = 19; break; + case 20: y = 5; break; + case 21: y = 107; break; + case 22: y = 31; break; + case 23: y = 8; break; + case 24: y = 28; break; + case 25: y = 106; break; + case 26: y = 31; break; + case 27: y = 102; break; + case 28: y = 105; break; + case 29: y = 111; break; + case 30: y = 17; break; + case 31: y = 10; break; + case 32: y = 31; break; + case 98: y = 18; break; + case -62: y = 19; break; + } + return y; +} + +int +main () +{ + if (foo (98) != 18 || foo (97) != 0 || foo (99) != 0) + abort (); + if (foo (-62) != 19 || foo (-63) != 0 || foo (-61) != 0) + abort (); + if (foo (28) != 105 || foo (27) != 102 || foo (29) != 111) + abort (); + return 0; +} diff --git a/gcc/testsuite/gcc.dg/pr15347.c b/gcc/testsuite/gcc.dg/pr15347.c new file mode 100644 index 00000000000..b95b0ea2a5e --- /dev/null +++ b/gcc/testsuite/gcc.dg/pr15347.c @@ -0,0 +1,10 @@ +/* { dg-do link } */ + +extern void link_error (void); +int +main () +{ + if ("<12ers" + 1 == 0) + link_error (); + return 0; +} diff --git a/gcc/testsuite/gcc.dg/pr48685.c b/gcc/testsuite/gcc.dg/pr48685.c new file mode 100644 index 00000000000..36df0cc5f31 --- /dev/null +++ b/gcc/testsuite/gcc.dg/pr48685.c @@ -0,0 +1,11 @@ +/* PR c/48685 */ +/* { dg-do compile } */ +/* { dg-options "-O2" } */ + +int +main () +{ + int v = 1; + (void) (1 == 2 ? (void) 0 : (v = 0)); + return v; +} diff --git a/gcc/testsuite/gcc.dg/pr48768.c b/gcc/testsuite/gcc.dg/pr48768.c new file mode 100644 index 00000000000..7d0383e83bc --- /dev/null +++ b/gcc/testsuite/gcc.dg/pr48768.c @@ -0,0 +1,38 @@ +/* PR debug/48768 */ +/* { dg-do compile } */ +/* { dg-options "-O -fcompare-debug" } */ + +int a, b; + +int +bar (void) +{ + int i, j = 1; + for (i = 0; i != 10; i++) + { + lab: + if (i) + { + int *k = &j; + } + else if (j) + goto lab; + } + return 1; +} + +inline int +foo (int x) +{ + unsigned int c = x; + int d = x; + if (bar ()) + for (; c; c++) + while (x >= 0) + if (foo (d) >= 0) + { + d = bar (); + a = b ? b : 1; + } + return 0; +} diff --git a/gcc/testsuite/gcc.dg/torture/pr48694-1.c b/gcc/testsuite/gcc.dg/torture/pr48694-1.c new file mode 100644 index 00000000000..810366bc8b4 --- /dev/null +++ b/gcc/testsuite/gcc.dg/torture/pr48694-1.c @@ -0,0 +1,14 @@ +/* { dg-do compile } */ + +extern volatile int g_89[5][9]; +extern int g, *gp; +void func_64() +{ + int i; + for (i = 0; i < 1; ) + { + for (g = 0; g < 1; ) + return; + gp = (int *)&g_89[g][0]; + } +} diff --git a/gcc/testsuite/gcc.dg/torture/pr48694-2.c b/gcc/testsuite/gcc.dg/torture/pr48694-2.c new file mode 100644 index 00000000000..4791ac3f70c --- /dev/null +++ b/gcc/testsuite/gcc.dg/torture/pr48694-2.c @@ -0,0 +1,20 @@ +/* { dg-do compile } */ + +extern volatile int g_4[1][4]; +extern int g_7; +void modify(int *); +void func_2() +{ + int l_46 = 4; + if (g_7) + modify(&l_46); + else + { + int i; + for (i = 0; i != 5; i += 1) + { + volatile int *vp = &g_4[0][l_46]; + *vp = 0; + } + } +} diff --git a/gcc/testsuite/gcc.dg/torture/pr48731.c b/gcc/testsuite/gcc.dg/torture/pr48731.c new file mode 100644 index 00000000000..74b77f67c52 --- /dev/null +++ b/gcc/testsuite/gcc.dg/torture/pr48731.c @@ -0,0 +1,24 @@ +/* { dg-do compile } */ + +#include + +int blah(int a, ...) +{ + va_list va; + va_start(va,a); + if (a == 0) + return -1; + else + { + int i; + for (i = 0; i < a; i++) + va_arg(va,int); + return va_arg(va,int); + } +} + +__attribute((flatten)) +int blah2(int b, int c) +{ + return blah(2, b, c); +} diff --git a/gcc/testsuite/gcc.dg/tree-prof/prof-robust-1.c b/gcc/testsuite/gcc.dg/tree-prof/prof-robust-1.c new file mode 100644 index 00000000000..316cfc75734 --- /dev/null +++ b/gcc/testsuite/gcc.dg/tree-prof/prof-robust-1.c @@ -0,0 +1,25 @@ +/* { dg-options "-O2 -w" } */ + +#include +#include + +#ifdef _PROFILE_USE +int foo(int x) { + return 3 * x; +} +#else +int foo(int x) { + return 3 * x; +} +#endif + +int x = 1000; + +int main(int argc, char *argv[]) { + int i; + int sum = 0; + for (i = 0; i < x; i++) + sum += i; + printf("%d\n", sum); + return 0; +} diff --git a/gcc/testsuite/gcc.dg/tree-ssa/alias_bug.c b/gcc/testsuite/gcc.dg/tree-ssa/alias_bug.c new file mode 100644 index 00000000000..64fef27874a --- /dev/null +++ b/gcc/testsuite/gcc.dg/tree-ssa/alias_bug.c @@ -0,0 +1,61 @@ +/* { dg-do compile } */ +/* { dg-options "-O2 -fno-strict-aliasing -fdump-tree-optimized" } */ + +typedef unsigned u32; +typedef unsigned short u16; +typedef unsigned char u8; +struct biosregs { + union { + struct { + u32 edi; + u32 esi; + u32 ebp; + u32 _esp; + u32 ebx; + u32 edx; + u32 ecx; + u32 eax; + u32 _fsgs; + u32 _dses; + u32 eflags; + }; + struct { + u16 di, hdi; + u16 si, hsi; + u16 bp, hbp; + u16 _sp, _hsp; + u16 bx, hbx; + u16 dx, hdx; + u16 cx, hcx; + u16 ax, hax; + u16 gs, fs; + u16 es, ds; + u16 flags, hflags; + }; + struct { + u8 dil, dih, edi2, edi3; + u8 sil, sih, esi2, esi3; + u8 bpl, bph, ebp2, ebp3; + u8 _spl, _sph, _esp2, _esp3; + u8 bl, bh, ebx2, ebx3; + u8 dl, dh, edx2, edx3; + u8 cl, ch, ecx2, ecx3; + u8 al, ah, eax2, eax3; + }; + }; +}; +void initregs(struct biosregs *regs); +void intcall(u8 int_no, const struct biosregs *ireg, struct biosregs *oreg); +static u32 *const gp = (u32*) 0x32; +void keyboard_set_repeat(void) +{ + struct biosregs ireg; + *gp = 10; + initregs(&ireg); + ireg.ax = 0x0305; + intcall(0x16, &ireg, ((void *)0)); +} + +/* { dg-final { scan-tree-dump-times "ireg.*ax" 1 "optimized"} } */ + +/* { dg-final { cleanup-tree-dump "optimized" } } */ diff --git a/gcc/testsuite/gcc.dg/tree-ssa/inline-10.c b/gcc/testsuite/gcc.dg/tree-ssa/inline-10.c new file mode 100644 index 00000000000..1d7aeef2aa0 --- /dev/null +++ b/gcc/testsuite/gcc.dg/tree-ssa/inline-10.c @@ -0,0 +1,38 @@ +/* { dg-do compile } */ +/* { dg-options "-Os -fdump-tree-optimized -fno-partial-inlining" } */ +void do_something1(void); +void do_something2(void); +void do_something3(void); +void do_something4(void); +void do_something5(void); +void do_something_big(int); + +int do_something (int size) +{ + if (__builtin_constant_p (size)) + switch (size) + { + case 1:do_something1 (); break; + case 2:do_something2 (); break; + case 5:do_something1 (); do_something1 (); + case 3:do_something3 (); break; + case 4:do_something4 (); break; + } + else + do_something_big (size); +} +extern int n; +main() +{ + do_something (2); + do_something (3); + do_something (5); + do_something (70); +} +/* All calls should be inlined, except for do_something (5). */ +/* { dg-final { scan-tree-dump-not "do_something1" "optimized" } } */ +/* { dg-final { scan-tree-dump-times "do_something2" 1 "optimized" } } */ +/* { dg-final { scan-tree-dump-times "do_something3" 1 "optimized" } } */ +/* { dg-final { scan-tree-dump-times "do_something \\(5\\)" 1 "optimized" } } */ +/* { dg-final { scan-tree-dump-not "do_something \\(70\\)" "optimized" } } */ +/* { dg-final { cleanup-tree-dump "optimized" } } */ diff --git a/gcc/testsuite/gcc.dg/tree-ssa/inline-9.c b/gcc/testsuite/gcc.dg/tree-ssa/inline-9.c new file mode 100644 index 00000000000..678dd852db6 --- /dev/null +++ b/gcc/testsuite/gcc.dg/tree-ssa/inline-9.c @@ -0,0 +1,24 @@ +/* { dg-do compile } */ +/* { dg-options "-Os -fdump-tree-optimized -fno-partial-inlining" } */ + +/* When optimizing for size, t should be inlined when it expands to one call only. */ +extern int q(int); +int t(int a) +{ + if (a > 12) + { + q(a+5); + q(a+5); + } + else + q(a+10); +} + +main() +{ + t(5); + t(20); +} +/* { dg-final { scan-tree-dump-times "q \\(15\\)" 1 "optimized" } } */ +/* { dg-final { scan-tree-dump-times "t \\(20\\)" 1 "optimized" } } */ +/* { dg-final { cleanup-tree-dump "optimized" } } */ diff --git a/gcc/testsuite/gcc.dg/tree-ssa/integer-addr.c b/gcc/testsuite/gcc.dg/tree-ssa/integer-addr.c new file mode 100644 index 00000000000..b102a7a52e7 --- /dev/null +++ b/gcc/testsuite/gcc.dg/tree-ssa/integer-addr.c @@ -0,0 +1,29 @@ +/* { dg-do compile } */ +/* { dg-options "-O2 -fdump-tree-optimized -fno-strict-aliasing" } */ +/* Test with fixed address */ +static int *foo = (int *) (unsigned long) 0x7800000; + +int func(void) __attribute__ ((noinline)); + +extern int bar(void); + +int func(void) +{ + if (*foo) { + return 1; + } + return 0; + +} + +int foobar(void) +{ + + if (func()) { + *foo = 1; + } + return func(); +} + +/* { dg-final { scan-tree-dump-times "= func" 2 "optimized" } } */ +/* { dg-final { cleanup-tree-dump "optimized" } } */ diff --git a/gcc/testsuite/gcc.dg/tree-ssa/ssa-dom-thread-4.c b/gcc/testsuite/gcc.dg/tree-ssa/ssa-dom-thread-4.c new file mode 100644 index 00000000000..e841429f61a --- /dev/null +++ b/gcc/testsuite/gcc.dg/tree-ssa/ssa-dom-thread-4.c @@ -0,0 +1,63 @@ +/* { dg-do compile } */ +/* { dg-options "-O2 -fdump-tree-dom1-details" } */ +struct bitmap_head_def; +typedef struct bitmap_head_def *bitmap; +typedef const struct bitmap_head_def *const_bitmap; +typedef unsigned long BITMAP_WORD; +typedef struct bitmap_element_def +{ + struct bitmap_element_def *next; + unsigned int indx; +} bitmap_element; + + + + + + + + + +unsigned char +bitmap_ior_and_compl (bitmap dst, const_bitmap a, const_bitmap b, + const_bitmap kill) +{ + unsigned char changed = 0; + + bitmap_element *dst_elt; + const bitmap_element *a_elt, *b_elt, *kill_elt, *dst_prev; + + while (a_elt || b_elt) + { + unsigned char new_element = 0; + + if (b_elt) + while (kill_elt && kill_elt->indx < b_elt->indx) + kill_elt = kill_elt->next; + + if (b_elt && kill_elt && kill_elt->indx == b_elt->indx + && (!a_elt || a_elt->indx >= b_elt->indx)) + { + bitmap_element tmp_elt; + unsigned ix; + + BITMAP_WORD ior = 0; + + changed = bitmap_elt_ior (dst, dst_elt, dst_prev, + a_elt, &tmp_elt, changed); + + } + + } + + + return changed; +} +/* The block starting the second conditional has 3 incoming edges, + we should thread all three, but due to a bug in the threading + code we missed the edge when the first conditional is false + (b_elt is zero, which means the second conditional is always + zero. */ +/* { dg-final { scan-tree-dump-times "Threaded" 3 "dom1"} } */ +/* { dg-final { cleanup-tree-dump "dom1" } } */ + diff --git a/gcc/testsuite/gcc.dg/tree-ssa/vrp56.c b/gcc/testsuite/gcc.dg/tree-ssa/vrp56.c new file mode 100644 index 00000000000..912d28e0f64 --- /dev/null +++ b/gcc/testsuite/gcc.dg/tree-ssa/vrp56.c @@ -0,0 +1,42 @@ +/* { dg-do compile } */ +/* { dg-options "-O2 -fdump-tree-vrp1-details" } */ +typedef struct basic_block_def *basic_block; +struct basic_block_def; +struct edge_def; +typedef struct edge_def *edge; +typedef struct VEC_edge_base +{ + unsigned num; +} VEC_edge_base; +typedef struct VEC_edge_none +{ + VEC_edge_base base; +} VEC_edge_none; +static __inline__ unsigned +VEC_edge_base_length (VEC_edge_base * vec_) +{ + return vec_ ? vec_->num : 0; +} + +typedef struct VEC_edge_gc +{ + VEC_edge_base base; +} VEC_edge_gc; +struct basic_block_def +{ + VEC_edge_gc *succs; +}; + +unsigned char +cleanup_empty_eh (basic_block bb) +{ + edge e_out; + switch (VEC_edge_base_length (&bb->succs->base)) + { + case 1: + foo (); + } +} +/* { dg-final { scan-tree-dump-times "Threaded" 1 "vrp1"} } */ +/* { dg-final { cleanup-tree-dump "vrp1" } } */ + diff --git a/gcc/testsuite/gcc.dg/tree-ssa/vrp57.c b/gcc/testsuite/gcc.dg/tree-ssa/vrp57.c new file mode 100644 index 00000000000..c736adc9e3e --- /dev/null +++ b/gcc/testsuite/gcc.dg/tree-ssa/vrp57.c @@ -0,0 +1,17 @@ +/* PR40052 */ +/* { dg-do compile } */ +/* { dg-options "-O -ftree-vrp -fdump-tree-optimized" } */ + +int foo(_Bool b) +{ + return b | 1; +} + +int bar(_Bool b) +{ + return b & -2; +} + +/* { dg-final { scan-tree-dump "return 0;" "optimized" } } */ +/* { dg-final { scan-tree-dump "return 1;" "optimized" } } */ +/* { dg-final { cleanup-tree-dump "optimized" } } */ diff --git a/gcc/testsuite/gcc.dg/uninit-suppress.c b/gcc/testsuite/gcc.dg/uninit-suppress.c new file mode 100644 index 00000000000..64038a3a239 --- /dev/null +++ b/gcc/testsuite/gcc.dg/uninit-suppress.c @@ -0,0 +1,16 @@ +/* { dg-do compile } */ +/* { dg-options "-fno-tree-ccp -O2 -Wuninitialized -Wno-maybe-uninitialized" } */ +void blah(); +int gflag; + +void foo() +{ + int v; + if (gflag) + v = 10; + + blah(); /* *gflag may be killed, but compiler won't know */ + + if (gflag) + bar(v); /* { dg-bogus "uninitialized" "should be suppressed" } */ +} diff --git a/gcc/testsuite/gcc.dg/uninit-suppress_2.c b/gcc/testsuite/gcc.dg/uninit-suppress_2.c new file mode 100644 index 00000000000..a48b182f8cb --- /dev/null +++ b/gcc/testsuite/gcc.dg/uninit-suppress_2.c @@ -0,0 +1,16 @@ +/* { dg-do compile } */ +/* { dg-options "-fno-tree-ccp -O2 -Wuninitialized -Werror=uninitialized -Wno-error=maybe-uninitialized" } */ +void blah(); +int gflag; + +void foo() +{ + int v; + if (gflag) + v = 10; + + blah(); /* *gflag may be killed, but compiler won't know */ + + if (gflag) + bar(v); /* { dg-warning "uninitialized" "should not be promoted to error" } */ +} diff --git a/gcc/testsuite/gcc.dg/vect/pr48765.c b/gcc/testsuite/gcc.dg/vect/pr48765.c new file mode 100644 index 00000000000..469c4f423ce --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/pr48765.c @@ -0,0 +1,82 @@ +/* { dg-do compile { target powerpc*-*-* } } */ +/* { dg-options "-m64 -O3 -mcpu=power6" } */ + +enum reg_class +{ + NO_REGS, AP_REG, XRF_REGS, GENERAL_REGS, AGRF_REGS, XGRF_REGS, ALL_REGS, + LIM_REG_CLASSES +}; +enum machine_mode +{ + VOIDmode, QImode, HImode, PSImode, SImode, PDImode, DImode, TImode, OImode, + QFmode, HFmode, TQFmode, SFmode, DFmode, XFmode, TFmode, SCmode, DCmode, + XCmode, TCmode, CQImode, CHImode, CSImode, CDImode, CTImode, COImode, + BLKmode, CCmode, CCEVENmode, MAX_MACHINE_MODE +}; +typedef struct rtx_def +{ + int mode:8; +} + *rtx; +extern rtx *regno_reg_rtx; +typedef unsigned int HARD_REG_ELT_TYPE; +typedef HARD_REG_ELT_TYPE HARD_REG_SET[((64 + 32 - 1) / 32)]; +extern int reg_alloc_order[64]; +extern int max_regno; +extern int *reg_n_calls_crossed; +extern short *reg_renumber; +static int *reg_where_dead; +static int *reg_where_born; +static int *reg_order; +static char *regs_change_size; +static HARD_REG_SET *after_insn_hard_regs; +static int stupid_find_reg (int, enum reg_class, enum machine_mode, int, int, + int); +void +stupid_life_analysis (f, nregs, file) + rtx f; +{ + register int i; + for (i = (((64)) + 3) + 1; i < max_regno; i++) + { + register int r = reg_order[i]; + if ((int) LIM_REG_CLASSES > 1) + reg_renumber[r] = + stupid_find_reg (reg_n_calls_crossed[r], reg_preferred_class (r), + ((regno_reg_rtx[r])->mode), reg_where_born[r], + reg_where_dead[r], regs_change_size[r]); + } +} + +static int +stupid_find_reg (call_preserved, class, mode, born_insn, dead_insn, + changes_size) + int call_preserved; + enum reg_class class; + enum machine_mode mode; +{ + register int i, ins; + HARD_REG_SET used, this_reg; + for (ins = born_insn; ins < dead_insn; ins++) + do + { + register HARD_REG_ELT_TYPE *scan_tp_ = (used), *scan_fp_ = + (after_insn_hard_regs[ins]); + for (i = 0; i < ((64 + 32 - 1) / 32); i++) + *scan_tp_++ |= *scan_fp_++; + } + while (0); + for (i = 0; i < 64; i++) + { + int regno = reg_alloc_order[i]; + if (((used)[(regno) / ((unsigned) 32)] & + (((HARD_REG_ELT_TYPE) (1)) << ((regno) % ((unsigned) 32))))) + { + register int j; + if (j == regno) + return regno; + } + } +} + +/* { dg-final { cleanup-tree-dump "vect" } } */ diff --git a/gcc/testsuite/gcc.target/powerpc/pr48258-1.c b/gcc/testsuite/gcc.target/powerpc/pr48258-1.c new file mode 100644 index 00000000000..4f37815d384 --- /dev/null +++ b/gcc/testsuite/gcc.target/powerpc/pr48258-1.c @@ -0,0 +1,57 @@ +/* { dg-do compile } */ +/* { dg-skip-if "" { powerpc*-*-darwin* } { "*" } { "" } } */ +/* { dg-require-effective-target powerpc_vsx_ok } */ +/* { dg-options "-O3 -mcpu=power7 -mabi=altivec -ffast-math -fno-unroll-loops" } */ +/* { dg-final { scan-assembler-times "xvaddsp" 3 } } */ +/* { dg-final { scan-assembler-times "xvminsp" 3 } } */ +/* { dg-final { scan-assembler-times "xvmaxsp" 3 } } */ +/* { dg-final { scan-assembler-times "xxsldwi" 6 } } */ +/* { dg-final { scan-assembler-times "xscvspdp" 3 } } */ +/* { dg-final { scan-assembler-not "stvewx" } } */ +/* { dg-final { scan-assembler-not "stvx" } } */ +/* { dg-final { scan-assembler-not "stxvd2x" } } */ +/* { dg-final { scan-assembler-not "stxvw4x" } } */ + +#include + +#ifndef SIZE +#define SIZE 1024 +#endif + +float values[SIZE] __attribute__((__aligned__(32))); + +float +vector_sum (void) +{ + size_t i; + float sum = 0.0f; + + for (i = 0; i < SIZE; i++) + sum += values[i]; + + return sum; +} + +float +vector_min (void) +{ + size_t i; + float min = values[0]; + + for (i = 0; i < SIZE; i++) + min = __builtin_fminf (min, values[i]); + + return min; +} + +float +vector_max (void) +{ + size_t i; + float max = values[0]; + + for (i = 0; i < SIZE; i++) + max = __builtin_fmaxf (max, values[i]); + + return max; +} diff --git a/gcc/testsuite/gcc.target/powerpc/pr48258-2.c b/gcc/testsuite/gcc.target/powerpc/pr48258-2.c new file mode 100644 index 00000000000..443fb624e30 --- /dev/null +++ b/gcc/testsuite/gcc.target/powerpc/pr48258-2.c @@ -0,0 +1,58 @@ +/* { dg-do compile } */ +/* { dg-skip-if "" { powerpc*-*-darwin* } { "*" } { "" } } */ +/* { dg-require-effective-target powerpc_vsx_ok } */ +/* { dg-options "-O3 -mcpu=power7 -mabi=altivec -ffast-math -fno-unroll-loops" } */ +/* { dg-final { scan-assembler-times "xvadddp" 1 } } */ +/* { dg-final { scan-assembler-times "xvmindp" 1 } } */ +/* { dg-final { scan-assembler-times "xvmaxdp" 1 } } */ +/* { dg-final { scan-assembler-times "xsadddp" 1 } } */ +/* { dg-final { scan-assembler-times "xsmindp" 1 } } */ +/* { dg-final { scan-assembler-times "xsmaxdp" 1 } } */ +/* { dg-final { scan-assembler-not "xxsldwi" } } */ +/* { dg-final { scan-assembler-not "stvx" } } */ +/* { dg-final { scan-assembler-not "stxvd2x" } } */ +/* { dg-final { scan-assembler-not "stxvw4x" } } */ + +#include + +#ifndef SIZE +#define SIZE 1024 +#endif + +double values[SIZE] __attribute__((__aligned__(32))); + +double +vector_sum (void) +{ + size_t i; + double sum = 0.0; + + for (i = 0; i < SIZE; i++) + sum += values[i]; + + return sum; +} + +double +vector_min (void) +{ + size_t i; + double min = values[0]; + + for (i = 0; i < SIZE; i++) + min = __builtin_fmin (min, values[i]); + + return min; +} + +double +vector_max (void) +{ + size_t i; + double max = values[0]; + + for (i = 0; i < SIZE; i++) + max = __builtin_fmax (max, values[i]); + + return max; +} diff --git a/gcc/testsuite/gfortran.dg/coarray_19.f90 b/gcc/testsuite/gfortran.dg/coarray_19.f90 new file mode 100644 index 00000000000..cbb1dd20d8f --- /dev/null +++ b/gcc/testsuite/gfortran.dg/coarray_19.f90 @@ -0,0 +1,27 @@ +! { dg-do compile } +! { dg-options "-fcoarray=single" } +! +! PR fortran/18918 +! + +! Was failing before as the "x%a()[]" was +! regarded as coindexed +subroutine test2() + type t + integer, allocatable :: a(:)[:] + end type t + type(t), SAVE :: x + allocate(x%a(1)[*]) +end subroutine test2 + + +module m + integer, allocatable :: a(:)[:] +end module m + +! Was failing as "a" was allocatable but +! as->cotype was not AS_DEFERERED. +use m +end + +! { dg-final { cleanup-modules "m" } } diff --git a/gcc/testsuite/gfortran.dg/import9.f90 b/gcc/testsuite/gfortran.dg/import9.f90 new file mode 100644 index 00000000000..4ed5cdf88e3 --- /dev/null +++ b/gcc/testsuite/gfortran.dg/import9.f90 @@ -0,0 +1,30 @@ +! { dg-do compile } +! +! PR fortran/48821 +! +! Contributed by Daniel Carrera +! + +contains + pure subroutine rk4_vec(t, Y, dY, h) + real, intent(inout) :: t, Y(:) + real, intent(in) :: h + real, dimension(size(Y)) :: k1, k2, k3, k4 + + interface + pure function dY(t0, y0) + import :: Y + real, intent(in) :: t0, y0(size(Y)) + real :: dY(size(y0)) + end function + end interface + + k1 = dY(t, Y) + k2 = dY(t + h/2, Y + k1*h/2) + k3 = dY(t + h/2, Y + k2*h/2) + k4 = dY(t + h , Y + k3*h) + + Y = Y + (k1 + 2*k2 + 2*k3 + k4) * h/6 + t = t + h + end subroutine +end diff --git a/gcc/testsuite/gfortran.dg/interface_35.f90 b/gcc/testsuite/gfortran.dg/interface_35.f90 new file mode 100644 index 00000000000..20aa4af786d --- /dev/null +++ b/gcc/testsuite/gfortran.dg/interface_35.f90 @@ -0,0 +1,79 @@ +! { dg-do compile } +! { dg-options "-std=f2008" } +! +! PR fortran/48112 (module_m) +! PR fortran/48279 (sidl_string_array, s_Hard) +! +! Contributed by mhp77@gmx.at (module_m) +! and Adrian Prantl (sidl_string_array, s_Hard) +! + +module module_m + interface test + function test1( ) result( test ) + integer :: test + end function test1 + end interface test +end module module_m + +! ----- + +module sidl_string_array + type sidl_string_1d + end type sidl_string_1d + interface set + module procedure & + setg1_p + end interface +contains + subroutine setg1_p(array, index, val) + type(sidl_string_1d), intent(inout) :: array + end subroutine setg1_p +end module sidl_string_array + +module s_Hard + use sidl_string_array + type :: s_Hard_t + integer(8) :: dummy + end type s_Hard_t + interface set_d_interface + end interface + interface get_d_string + module procedure get_d_string_p + end interface + contains ! Derived type member access functions + type(sidl_string_1d) function get_d_string_p(s) + type(s_Hard_t), intent(in) :: s + end function get_d_string_p + subroutine set_d_objectArray_p(s, d_objectArray) + end subroutine set_d_objectArray_p +end module s_Hard + +subroutine initHard(h, ex) + use s_Hard + type(s_Hard_t), intent(inout) :: h + call set(get_d_string(h), 0, 'Three') ! { dg-error "There is no specific subroutine for the generic" } +end subroutine initHard + +! ----- + + interface get + procedure get1 + end interface + + integer :: h + call set1 (get (h)) + +contains + + subroutine set1 (a) + integer, intent(in) :: a + end subroutine + + integer function get1 (s) ! { dg-error "Extension: Internal procedure .get1. in generic interface .get." } + integer :: s + end function + +end + +! { dg-final { cleanup-modules "module_m module_m2 s_hard sidl_string_array" } } diff --git a/gcc/testsuite/gfortran.dg/interface_36.f90 b/gcc/testsuite/gfortran.dg/interface_36.f90 new file mode 100644 index 00000000000..503229134ab --- /dev/null +++ b/gcc/testsuite/gfortran.dg/interface_36.f90 @@ -0,0 +1,28 @@ +! { dg-do compile } +! +! PR fortran/48800 +! +! Contributed by Daniel Carrera +! + pure function runge_kutta_step(t, r_, dr, h) result(res) + real, intent(in) :: t, r_(:), h + real, dimension(:), allocatable :: k1, k2, k3, k4, res + integer :: N + + interface + pure function dr(t, r_) ! { dg-error "cannot have a deferred shape" } + real, intent(in) :: t, r_(:) + real :: dr(:) + end function + end interface + + N = size(r_) + allocate(k1(N),k2(N),k3(N),k4(N),res(N)) + + k1 = dr(t, r_) + k2 = dr(t + h/2, r_ + k1*h/2) + k3 = dr(t + h/2, r_ + k2*h/2) + k4 = dr(t + h , r_ + k3*h) + + res = r_ + (k1 + 2*k2 + 2*k3 + k4) * h/6 + end function diff --git a/gcc/testsuite/gfortran.dg/round_3.f08 b/gcc/testsuite/gfortran.dg/round_3.f08 new file mode 100644 index 00000000000..8b03ce562f1 --- /dev/null +++ b/gcc/testsuite/gfortran.dg/round_3.f08 @@ -0,0 +1,99 @@ +! { dg-do run } +! PR48615 Invalid UP/DOWN rounding with E and ES descriptors +! Test case provided by Thomas Henlich. +program pr48615 + call checkfmt("(RU,F17.0)", 2.5, " 3.") + call checkfmt("(RU,-1P,F17.1)", 2.5, " 0.3") + call checkfmt("(RU,E17.1)", 2.5, " 0.3E+01") + call checkfmt("(RU,1P,E17.0)", 2.5, " 3.E+00") + call checkfmt("(RU,ES17.0)", 2.5, " 3.E+00") + call checkfmt("(RU,EN17.0)", 2.5, " 3.E+00") + call checkfmt("(RU,F2.0)", 2.0, "2.") + call checkfmt("(RU,F6.4)", 2.0, "2.0000") + call checkfmt("(RU,1P,E6.0E2)", 2.0, "2.E+00") + call checkfmt("(RU,1P,E7.1E2)", 2.5, "2.5E+00") + call checkfmt("(RU,1P,E10.4E2)", 2.5, "2.5000E+00") + call checkfmt("(RU,1P,G6.0E2)", 2.0, "2.E+00") + call checkfmt("(RU,1P,G10.4E2)", 2.3456e5, "2.3456E+05") + + call checkfmt("(RU,F2.0)", 0.09, "1.") ! 0. + call checkfmt("(RD,F3.0)", -0.09, "-1.") ! -0. + call checkfmt("(RU,F2.0)", 2.0, "2.") ! 3. + call checkfmt("(RD,F3.0)", -2.0, "-2.") ! -3. + call checkfmt("(RU,F6.4)", 2.0, "2.0000") ! 2.0001 + call checkfmt("(RD,F7.4)", -2.0, "-2.0000") ! -2.0001 + call checkfmt("(RU,1P,E6.0E2)", 2.0, "2.E+00") ! 3.E+00 + call checkfmt("(RD,1P,E7.0E2)", -2.0, "-2.E+00") ! -3.E+00 + call checkfmt("(RU,1P,E7.1E2)", 2.5, "2.5E+00") ! 2.6E+00 + call checkfmt("(RD,1P,E8.1E2)", -2.5, "-2.5E+00") ! -2.6E+00 + call checkfmt("(RU,1P,E10.4E2)", 2.5, "2.5000E+00") ! 2.5001E+00 + call checkfmt("(RD,1P,E11.4E2)", -2.5, "-2.5000E+00") ! -2.5001E+00 + call checkfmt("(RU,1P,G6.0E2)", 2.0, "2.E+00") ! 3.E+00 + call checkfmt("(RD,1P,G7.0E2)", -2.0, "-2.E+00") ! -3.E+00 + call checkfmt("(RU,1P,G10.4E2)", 2.3456e5, "2.3456E+05") ! 2.3457E+05 + call checkfmt("(RD,1P,G11.4E2)", -2.3456e5, "-2.3456E+05") ! -2.3457E+05 + + call checkfmt("(RD,F17.0)", 2.5, " 2.") + call checkfmt("(RD,-1P,F17.1)", 2.5, " 0.2") + call checkfmt("(RD,E17.1)", 2.5, " 0.2E+01") + call checkfmt("(RD,1P,E17.0)", 2.5, " 2.E+00") + call checkfmt("(RD,ES17.0)", 2.5, " 2.E+00") + call checkfmt("(RD,EN17.0)", 2.5, " 2.E+00") + + call checkfmt("(RC,F17.0)", 2.5, " 3.") + call checkfmt("(RC,-1P,F17.1)", 2.5, " 0.3") + call checkfmt("(RC,E17.1)", 2.5, " 0.3E+01") + call checkfmt("(RC,1P,E17.0)", 2.5, " 3.E+00") + call checkfmt("(RC,ES17.0)", 2.5, " 3.E+00") + call checkfmt("(RC,EN17.0)", 2.5, " 3.E+00") + + call checkfmt("(RN,F17.0)", 2.5, " 2.") + call checkfmt("(RN,-1P,F17.1)", 2.5, " 0.2") + call checkfmt("(RN,E17.1)", 2.5, " 0.2E+01") + call checkfmt("(RN,1P,E17.0)", 2.5, " 2.E+00") + call checkfmt("(RN,ES17.0)", 2.5, " 2.E+00") + call checkfmt("(RN,EN17.0)", 2.5, " 2.E+00") + + call checkfmt("(RZ,F17.0)", 2.5, " 2.") + call checkfmt("(RZ,-1P,F17.1)", 2.5, " 0.2") + call checkfmt("(RZ,E17.1)", 2.5, " 0.2E+01") + call checkfmt("(RZ,1P,E17.0)", 2.5, " 2.E+00") + call checkfmt("(RZ,ES17.0)", 2.5, " 2.E+00") + call checkfmt("(RZ,EN17.0)", 2.5, " 2.E+00") + + call checkfmt("(RZ,F17.0)", -2.5, " -2.") + call checkfmt("(RZ,-1P,F17.1)", -2.5, " -0.2") + call checkfmt("(RZ,E17.1)", -2.5, " -0.2E+01") + call checkfmt("(RZ,1P,E17.0)", -2.5, " -2.E+00") + call checkfmt("(RZ,ES17.0)", -2.5, " -2.E+00") + call checkfmt("(RZ,EN17.0)", -2.5, " -2.E+00") + + call checkfmt("(RN,F17.0)", -2.5, " -2.") + call checkfmt("(RN,-1P,F17.1)", -2.5, " -0.2") + call checkfmt("(RN,E17.1)", -2.5, " -0.2E+01") + call checkfmt("(RN,1P,E17.0)", -2.5, " -2.E+00") + call checkfmt("(RN,ES17.0)", -2.5, " -2.E+00") + call checkfmt("(RN,EN17.0)", -2.5, " -2.E+00") + + call checkfmt("(RC,F17.0)", -2.5, " -3.") + call checkfmt("(RC,-1P,F17.1)", -2.5, " -0.3") + call checkfmt("(RC,E17.1)", -2.5, " -0.3E+01") + call checkfmt("(RC,1P,E17.0)", -2.5, " -3.E+00") + call checkfmt("(RC,ES17.0)", -2.5, " -3.E+00") + call checkfmt("(RC,EN17.0)", -2.5, " -3.E+00") + + call checkfmt("(RU,E17.1)", nearest(2.0, 1.0), " 0.3E+01") + call checkfmt("(RD,E17.1)", nearest(3.0, -1.0), " 0.2E+01") + +contains + subroutine checkfmt(fmt, x, cmp) + character(len=*), intent(in) :: fmt + real, intent(in) :: x + character(len=*), intent(in) :: cmp + character(len=20) :: s + + write(s, fmt) x + if (s /= cmp) call abort + !if (s /= cmp) print "(a,1x,a,' expected: ',1x)", fmt, s, cmp + end subroutine +end program diff --git a/gcc/testsuite/gfortran.dg/typebound_proc_22.f90 b/gcc/testsuite/gfortran.dg/typebound_proc_22.f90 new file mode 100644 index 00000000000..f7691c5f283 --- /dev/null +++ b/gcc/testsuite/gfortran.dg/typebound_proc_22.f90 @@ -0,0 +1,49 @@ +! { dg-do compile } +! +! PR fortran/48810 +! +! Contributed by Andrew Baldwin +! + module qtest + type foobar + integer :: x + contains + private + procedure :: gimmex + generic, public :: getx => gimmex + end type foobar + contains + function gimmex(foo) + class (foobar) :: foo + integer :: gimmex + gimmex = foo%x + end function gimmex + end module qtest + + module qtestPriv + type foobarPriv + integer :: x + contains + private + procedure :: gimmexPriv + generic, private :: getxPriv => gimmexPriv + end type foobarPriv + contains + function gimmexPriv(foo) + class (foobarPriv) :: foo + integer :: gimmex + gimmex = foo%x + end function gimmexPriv + end module qtestPriv + + program quicktest + use qtest + use qtestPriv + type (foobar) :: foo + type (foobarPriv) :: fooPriv + integer :: bar + bar = foo%getx() ! OK + bar = fooPriv%getxPriv() ! { dg-error " is PRIVATE " } + end program quicktest + +! { dg-final { cleanup-modules "qtest qtestpriv" } } diff --git a/gcc/testsuite/gfortran.dg/whole_file_34.f90 b/gcc/testsuite/gfortran.dg/whole_file_34.f90 new file mode 100644 index 00000000000..9b421e004ae --- /dev/null +++ b/gcc/testsuite/gfortran.dg/whole_file_34.f90 @@ -0,0 +1,12 @@ +! { dg-do compile } +! +! PR fortran/48788 +! +! Contributed by Zdenek Sojka +! +function foo () +end function foo + character(4), external :: foo ! { dg-error "Return type mismatch of function" } + character(4) :: x + x = foo () +END diff --git a/libgo/go/syslog/syslog_libc.go b/libgo/go/syslog/syslog_libc.go new file mode 100644 index 00000000000..044351dbfd4 --- /dev/null +++ b/libgo/go/syslog/syslog_libc.go @@ -0,0 +1,37 @@ +// Copyright 2011 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// gccgo specific implementation of syslog for Solaris. Solaris uses +// STREAMS to communicate with syslogd. That is enough of a pain that +// we just call the libc function. + +package syslog + +import ( + "fmt" + "os" + "syscall" +) + +func unixSyslog() (conn serverConn, err os.Error) { + return libcConn(0), nil +} + +type libcConn int + +func syslog_c(int, *byte) + +func (libcConn) writeBytes(p Priority, prefix string, b []byte) (int, os.Error) { + syslog_c(int(p), syscall.StringBytePtr(fmt.Sprintf("%s: %s", prefix, b))) + return len(b), nil +} + +func (libcConn) writeString(p Priority, prefix string, s string) (int, os.Error) { + syslog_c(int(p), syscall.StringBytePtr(fmt.Sprintf("%s: %s", prefix, s))) + return len(s), nil +} + +func (libcConn) close() os.Error { + return nil +} diff --git a/libgo/syscalls/socket_irix.go b/libgo/syscalls/socket_irix.go new file mode 100644 index 00000000000..34190362c3f --- /dev/null +++ b/libgo/syscalls/socket_irix.go @@ -0,0 +1,84 @@ +// socket_irix.go -- Socket handling specific to IRIX 6. + +// Copyright 2011 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package syscall + +const SizeofSockaddrInet4 = 16 +const SizeofSockaddrInet6 = 28 +const SizeofSockaddrUnix = 110 + +type RawSockaddrInet4 struct { + Family uint16 + Port uint16 + Addr [4]byte /* in_addr */ + Zero [8]uint8 +} + +func (sa *RawSockaddrInet4) setLen() Socklen_t { + return SizeofSockaddrInet4 +} + +type RawSockaddrInet6 struct { + Family uint16 + Port uint16 + Flowinfo uint32 + Addr [16]byte /* in6_addr */ + Scope_id uint32 +} + +func (sa *RawSockaddrInet6) setLen() Socklen_t { + return SizeofSockaddrInet6 +} + +type RawSockaddrUnix struct { + Family uint16 + Path [108]int8 +} + +func (sa *RawSockaddrUnix) setLen(int) { +} + +func (sa *RawSockaddrUnix) getLen() (int, int) { + if sa.Path[0] == 0 { + // "Abstract" Unix domain socket. + // Rewrite leading NUL as @ for textual display. + // (This is the standard convention.) + // Not friendly to overwrite in place, + // but the callers below don't care. + sa.Path[0] = '@' + } + + // Assume path ends at NUL. + // This is not technically the Linux semantics for + // abstract Unix domain sockets--they are supposed + // to be uninterpreted fixed-size binary blobs--but + // everyone uses this convention. + n := 0 + for n < len(sa.Path)-3 && sa.Path[n] != 0 { + n++ + } + + return n, 0 +} + +type RawSockaddr struct { + Family uint16 + Data [14]int8 +} + +// BindToDevice binds the socket associated with fd to device. +func BindToDevice(fd int, device string) (errno int) { + return ENOSYS +} + +// struct ip_mreg is provived in , but protected with _SGIAPI. +// This could be enabled with -D_SGI_SOURCE, but conflicts with +// -D_XOPEN_SOURCE=500 required for msg_control etc. in struct msghgr, so +// simply provide it here. +type IpMreq struct { + Multiaddr [4]byte + Interface [4]byte +} diff --git a/libstdc++-v3/testsuite/26_numerics/complex/cons/48760.cc b/libstdc++-v3/testsuite/26_numerics/complex/cons/48760.cc new file mode 100644 index 00000000000..0201cc7dca0 --- /dev/null +++ b/libstdc++-v3/testsuite/26_numerics/complex/cons/48760.cc @@ -0,0 +1,56 @@ +// Copyright (C) 2011 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING3. If not see +// . + +#include +#include +#include + +template + void do_test01() + { + bool test __attribute__((unused)) = true; + + if (std::numeric_limits::has_quiet_NaN) + { + std::complex c1(T(0), std::numeric_limits::quiet_NaN()); + VERIFY( c1.real() == T(0) ); + VERIFY( std::isnan(c1.imag()) ); + + std::complex c2(std::numeric_limits::quiet_NaN(), T(0)); + VERIFY( std::isnan(c2.real()) ); + VERIFY( c2.imag() == T(0) ); + + std::complex c3(std::numeric_limits::quiet_NaN(), + std::numeric_limits::quiet_NaN()); + VERIFY( std::isnan(c3.real()) ); + VERIFY( std::isnan(c3.imag()) ); + } + } + +// libstdc++/48760 +void test01() +{ + do_test01(); + do_test01(); + do_test01(); +} + +int main() +{ + test01(); + return 0; +} diff --git a/libstdc++-v3/testsuite/26_numerics/complex/cons/48760_c++0x.cc b/libstdc++-v3/testsuite/26_numerics/complex/cons/48760_c++0x.cc new file mode 100644 index 00000000000..f0017b113d0 --- /dev/null +++ b/libstdc++-v3/testsuite/26_numerics/complex/cons/48760_c++0x.cc @@ -0,0 +1,58 @@ +// { dg-options "-std=gnu++0x" } + +// Copyright (C) 2011 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING3. If not see +// . + +#include +#include +#include + +template + void do_test01() + { + bool test __attribute__((unused)) = true; + + if (std::numeric_limits::has_quiet_NaN) + { + std::complex c1(T(0), std::numeric_limits::quiet_NaN()); + VERIFY( c1.real() == T(0) ); + VERIFY( std::isnan(c1.imag()) ); + + std::complex c2(std::numeric_limits::quiet_NaN(), T(0)); + VERIFY( std::isnan(c2.real()) ); + VERIFY( c2.imag() == T(0) ); + + std::complex c3(std::numeric_limits::quiet_NaN(), + std::numeric_limits::quiet_NaN()); + VERIFY( std::isnan(c3.real()) ); + VERIFY( std::isnan(c3.imag()) ); + } + } + +// libstdc++/48760 +void test01() +{ + do_test01(); + do_test01(); + do_test01(); +} + +int main() +{ + test01(); + return 0; +} -- 2.11.4.GIT