@@ -2159,6 +2159,9 @@ transform_statements (void)
tree
asan_dynamic_init_call (bool after_p)
{
+ if (shadow_ptr_types[0] == NULL_TREE)
+ asan_init_shadow_ptr_types ();
+
tree fn = builtin_decl_implicit (after_p
? BUILT_IN_ASAN_AFTER_DYNAMIC_INIT
: BUILT_IN_ASAN_BEFORE_DYNAMIC_INIT);
@@ -2168,8 +2171,6 @@ asan_dynamic_init_call (bool after_p)
pretty_printer module_name_pp;
pp_string (&module_name_pp, main_input_filename);
- if (shadow_ptr_types[0] == NULL_TREE)
- asan_init_shadow_ptr_types ();
module_name_cst = asan_pp_string (&module_name_pp);
module_name_cst = fold_convert (const_ptr_type_node,
module_name_cst);
Hi! I've been lazy with backports to 5.x lately, which is why I had to backport so much (76 commits) now that I made some time for that. Bootstrapped/regtested on x86_64-linux and i686-linux, committed to branches/gcc-5-branch. Jakub 2017-05-30 Jakub Jelinek <jakub@redhat.com> Backported from mainline 2016-07-21 Jakub Jelinek <jakub@redhat.com> PR sanitizer/71953 * asan.c (asan_dynamic_init_call): Call asan_init_shadow_ptr_types before builtin_decl_implicit. 2017-05-30 Jakub Jelinek <jakub@redhat.com> Backported from mainline 2016-08-09 Jakub Jelinek <jakub@redhat.com> PR tree-optimization/72824 * tree-loop-distribution.c (const_with_all_bytes_same): Verify real_zerop is not negative. * gcc.c-torture/execute/ieee/pr72824.c: New test. --- gcc/tree-loop-distribution.c (revision 239318) +++ gcc/tree-loop-distribution.c (revision 239319) @@ -90,6 +90,7 @@ along with GCC; see the file COPYING3. #include "tree-pass.h" #include "gimple-pretty-print.h" #include "tree-vectorizer.h" +#include "real.h" /* A Reduced Dependence Graph (RDG) vertex representing a statement. */ @@ -775,12 +776,40 @@ const_with_all_bytes_same (tree val) int i, len; if (integer_zerop (val) - || real_zerop (val) || (TREE_CODE (val) == CONSTRUCTOR && !TREE_CLOBBER_P (val) && CONSTRUCTOR_NELTS (val) == 0)) return 0; + if (real_zerop (val)) + { + /* Only return 0 for +0.0, not for -0.0, which doesn't have + an all bytes same memory representation. Don't transform + -0.0 stores into +0.0 even for !HONOR_SIGNED_ZEROS. */ + switch (TREE_CODE (val)) + { + case REAL_CST: + if (!real_isneg (TREE_REAL_CST_PTR (val))) + return 0; + break; + case COMPLEX_CST: + if (!const_with_all_bytes_same (TREE_REALPART (val)) + && !const_with_all_bytes_same (TREE_IMAGPART (val))) + return 0; + break; + case VECTOR_CST: + unsigned int j; + for (j = 0; j < VECTOR_CST_NELTS (val); ++j) + if (const_with_all_bytes_same (VECTOR_CST_ELT (val, i))) + break; + if (j == VECTOR_CST_NELTS (val)) + return 0; + break; + default: + break; + } + } + if (CHAR_BIT != 8 || BITS_PER_UNIT != 8) return -1; --- gcc/testsuite/gcc.c-torture/execute/ieee/pr72824.c (nonexistent) +++ gcc/testsuite/gcc.c-torture/execute/ieee/pr72824.c (revision 239319) @@ -0,0 +1,19 @@ +/* PR tree-optimization/72824 */ + +static inline void +foo (float *x, float value) +{ + int i; + for (i = 0; i < 32; ++i) + x[i] = value; +} + +int +main () +{ + float x[32]; + foo (x, -0.f); + if (__builtin_copysignf (1.0, x[3]) != -1.0f) + __builtin_abort (); + return 0; +} 2017-05-30 Jakub Jelinek <jakub@redhat.com> Backported from mainline 2016-08-11 Jakub Jelinek <jakub@redhat.com> PR c/72816 * c-decl.c (grokdeclarator): When adding TYPE_DOMAIN for flexible array member through typedef, for orig_qual_indirect == 0 clear orig_qual_type. 2016-08-11 Jakub Jelinek <jakub@redhat.com> PR c/72816 * gcc.dg/pr72816.c: Remove dg-error. 2016-08-07 Jakub Jelinek <jakub@redhat.com> PR c/72816 * gcc.dg/pr72816.c: New test. --- gcc/c/c-decl.c (revision 239373) +++ gcc/c/c-decl.c (revision 239374) @@ -6563,6 +6563,8 @@ grokdeclarator (const struct c_declarato type = build_distinct_type_copy (TYPE_MAIN_VARIANT (type)); TYPE_DOMAIN (type) = build_range_type (sizetype, size_zero_node, NULL_TREE); + if (orig_qual_indirect == 0) + orig_qual_type = NULL_TREE; } type = c_build_qualified_type (type, type_quals, orig_qual_type, orig_qual_indirect); --- gcc/testsuite/gcc.dg/pr72816.c (nonexistent) +++ gcc/testsuite/gcc.dg/pr72816.c (revision 239374) @@ -0,0 +1,9 @@ +/* PR c/72816 */ +/* { dg-do compile } */ +/* { dg-options "-std=gnu11" } */ + +typedef const int A[]; +struct S { + int a; + A b; +}; 2017-05-30 Jakub Jelinek <jakub@redhat.com> Backported from mainline 2016-08-11 Jakub Jelinek <jakub@redhat.com> PR c++/72868 * constexpr.c (label_matches): Handle case range expressions. * g++.dg/cpp1y/constexpr-switch4.C: New test. --- gcc/cp/constexpr.c (revision 239379) +++ gcc/cp/constexpr.c (revision 239380) @@ -3307,6 +3307,12 @@ label_matches (tree *jump_target, tree_s { if (!CASE_LOW (stmt)) default_label = i; + else if (CASE_HIGH (stmt)) + { + if (tree_int_cst_le (CASE_LOW (stmt), *jump_target) + && tree_int_cst_le (*jump_target, CASE_HIGH (stmt))) + return true; + } else if (tree_int_cst_equal (*jump_target, CASE_LOW (stmt))) return true; } --- gcc/testsuite/g++.dg/cpp1y/constexpr-switch4.C (nonexistent) +++ gcc/testsuite/g++.dg/cpp1y/constexpr-switch4.C (revision 239380) @@ -0,0 +1,27 @@ +// PR c++/72868 +// { dg-do compile } +// { dg-options "-std=gnu++14" } + +constexpr int +foo (int i) +{ + switch (i) + { + case 11 ... 12: + return 4; + case 0 ... 9: + return 3; + default: + return 7; + } +} + +#define SA(X) static_assert((X),#X) +SA (foo (-1) == 7); +SA (foo (0) == 3); +SA (foo (3) == 3); +SA (foo (9) == 3); +SA (foo (10) == 7); +SA (foo (11) == 4); +SA (foo (12) == 4); +SA (foo (13) == 7); 2017-05-30 Jakub Jelinek <jakub@redhat.com> Backported from mainline 2016-08-12 Jakub Jelinek <jakub@redhat.com> Martin Liska <mliska@suse.cz> PR c/67410 * c-typeck.c (set_nonincremental_init_from_string): Use / instead of % to determine val element to change. Assert that wchar_bytes * charwidth fits into val array. * gcc.dg/pr67410.c: New test. --- gcc/c/c-typeck.c (revision 239419) +++ gcc/c/c-typeck.c (revision 239420) @@ -8485,6 +8485,8 @@ set_nonincremental_init_from_string (tre wchar_bytes = TYPE_PRECISION (TREE_TYPE (TREE_TYPE (str))) / BITS_PER_UNIT; charwidth = TYPE_PRECISION (char_type_node); + gcc_assert ((size_t) wchar_bytes * charwidth + <= ARRAY_SIZE (val) * HOST_BITS_PER_WIDE_INT); type = TREE_TYPE (constructor_type); p = TREE_STRING_POINTER (str); end = p + TREE_STRING_LENGTH (str); @@ -8510,7 +8512,7 @@ set_nonincremental_init_from_string (tre bitpos = (wchar_bytes - byte - 1) * charwidth; else bitpos = byte * charwidth; - val[bitpos % HOST_BITS_PER_WIDE_INT] + val[bitpos / HOST_BITS_PER_WIDE_INT] |= ((unsigned HOST_WIDE_INT) ((unsigned char) *p++)) << (bitpos % HOST_BITS_PER_WIDE_INT); } --- gcc/testsuite/gcc.dg/pr67410.c (nonexistent) +++ gcc/testsuite/gcc.dg/pr67410.c (revision 239420) @@ -0,0 +1,15 @@ +/* PR c/67410 */ +/* { dg-do run } */ +/* { dg-options "-std=gnu11" } */ + +struct { + __CHAR16_TYPE__ s[2]; +} a[] = { u"ff", [0].s[0] = u'x', [1] = u"\u1234\u4567", [1].s[0] = u'\u89ab' }; + +int +main () +{ + if (a[0].s[0] != u'x' || a[0].s[1] != u'f' || a[1].s[0] != u'\u89ab' || a[1].s[1] != u'\u4567') + __builtin_abort (); + return 0; +} 2017-05-30 Jakub Jelinek <jakub@redhat.com> Backported from mainline 2016-08-15 Martin Liska <mliska@suse.cz> Jakub Jelinek <jakub@redhat.com> PR tree-optimization/72824 * tree-loop-distribution.c (const_with_all_bytes_same) <case VECTOR_CST>: Fix a typo. * gcc.c-torture/execute/ieee/pr72824-2.c: New test. --- gcc/tree-loop-distribution.c (revision 239461) +++ gcc/tree-loop-distribution.c (revision 239462) @@ -773,7 +773,7 @@ const_with_all_bytes_same (tree val) case VECTOR_CST: unsigned int j; for (j = 0; j < VECTOR_CST_NELTS (val); ++j) - if (const_with_all_bytes_same (VECTOR_CST_ELT (val, i))) + if (const_with_all_bytes_same (VECTOR_CST_ELT (val, j))) break; if (j == VECTOR_CST_NELTS (val)) return 0; --- gcc/testsuite/gcc.c-torture/execute/ieee/pr72824-2.c (nonexistent) +++ gcc/testsuite/gcc.c-torture/execute/ieee/pr72824-2.c (revision 239462) @@ -0,0 +1,21 @@ +/* PR tree-optimization/72824 */ + +typedef float V __attribute__((vector_size (4 * sizeof (float)))); + +static inline void +foo (V *x, V value) +{ + int i; + for (i = 0; i < 32; ++i) + x[i] = value; +} + +int +main () +{ + V x[32]; + foo (x, (V) { 0.f, -0.f, 0.f, -0.f }); + if (__builtin_copysignf (1.0, x[3][1]) != -1.0f) + __builtin_abort (); + return 0; +} 2017-05-30 Jakub Jelinek <jakub@redhat.com> Backported from mainline 2016-08-16 Jakub Jelinek <jakub@redhat.com> PR target/71910 * tree-cfg.c (execute_fixup_cfg): Add node variable, use it. Before inlining, add cgraph edge for the added __builtin_unreachable call. * g++.dg/gomp/pr71910.C: New test. --- gcc/tree-cfg.c (revision 239921) +++ gcc/tree-cfg.c (revision 239922) @@ -8883,16 +8883,14 @@ execute_fixup_cfg (void) gcov_type count_scale; edge e; edge_iterator ei; + cgraph_node *node = cgraph_node::get (current_function_decl); count_scale - = GCOV_COMPUTE_SCALE (cgraph_node::get (current_function_decl)->count, - ENTRY_BLOCK_PTR_FOR_FN (cfun)->count); + = GCOV_COMPUTE_SCALE (node->count, ENTRY_BLOCK_PTR_FOR_FN (cfun)->count); - ENTRY_BLOCK_PTR_FOR_FN (cfun)->count = - cgraph_node::get (current_function_decl)->count; - EXIT_BLOCK_PTR_FOR_FN (cfun)->count = - apply_scale (EXIT_BLOCK_PTR_FOR_FN (cfun)->count, - count_scale); + ENTRY_BLOCK_PTR_FOR_FN (cfun)->count = node->count; + EXIT_BLOCK_PTR_FOR_FN (cfun)->count + = apply_scale (EXIT_BLOCK_PTR_FOR_FN (cfun)->count, count_scale); FOR_EACH_EDGE (e, ei, ENTRY_BLOCK_PTR_FOR_FN (cfun)->succs) e->count = apply_scale (e->count, count_scale); @@ -8985,10 +8983,19 @@ execute_fixup_cfg (void) { if (stmt && is_gimple_call (stmt)) gimple_call_set_ctrl_altering (stmt, false); - stmt = gimple_build_call - (builtin_decl_implicit (BUILT_IN_UNREACHABLE), 0); + tree fndecl = builtin_decl_implicit (BUILT_IN_UNREACHABLE); + stmt = gimple_build_call (fndecl, 0); gimple_stmt_iterator gsi = gsi_last_bb (bb); gsi_insert_after (&gsi, stmt, GSI_NEW_STMT); + if (!cfun->after_inlining) + { + gcall *call_stmt = dyn_cast <gcall *> (stmt); + int freq + = compute_call_stmt_bb_frequency (current_function_decl, + bb); + node->create_edge (cgraph_node::get_create (fndecl), + call_stmt, bb->count, freq); + } } } } --- gcc/testsuite/g++.dg/gomp/pr71910.C (nonexistent) +++ gcc/testsuite/g++.dg/gomp/pr71910.C (revision 239922) @@ -0,0 +1,13 @@ +// PR target/71910 +// { dg-do compile } +// { dg-additional-options "-O2" } + +#include <vector> + +int +main () +{ + std::vector<double> vec(10); +#pragma omp parallel + __builtin_exit (0); +} 2017-05-30 Jakub Jelinek <jakub@redhat.com> Backported from mainline 2016-08-30 Jakub Jelinek <jakub@redhat.com> PR middle-end/77377 * simplify-rtx.c (avoid_constant_pool_reference): For out of bounds constant pool reference return x instead of c. * gcc.target/i386/pr77377.c: New test. --- gcc/simplify-rtx.c (revision 239928) +++ gcc/simplify-rtx.c (revision 239929) @@ -251,15 +251,14 @@ avoid_constant_pool_reference (rtx x) /* If we're accessing the constant in a different mode than it was originally stored, attempt to fix that up via subreg simplifications. If that fails we have no choice but to return the original memory. */ - if ((offset != 0 || cmode != GET_MODE (x)) - && offset >= 0 && offset < GET_MODE_SIZE (cmode)) + if (offset == 0 && cmode == GET_MODE (x)) + return c; + else if (offset >= 0 && offset < GET_MODE_SIZE (cmode)) { rtx tem = simplify_subreg (GET_MODE (x), c, cmode, offset); if (tem && CONSTANT_P (tem)) return tem; } - else - return c; } return x; --- gcc/testsuite/gcc.target/i386/pr77377.c (nonexistent) +++ gcc/testsuite/gcc.target/i386/pr77377.c (revision 239929) @@ -0,0 +1,6 @@ +/* PR middle-end/77377 */ +/* { dg-do compile } */ +/* { dg-options "-O3 -msse" } */ +/* { dg-additional-options "-fpic" { target fpic } } */ + +#include "../../c-c++-common/pr59037.c" 2017-05-30 Jakub Jelinek <jakub@redhat.com> Backported from mainline 2016-08-30 Jakub Jelinek <jakub@redhat.com> PR debug/77363 * dwarf2out.c (modified_type_die): Use lookup_type_die (type) instead of lookup_type_die (type_main_variant (type)) even for array types. * g++.dg/debug/dwarf2/pr77363.C: New test. --- gcc/dwarf2out.c (revision 239929) +++ gcc/dwarf2out.c (revision 239930) @@ -11466,7 +11466,8 @@ modified_type_die (tree type, int cv_qua copy was created to help us keep track of typedef names) and that copy might have a different TYPE_UID from the original ..._TYPE node. */ - if (TREE_CODE (type) != VECTOR_TYPE) + if (TREE_CODE (type) != VECTOR_TYPE + && TREE_CODE (type) != ARRAY_TYPE) return lookup_type_die (type_main_variant (type)); else /* Vectors have the debugging information in the type, --- gcc/testsuite/g++.dg/debug/dwarf2/pr77363.C (nonexistent) +++ gcc/testsuite/g++.dg/debug/dwarf2/pr77363.C (revision 239930) @@ -0,0 +1,20 @@ +// PR debug/77363 +// { dg-options "-gdwarf-2 -dA -fno-merge-debug-strings" } +// { dg-final { scan-assembler "DIE \\(\[^\n\r\]*\\) DW_TAG_typedef\[^\n\r\]*\[\n\r]*\[^\n\r\]*type2\[^\n\r\]* DW_AT_name\[^\n\r\]*\[\n\r]*\[^\n\r\]* DW_AT_decl_file\[^\n\r\]*\[\n\r]*\[^\n\r\]* DW_AT_decl_line\[^\n\r\]*\[\n\r]*\[^\n\r\]* DW_AT_type" } } +// { dg-final { scan-assembler "DIE \\(\[^\n\r\]*\\) DW_TAG_typedef\[^\n\r\]*\[\n\r]*\[^\n\r\]*type3\[^\n\r\]* DW_AT_name\[^\n\r\]*\[\n\r]*\[^\n\r\]* DW_AT_decl_file\[^\n\r\]*\[\n\r]*\[^\n\r\]* DW_AT_decl_line\[^\n\r\]*\[\n\r]*\[^\n\r\]* DW_AT_type" } } +// { dg-final { scan-assembler "DIE \\(\[^\n\r\]*\\) DW_TAG_typedef\[^\n\r\]*\[\n\r]*\[^\n\r\]*type4\[^\n\r\]* DW_AT_name\[^\n\r\]*\[\n\r]*\[^\n\r\]* DW_AT_decl_file\[^\n\r\]*\[\n\r]*\[^\n\r\]* DW_AT_decl_line\[^\n\r\]*\[\n\r]*\[^\n\r\]* DW_AT_type" } } +// { dg-final { scan-assembler "DIE \\(\[^\n\r\]*\\) DW_TAG_typedef\[^\n\r\]*\[\n\r]*\[^\n\r\]*type5\[^\n\r\]* DW_AT_name\[^\n\r\]*\[\n\r]*\[^\n\r\]* DW_AT_decl_file\[^\n\r\]*\[\n\r]*\[^\n\r\]* DW_AT_decl_line\[^\n\r\]*\[\n\r]*\[^\n\r\]* DW_AT_type" } } + +typedef unsigned short type1; +typedef unsigned char type2; +typedef type2 type3[16]; +typedef unsigned char type4[16]; +typedef struct +{ + struct + { + type3 a; + type4 b; + } c; +} type5; +type5 var; 2017-05-30 Jakub Jelinek <jakub@redhat.com> Backported from mainline 2016-09-05 Jakub Jelinek <jakub@redhat.com> PR sanitizer/77396 * asan/asan_globals.cc: Cherry-pick upstream r280657. 2016-09-05 Jakub Jelinek <jakub@redhat.com> PR sanitizer/77396 * g++.dg/asan/pr77396-2.C: New test. 2016-09-02 Jakub Jelinek <jakub@redhat.com> PR sanitizer/77396 * g++.dg/asan/pr77396.C: New test. --- libsanitizer/asan/asan_globals.cc (revision 240176) +++ libsanitizer/asan/asan_globals.cc (revision 240177) @@ -249,10 +249,10 @@ void __asan_unregister_globals(__asan_gl // initializer can only touch global variables in the same TU. void __asan_before_dynamic_init(const char *module_name) { if (!flags()->check_initialization_order || - !flags()->poison_heap) + !flags()->poison_heap || + !dynamic_init_globals) return; bool strict_init_order = flags()->strict_init_order; - CHECK(dynamic_init_globals); CHECK(module_name); CHECK(asan_inited); BlockingMutexLock lock(&mu_for_globals); @@ -275,7 +275,8 @@ void __asan_before_dynamic_init(const ch // TU are poisoned. It simply unpoisons all dynamically initialized globals. void __asan_after_dynamic_init() { if (!flags()->check_initialization_order || - !flags()->poison_heap) + !flags()->poison_heap || + !dynamic_init_globals) return; CHECK(asan_inited); BlockingMutexLock lock(&mu_for_globals); --- gcc/testsuite/g++.dg/asan/pr77396.C (nonexistent) +++ gcc/testsuite/g++.dg/asan/pr77396.C (revision 240177) @@ -0,0 +1,12 @@ +// PR sanitizer/77396 +// { dg-do run } +// { dg-set-target-env-var ASAN_OPTIONS "check_initialization_order=true" } + +static int a = 0; +static int b = a; + +int +main () +{ + return 0; +} --- gcc/testsuite/g++.dg/asan/pr77396-2.C (nonexistent) +++ gcc/testsuite/g++.dg/asan/pr77396-2.C (revision 240177) @@ -0,0 +1,12 @@ +// PR sanitizer/77396 +// { dg-do run } +// { dg-set-target-env-var ASAN_OPTIONS "check_initialization_order=true" } + +struct S { S () { asm volatile ("" : : : "memory"); } }; +static S c; + +int +main () +{ + return 0; +} 2017-05-30 Jakub Jelinek <jakub@redhat.com> Backported from mainline 2016-09-08 Jakub Jelinek <jakub@redhat.com> PR fortran/77516 * omp-low.c (lower_rec_simd_input_clauses): Use max_vf for non-positive OMP_CLAUSE_SAFELEN_EXPR. * gfortran.dg/gomp/pr77516.f90: New test. --- gcc/omp-low.c (revision 240178) +++ gcc/omp-low.c (revision 240179) @@ -4300,7 +4300,9 @@ lower_rec_simd_input_clauses (tree new_v { tree c = find_omp_clause (gimple_omp_for_clauses (ctx->stmt), OMP_CLAUSE_SAFELEN); - if (c && TREE_CODE (OMP_CLAUSE_SAFELEN_EXPR (c)) != INTEGER_CST) + if (c + && (TREE_CODE (OMP_CLAUSE_SAFELEN_EXPR (c)) != INTEGER_CST + || tree_int_cst_sgn (OMP_CLAUSE_SAFELEN_EXPR (c)) != 1)) max_vf = 1; else if (c && compare_tree_int (OMP_CLAUSE_SAFELEN_EXPR (c), max_vf) == -1) --- gcc/testsuite/gfortran.dg/gomp/pr77516.f90 (nonexistent) +++ gcc/testsuite/gfortran.dg/gomp/pr77516.f90 (revision 240179) @@ -0,0 +1,12 @@ +! PR fortran/77516 +! { dg-do compile } + +program pr77516 + integer :: i, x + x = 0 +!$omp simd safelen(0) reduction(+:x) + do i = 1, 8 + x = x + 1 + end do + print *, x +end 2017-05-30 Jakub Jelinek <jakub@redhat.com> Backported from mainline 2016-09-08 Jakub Jelinek <jakub@redhat.com> PR fortran/77500 * trans-openmp.c (gfc_trans_omp_atomic): For atomic write or swap, don't try to look through GFC_ISYM_CONVERSION. In other cases, check that value.function.isym is non-NULL before dereferencing it. * gfortran.dg/gomp/pr77500.f90: New test. --- gcc/fortran/trans-openmp.c (revision 240179) +++ gcc/fortran/trans-openmp.c (revision 240180) @@ -2816,7 +2816,11 @@ gfc_trans_omp_atomic (gfc_code *code) gfc_start_block (&block); expr2 = code->expr2; - if (expr2->expr_type == EXPR_FUNCTION + if (((atomic_code->ext.omp_atomic & GFC_OMP_ATOMIC_MASK) + != GFC_OMP_ATOMIC_WRITE) + && (atomic_code->ext.omp_atomic & GFC_OMP_ATOMIC_SWAP) == 0 + && expr2->expr_type == EXPR_FUNCTION + && expr2->value.function.isym && expr2->value.function.isym->id == GFC_ISYM_CONVERSION) expr2 = expr2->value.function.actual->expr; @@ -2855,6 +2859,7 @@ gfc_trans_omp_atomic (gfc_code *code) var = code->expr1->symtree->n.sym; expr2 = code->expr2; if (expr2->expr_type == EXPR_FUNCTION + && expr2->value.function.isym && expr2->value.function.isym->id == GFC_ISYM_CONVERSION) expr2 = expr2->value.function.actual->expr; } @@ -2912,6 +2917,7 @@ gfc_trans_omp_atomic (gfc_code *code) } e = expr2->value.op.op1; if (e->expr_type == EXPR_FUNCTION + && e->value.function.isym && e->value.function.isym->id == GFC_ISYM_CONVERSION) e = e->value.function.actual->expr; if (e->expr_type == EXPR_VARIABLE @@ -2925,6 +2931,7 @@ gfc_trans_omp_atomic (gfc_code *code) { e = expr2->value.op.op2; if (e->expr_type == EXPR_FUNCTION + && e->value.function.isym && e->value.function.isym->id == GFC_ISYM_CONVERSION) e = e->value.function.actual->expr; gcc_assert (e->expr_type == EXPR_VARIABLE @@ -3039,6 +3046,7 @@ gfc_trans_omp_atomic (gfc_code *code) code = code->next; expr2 = code->expr2; if (expr2->expr_type == EXPR_FUNCTION + && expr2->value.function.isym && expr2->value.function.isym->id == GFC_ISYM_CONVERSION) expr2 = expr2->value.function.actual->expr; --- gcc/testsuite/gfortran.dg/gomp/pr77500.f90 (nonexistent) +++ gcc/testsuite/gfortran.dg/gomp/pr77500.f90 (revision 240180) @@ -0,0 +1,9 @@ +! PR fortran/77500 +! { dg-do compile } + +program pr77500 + real :: x +!$omp atomic write + x = f() +!$omp end atomic +end 2017-05-30 Jakub Jelinek <jakub@redhat.com> Backported from mainline 2016-09-14 Jakub Jelinek <jakub@redhat.com> PR sanitizer/68260 * tsan.c: Include target.h. (enum tsan_atomic_action): Add bool_clear and bool_test_and_set. (BOOL_CLEAR, BOOL_TEST_AND_SET): Define. (tsan_atomic_table): Add BUILT_IN_ATOMIC_CLEAR and BUILT_IN_ATOMIC_TEST_AND_SET entries. (instrument_builtin_call): Handle bool_clear and bool_test_and_set. * c-c++-common/tsan/pr68260.c: New test. --- gcc/tsan.c (revision 240181) +++ gcc/tsan.c (revision 240182) @@ -40,6 +40,7 @@ along with GCC; see the file COPYING3. #include "tsan.h" #include "asan.h" #include "builtins.h" +#include "target.h" /* Number of instrumented memory accesses in the current function. */ @@ -240,7 +241,8 @@ instrument_expr (gimple_stmt_iterator gs enum tsan_atomic_action { check_last, add_seq_cst, add_acquire, weak_cas, strong_cas, - bool_cas, val_cas, lock_release, fetch_op, fetch_op_seq_cst + bool_cas, val_cas, lock_release, fetch_op, fetch_op_seq_cst, + bool_clear, bool_test_and_set }; /* Table how to map sync/atomic builtins to their corresponding @@ -274,6 +276,10 @@ static const struct tsan_map_atomic TRANSFORM (fcode, tsan_fcode, fetch_op, code) #define FETCH_OPS(fcode, tsan_fcode, code) \ TRANSFORM (fcode, tsan_fcode, fetch_op_seq_cst, code) +#define BOOL_CLEAR(fcode, tsan_fcode) \ + TRANSFORM (fcode, tsan_fcode, bool_clear, ERROR_MARK) +#define BOOL_TEST_AND_SET(fcode, tsan_fcode) \ + TRANSFORM (fcode, tsan_fcode, bool_test_and_set, ERROR_MARK) CHECK_LAST (ATOMIC_LOAD_1, TSAN_ATOMIC8_LOAD), CHECK_LAST (ATOMIC_LOAD_2, TSAN_ATOMIC16_LOAD), @@ -463,7 +469,11 @@ static const struct tsan_map_atomic LOCK_RELEASE (SYNC_LOCK_RELEASE_2, TSAN_ATOMIC16_STORE), LOCK_RELEASE (SYNC_LOCK_RELEASE_4, TSAN_ATOMIC32_STORE), LOCK_RELEASE (SYNC_LOCK_RELEASE_8, TSAN_ATOMIC64_STORE), - LOCK_RELEASE (SYNC_LOCK_RELEASE_16, TSAN_ATOMIC128_STORE) + LOCK_RELEASE (SYNC_LOCK_RELEASE_16, TSAN_ATOMIC128_STORE), + + BOOL_CLEAR (ATOMIC_CLEAR, TSAN_ATOMIC8_STORE), + + BOOL_TEST_AND_SET (ATOMIC_TEST_AND_SET, TSAN_ATOMIC8_EXCHANGE) }; /* Instrument an atomic builtin. */ @@ -615,6 +625,57 @@ instrument_builtin_call (gimple_stmt_ite build_int_cst (NULL_TREE, MEMMODEL_RELEASE)); return; + case bool_clear: + case bool_test_and_set: + if (BOOL_TYPE_SIZE != 8) + { + decl = NULL_TREE; + for (j = 1; j < 5; j++) + if (BOOL_TYPE_SIZE == (8 << j)) + { + enum built_in_function tsan_fcode + = (enum built_in_function) + (tsan_atomic_table[i].tsan_fcode + j); + decl = builtin_decl_implicit (tsan_fcode); + break; + } + if (decl == NULL_TREE) + return; + } + last_arg = gimple_call_arg (stmt, num - 1); + if (!tree_fits_uhwi_p (last_arg) + || memmodel_base (tree_to_uhwi (last_arg)) >= MEMMODEL_LAST) + return; + t = TYPE_ARG_TYPES (TREE_TYPE (decl)); + t = TREE_VALUE (TREE_CHAIN (t)); + if (tsan_atomic_table[i].action == bool_clear) + { + update_gimple_call (gsi, decl, 3, gimple_call_arg (stmt, 0), + build_int_cst (t, 0), last_arg); + return; + } + t = build_int_cst (t, targetm.atomic_test_and_set_trueval); + update_gimple_call (gsi, decl, 3, gimple_call_arg (stmt, 0), + t, last_arg); + stmt = gsi_stmt (*gsi); + lhs = gimple_call_lhs (stmt); + if (lhs == NULL_TREE) + return; + if (targetm.atomic_test_and_set_trueval != 1 + || !useless_type_conversion_p (TREE_TYPE (lhs), + TREE_TYPE (t))) + { + tree new_lhs = make_ssa_name (TREE_TYPE (t)); + gimple_call_set_lhs (stmt, new_lhs); + if (targetm.atomic_test_and_set_trueval != 1) + g = gimple_build_assign (lhs, NE_EXPR, new_lhs, + build_int_cst (TREE_TYPE (t), 0)); + else + g = gimple_build_assign (lhs, NOP_EXPR, new_lhs); + gsi_insert_after (gsi, g, GSI_NEW_STMT); + update_stmt (stmt); + } + return; default: continue; } --- gcc/testsuite/c-c++-common/tsan/pr68260.c (nonexistent) +++ gcc/testsuite/c-c++-common/tsan/pr68260.c (revision 240182) @@ -0,0 +1,28 @@ +/* PR sanitizer/68260 */ + +#include <pthread.h> +#include <stdbool.h> + +bool lock; +int counter; + +void * +tf (void *arg) +{ + (void) arg; + while (__atomic_test_and_set (&lock, __ATOMIC_ACQUIRE)) + ; + ++counter; + __atomic_clear (&lock, __ATOMIC_RELEASE); + return (void *) 0; +} + +int +main () +{ + pthread_t thr; + pthread_create (&thr, 0, tf, 0); + tf ((void *) 0); + pthread_join (thr, 0); + return 0; +} 2017-05-30 Jakub Jelinek <jakub@redhat.com> Backported from mainline 2016-09-16 Jakub Jelinek <jakub@redhat.com> Eric Botcazou <ebotcazou@adacore.com> PR middle-end/77594 * internal-fn.c (expand_arith_overflow) <case MINUS_EXPR>: Don't fall through into expand_addsub_overflow after expand_neg_overflow. * gcc.target/i386/pr77594.c: New test. --- gcc/internal-fn.c (revision 240182) +++ gcc/internal-fn.c (revision 240183) @@ -1789,7 +1789,10 @@ expand_arith_overflow (enum tree_code co { case MINUS_EXPR: if (integer_zerop (arg0) && !unsr_p) - expand_neg_overflow (loc, lhs, arg1, false); + { + expand_neg_overflow (loc, lhs, arg1, false); + return; + } /* FALLTHRU */ case PLUS_EXPR: expand_addsub_overflow (loc, code, lhs, arg0, arg1, --- gcc/testsuite/gcc.target/i386/pr77594.c (nonexistent) +++ gcc/testsuite/gcc.target/i386/pr77594.c (revision 240183) @@ -0,0 +1,11 @@ +/* PR middle-end/77594 */ +/* { dg-do compile } */ +/* { dg-options "-O0" } */ + +int +foo (int a, int *b) +{ + return __builtin_sub_overflow (0, a, b); +} + +/* { dg-final { scan-assembler-times "\tjn?o\t" 1 } } */ 2017-05-30 Jakub Jelinek <jakub@redhat.com> Backported from mainline 2016-09-16 Jakub Jelinek <jakub@redhat.com> PR c++/77375 * class.c (check_bases): Set CLASSTYPE_HAS_MUTABLE if any TYPE_HAS_MUTABLE_P for any bases. * g++.dg/cpp0x/mutable1.C: New test. --- gcc/cp/class.c (revision 243380) +++ gcc/cp/class.c (revision 243381) @@ -1777,6 +1777,8 @@ check_bases (tree t, SET_CLASSTYPE_REF_FIELDS_NEED_INIT (t, CLASSTYPE_REF_FIELDS_NEED_INIT (t) | CLASSTYPE_REF_FIELDS_NEED_INIT (basetype)); + if (TYPE_HAS_MUTABLE_P (basetype)) + CLASSTYPE_HAS_MUTABLE (t) = 1; /* A standard-layout class is a class that: ... --- gcc/testsuite/g++.dg/cpp0x/mutable1.C (nonexistent) +++ gcc/testsuite/g++.dg/cpp0x/mutable1.C (revision 243381) @@ -0,0 +1,12 @@ +// PR c++/77375 +// { dg-do run { target c++11 } } + +struct Base { mutable int i; }; +struct Derived : Base {}; +const Derived foo{}; + +int +main () +{ + foo.i = 42; +} 2017-05-30 Jakub Jelinek <jakub@redhat.com> Backported from mainline 2016-09-19 Jakub Jelinek <jakub@redhat.com> Jan Hubicka <jh@suse.cz> PR target/77587 * cgraph.c (cgraph_node::rtl_info): Pass &avail to ultimate_alias_target call, return NULL if avail < AVAIL_AVAILABLE. Call ultimate_alias_target just once, not up to 4 times. * gcc.dg/pr77587.c: New test. * gcc.dg/pr77587a.c: New file. --- gcc/cgraph.c (revision 243382) +++ gcc/cgraph.c (revision 243383) @@ -1914,11 +1914,14 @@ cgraph_node::rtl_info (tree decl) cgraph_node *node = get (decl); if (!node) return NULL; - node = node->ultimate_alias_target (); - if (node->decl != current_function_decl - && !TREE_ASM_WRITTEN (node->decl)) + enum availability avail; + node = node->ultimate_alias_target (&avail); + if (decl != current_function_decl + && (avail < AVAIL_AVAILABLE + || (node->decl != current_function_decl + && !TREE_ASM_WRITTEN (node->decl)))) return NULL; - return &node->ultimate_alias_target ()->rtl; + return &node->rtl; } /* Return a string describing the failure REASON. */ --- gcc/testsuite/gcc.dg/pr77587.c (nonexistent) +++ gcc/testsuite/gcc.dg/pr77587.c (revision 243383) @@ -0,0 +1,14 @@ +/* PR target/77587 */ +/* { dg-do run } */ +/* { dg-require-weak-override "" } */ +/* { dg-additional-sources "pr77587a.c" } */ + +void +bar (long x, long y, long z) +{ + struct __attribute__((aligned (16))) S { long a, b, c, d; } s; + char *p = (char *) &s; + __asm ("" : "+r" (p)); + if (((__UINTPTR_TYPE__) p) & 15) + __builtin_abort (); +} --- gcc/testsuite/gcc.dg/pr77587a.c (nonexistent) +++ gcc/testsuite/gcc.dg/pr77587a.c (revision 243383) @@ -0,0 +1,23 @@ +/* PR target/77587 */ +/* { dg-do compile } */ +/* { dg-require-weak-override "" } */ + +void +foo (long x, long y, long z) +{ +} + +void bar (long x, long y, long z) __attribute__ ((weak, alias ("foo"))); + +void +baz (long x, long y, long z) +{ + bar (0, 0, 0); +} + +int +main () +{ + baz (0, 0, 0); + return 0; +} 2017-05-30 Jakub Jelinek <jakub@redhat.com> Backported from mainline 2016-09-20 Jakub Jelinek <jakub@redhat.com> PR middle-end/77624 * builtins.c (fold_builtin_atomic_always_lock_free): Only look through cast to void * if the cast is from some other pointer type. * c-c++-common/pr77624-1.c: New test. * c-c++-common/pr77624-2.c: New test. --- gcc/builtins.c (revision 243383) +++ gcc/builtins.c (revision 243384) @@ -5403,8 +5403,10 @@ fold_builtin_atomic_always_lock_free (tr end before anything else has a chance to look at it. The pointer parameter at this point is usually cast to a void *, so check for that and look past the cast. */ - if (CONVERT_EXPR_P (arg1) && POINTER_TYPE_P (ttype) - && VOID_TYPE_P (TREE_TYPE (ttype))) + if (CONVERT_EXPR_P (arg1) + && POINTER_TYPE_P (ttype) + && VOID_TYPE_P (TREE_TYPE (ttype)) + && POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (arg1, 0)))) arg1 = TREE_OPERAND (arg1, 0); ttype = TREE_TYPE (arg1); --- gcc/testsuite/c-c++-common/pr77624-1.c (nonexistent) +++ gcc/testsuite/c-c++-common/pr77624-1.c (revision 243384) @@ -0,0 +1,14 @@ +/* PR middle-end/77624 */ +/* { dg-do compile } */ + +int +foo (int a) +{ + return __atomic_is_lock_free (2, a); /* { dg-warning "pointer from integer" "" { target c } } */ +} /* { dg-error "invalid conversion" "" { target c++ } 7 } */ + +int +bar (int a) +{ + return __atomic_always_lock_free (2, a); /* { dg-warning "pointer from integer" "" { target c } } */ +} /* { dg-error "invalid conversion" "" { target c++ } 13 } */ --- gcc/testsuite/c-c++-common/pr77624-2.c (nonexistent) +++ gcc/testsuite/c-c++-common/pr77624-2.c (revision 243384) @@ -0,0 +1,26 @@ +/* PR middle-end/77624 */ +/* { dg-do compile } */ + +void +foo (int *a) +{ + double b = 0; + __atomic_is_lock_free (2, a, 2); /* { dg-error "too many arguments" } */ + __atomic_is_lock_free (2); /* { dg-error "too few arguments" } */ + __atomic_is_lock_free (2, b); /* { dg-error "incompatible type" "" { target c } } */ + /* { dg-message "expected" "" { target c } 10 } */ + /* { dg-error "convert" "" { target c++ } 10 } */ + __atomic_is_lock_free (2, 0); +} + +void +bar (int *a) +{ + double b = 0; + __atomic_always_lock_free (2, a, 2); /* { dg-error "too many arguments" } */ + __atomic_always_lock_free (2); /* { dg-error "too few arguments" } */ + __atomic_always_lock_free (2, b); /* { dg-error "incompatible type" "" { target c } } */ + /* { dg-message "expected" "" { target c } 22 } */ + /* { dg-error "convert" "" { target c++ } 22 } */ + __atomic_always_lock_free (2, 0); +} 2017-05-30 Jakub Jelinek <jakub@redhat.com> Backported from mainline 2016-09-20 Jakub Jelinek <jakub@redhat.com> PR c++/77637 * parser.c (cp_parser_std_attribute_list): Reject ... without preceding attribute. * g++.dg/cpp0x/gen-attrs-62.C: New test. --- gcc/cp/parser.c (revision 243384) +++ gcc/cp/parser.c (revision 243385) @@ -24058,8 +24058,12 @@ cp_parser_std_attribute_list (cp_parser if (token->type == CPP_ELLIPSIS) { cp_lexer_consume_token (parser->lexer); - TREE_VALUE (attribute) - = make_pack_expansion (TREE_VALUE (attribute)); + if (attribute == NULL_TREE) + error_at (token->location, + "expected attribute before %<...%>"); + else + TREE_VALUE (attribute) + = make_pack_expansion (TREE_VALUE (attribute)); token = cp_lexer_peek_token (parser->lexer); } if (token->type != CPP_COMMA) --- gcc/testsuite/g++.dg/cpp0x/gen-attrs-62.C (nonexistent) +++ gcc/testsuite/g++.dg/cpp0x/gen-attrs-62.C (revision 243385) @@ -0,0 +1,5 @@ +// PR c++/77637 +// { dg-do compile { target c++11 } } + +int [[...]] a; // { dg-error "expected attribute before '...'" } +int [[,,...]] b; // { dg-error "expected attribute before '...'" } 2017-05-30 Jakub Jelinek <jakub@redhat.com> Backported from mainline 2016-09-22 Jakub Jelinek <jakub@redhat.com> PR fortran/77665 * tree-inline.c (remap_gimple_stmt): Set has_simduid_loops for all IFN_GOMP_SIMD_* internal fns. * gfortran.dg/gomp/pr77665.f90: New test. --- gcc/tree-inline.c (revision 243386) +++ gcc/tree-inline.c (revision 243387) @@ -1644,6 +1644,17 @@ remap_gimple_stmt (gimple stmt, copy_bod gimple_call_set_tail (call_stmt, false); if (gimple_call_from_thunk_p (call_stmt)) gimple_call_set_from_thunk (call_stmt, false); + if (gimple_call_internal_p (call_stmt)) + switch (gimple_call_internal_fn (call_stmt)) + { + case IFN_GOMP_SIMD_LANE: + case IFN_GOMP_SIMD_VF: + case IFN_GOMP_SIMD_LAST_LANE: + DECL_STRUCT_FUNCTION (id->dst_fn)->has_simduid_loops = true; + break; + default: + break; + } } /* Remap the region numbers for __builtin_eh_{pointer,filter}, --- gcc/testsuite/gfortran.dg/gomp/pr77665.f90 (nonexistent) +++ gcc/testsuite/gfortran.dg/gomp/pr77665.f90 (revision 243387) @@ -0,0 +1,18 @@ +! PR fortran/77665 +! { dg-do compile } +! { dg-additional-options "-O2" } + +program pr77665 + type t + integer :: a = 0 + end type + type(t) :: x + integer :: i + !$omp declare reduction (+:t: omp_out%a = omp_out%a + omp_in%a) + !$omp simd reduction(+:x) + do i = 1, 8 + if (abs(i) < 5) call abort + x%a = x%a + 1 + end do + print *, x%a +end 2017-05-30 Jakub Jelinek <jakub@redhat.com> Backported from mainline 2016-09-27 Jakub Jelinek <jakub@redhat.com> PR fortran/77666 * trans-openmp.c (gfc_omp_private_outer_ref): Return true even for references to allocatable arrays. * gfortran.dg/gomp/pr77666.f90: New test. --- gcc/fortran/trans-openmp.c (revision 243387) +++ gcc/fortran/trans-openmp.c (revision 243388) @@ -207,6 +207,9 @@ gfc_omp_private_outer_ref (tree decl) { tree type = TREE_TYPE (decl); + if (gfc_omp_privatize_by_reference (decl)) + type = TREE_TYPE (type); + if (GFC_DESCRIPTOR_TYPE_P (type) && GFC_TYPE_ARRAY_AKIND (type) == GFC_ARRAY_ALLOCATABLE) return true; @@ -214,9 +217,6 @@ gfc_omp_private_outer_ref (tree decl) if (GFC_DECL_GET_SCALAR_ALLOCATABLE (decl)) return true; - if (gfc_omp_privatize_by_reference (decl)) - type = TREE_TYPE (type); - if (gfc_has_alloc_comps (type, decl)) return true; --- gcc/testsuite/gfortran.dg/gomp/pr77666.f90 (nonexistent) +++ gcc/testsuite/gfortran.dg/gomp/pr77666.f90 (revision 243388) @@ -0,0 +1,26 @@ +! PR fortran/77666 +! { dg-do compile } + +subroutine foo(x) + interface + subroutine baz(x, y) + integer, allocatable :: x(:), y + end subroutine + end interface + integer, allocatable :: x(:), y +!$omp parallel private(x, y) + call baz (x, y) +!$omp end parallel +end +subroutine bar + interface + subroutine baz(x, y) + integer, allocatable :: x(:), y + end subroutine + end interface + integer, allocatable :: x(:), y + call baz (x, y) +!$omp parallel private(x, y) + call baz (x, y) +!$omp end parallel +end 2017-05-30 Jakub Jelinek <jakub@redhat.com> Backported from mainline 2016-09-27 Jakub Jelinek <jakub@redhat.com> PR c++/77722 * cp-gimplify.c (cp_ubsan_maybe_instrument_return): Instrument also functions that have just a STATEMENT_LIST instead of BIND_EXPR, or BIND_EXPR with some statement rather than STATEMENT_LIST as body. * g++.dg/ubsan/return-4.C: New test. * g++.dg/ubsan/return-5.C: New test. * g++.dg/ubsan/return-6.C: New test. --- gcc/cp/cp-gimplify.c (revision 243388) +++ gcc/cp/cp-gimplify.c (revision 243389) @@ -1507,14 +1507,11 @@ cp_ubsan_maybe_instrument_return (tree f } if (t == NULL_TREE) return; - t = DECL_SAVED_TREE (fndecl); - if (TREE_CODE (t) == BIND_EXPR - && TREE_CODE (BIND_EXPR_BODY (t)) == STATEMENT_LIST) - { - tree_stmt_iterator i = tsi_last (BIND_EXPR_BODY (t)); - t = ubsan_instrument_return (DECL_SOURCE_LOCATION (fndecl)); - tsi_link_after (&i, t, TSI_NEW_STMT); - } + tree *p = &DECL_SAVED_TREE (fndecl); + if (TREE_CODE (*p) == BIND_EXPR) + p = &BIND_EXPR_BODY (*p); + t = ubsan_instrument_return (DECL_SOURCE_LOCATION (fndecl)); + append_to_statement_list (t, p); } void --- gcc/testsuite/g++.dg/ubsan/return-4.C (nonexistent) +++ gcc/testsuite/g++.dg/ubsan/return-4.C (revision 243389) @@ -0,0 +1,18 @@ +// PR c++/77722 +// { dg-do run } +// { dg-options "-fsanitize=return -w" } +// { dg-shouldfail "ubsan" } + +int +foo () +{ +} + +int +main () +{ + foo (); + return 0; +} + +// { dg-output "execution reached the end of a value-returning function without returning a value" } --- gcc/testsuite/g++.dg/ubsan/return-5.C (nonexistent) +++ gcc/testsuite/g++.dg/ubsan/return-5.C (revision 243389) @@ -0,0 +1,19 @@ +// PR c++/77722 +// { dg-do run } +// { dg-options "-fsanitize=return -w" } +// { dg-shouldfail "ubsan" } + +int +foo () +{ + int a = 5; +} + +int +main () +{ + foo (); + return 0; +} + +// { dg-output "execution reached the end of a value-returning function without returning a value" } --- gcc/testsuite/g++.dg/ubsan/return-6.C (nonexistent) +++ gcc/testsuite/g++.dg/ubsan/return-6.C (revision 243389) @@ -0,0 +1,20 @@ +// PR c++/77722 +// { dg-do run } +// { dg-options "-fsanitize=return -w" } +// { dg-shouldfail "ubsan" } + +int +foo () +{ + int a = 5; + int b = 5; +} + +int +main () +{ + foo (); + return 0; +} + +// { dg-output "execution reached the end of a value-returning function without returning a value" } 2017-05-30 Jakub Jelinek <jakub@redhat.com> Backported from mainline 2016-09-28 Jakub Jelinek <jakub@redhat.com> PR c++/77467 * constexpr.c (enum constexpr_switch_state): New. (struct constexpr_ctx): Add css_state field. (label_matches): Add CTX and STMT arguments, remove I and DEFAULT_LABEL. For CASE_LABEL_EXPR assert ctx->css_state != NULL, handle default labels according to css_state. (cxx_eval_statement_list): Remove statement skipping, label_matches and default_label handling code. (cxx_eval_loop_expr): Exit after first iteration even if switches (jump_target). (cxx_eval_switch_expr): Set up css_state field in ctx, if default label has been seen in the body, but no cases matched, evaluate the body second time. (cxx_eval_constant_expression): Handle stmt skipping and label_matches here. Handle PREDICT_EXPR. For MODIFY_EXPR or INIT_EXPR, assert statement is not skipped. For COND_EXPR during skipping, don't evaluate condition, just the then block and if still skipping at the end also the else block. (cxx_eval_outermost_constant_expr): Adjust constexpr_ctx initializer. (is_sub_constant_expr): Likewise. * g++.dg/cpp1y/constexpr-77467.C: New test. --- gcc/cp/constexpr.c (revision 243389) +++ gcc/cp/constexpr.c (revision 243390) @@ -888,6 +888,18 @@ struct constexpr_call_hasher : ggc_hashe static bool equal (constexpr_call *, constexpr_call *); }; +enum constexpr_switch_state { + /* Used when processing a switch for the first time by cxx_eval_switch_expr + and default: label for that switch has not been seen yet. */ + css_default_not_seen, + /* Used when processing a switch for the first time by cxx_eval_switch_expr + and default: label for that switch has been seen already. */ + css_default_seen, + /* Used when processing a switch for the second time by + cxx_eval_switch_expr, where default: label should match. */ + css_default_processing +}; + /* The constexpr expansion context. CALL is the current function expansion, CTOR is the current aggregate initializer, OBJECT is the object being initialized by CTOR, either a VAR_DECL or a _REF. VALUES @@ -907,6 +919,8 @@ struct constexpr_ctx { tree ctor; /* The object we're building the CONSTRUCTOR for. */ tree object; + /* If inside SWITCH_EXPR. */ + constexpr_switch_state *css_state; /* Whether we should error on a non-constant expression or fail quietly. */ bool quiet; /* Whether we are strictly conforming to constant expression rules or @@ -3071,14 +3085,12 @@ switches (tree *jump_target) } /* Subroutine of cxx_eval_statement_list. Determine whether the statement - at I matches *jump_target. If we're looking for a case label and we see - the default label, copy I into DEFAULT_LABEL. */ + STMT matches *jump_target. If we're looking for a case label and we see + the default label, note it in ctx->css_state. */ static bool -label_matches (tree *jump_target, tree_stmt_iterator i, - tree_stmt_iterator& default_label) +label_matches (const constexpr_ctx *ctx, tree *jump_target, tree stmt) { - tree stmt = tsi_stmt (i); switch (TREE_CODE (*jump_target)) { case LABEL_DECL: @@ -3090,8 +3102,18 @@ label_matches (tree *jump_target, tree_s case INTEGER_CST: if (TREE_CODE (stmt) == CASE_LABEL_EXPR) { + gcc_assert (ctx->css_state != NULL); if (!CASE_LOW (stmt)) - default_label = i; + { + /* default: should appear just once in a SWITCH_EXPR + body (excluding nested SWITCH_EXPR). */ + gcc_assert (*ctx->css_state != css_default_seen); + /* When evaluating SWITCH_EXPR body for the second time, + return true for the default: label. */ + if (*ctx->css_state == css_default_processing) + return true; + *ctx->css_state = css_default_seen; + } else if (CASE_HIGH (stmt)) { if (tree_int_cst_le (CASE_LOW (stmt), *jump_target) @@ -3118,7 +3140,6 @@ cxx_eval_statement_list (const constexpr tree *jump_target) { tree_stmt_iterator i; - tree_stmt_iterator default_label = tree_stmt_iterator(); tree local_target; /* In a statement-expression we want to return the last value. */ tree r = NULL_TREE; @@ -3129,18 +3150,7 @@ cxx_eval_statement_list (const constexpr } for (i = tsi_start (t); !tsi_end_p (i); tsi_next (&i)) { - reenter: tree stmt = tsi_stmt (i); - if (*jump_target) - { - if (TREE_CODE (stmt) == STATEMENT_LIST) - /* The label we want might be inside. */; - else if (label_matches (jump_target, i, default_label)) - /* Found it. */ - *jump_target = NULL_TREE; - else - continue; - } r = cxx_eval_constant_expression (ctx, stmt, false, non_constant_p, overflow_p, jump_target); @@ -3149,12 +3159,6 @@ cxx_eval_statement_list (const constexpr if (returns (jump_target) || breaks (jump_target)) break; } - if (switches (jump_target) && !tsi_end_p (default_label)) - { - i = default_label; - *jump_target = NULL_TREE; - goto reenter; - } return r; } @@ -3189,7 +3193,10 @@ cxx_eval_loop_expr (const constexpr_ctx /* Forget saved values of SAVE_EXPRs. */ save_exprs.traverse<constexpr_ctx &, save_exprs_remover>(new_ctx); } - while (!returns (jump_target) && !breaks (jump_target) && !*non_constant_p); + while (!returns (jump_target) + && !breaks (jump_target) + && !switches (jump_target) + && !*non_constant_p); if (breaks (jump_target)) *jump_target = NULL_TREE; @@ -3212,8 +3219,20 @@ cxx_eval_switch_expr (const constexpr_ct *jump_target = cond; tree body = TREE_OPERAND (t, 1); - cxx_eval_statement_list (ctx, body, - non_constant_p, overflow_p, jump_target); + constexpr_ctx new_ctx = *ctx; + constexpr_switch_state css = css_default_not_seen; + new_ctx.css_state = &css; + cxx_eval_constant_expression (&new_ctx, body, false, + non_constant_p, overflow_p, jump_target); + if (switches (jump_target) && css == css_default_seen) + { + /* If the SWITCH_EXPR body has default: label, process it once again, + this time instructing label_matches to return true for default: + label on switches (jump_target). */ + css = css_default_processing; + cxx_eval_constant_expression (&new_ctx, body, false, + non_constant_p, overflow_p, jump_target); + } if (breaks (jump_target) || switches (jump_target)) *jump_target = NULL_TREE; return NULL_TREE; @@ -3290,6 +3309,27 @@ cxx_eval_constant_expression (const cons constexpr_ctx new_ctx; tree r = t; + if (jump_target && *jump_target) + { + /* If we are jumping, ignore all statements/expressions except those + that could have LABEL_EXPR or CASE_LABEL_EXPR in their bodies. */ + switch (TREE_CODE (t)) + { + case BIND_EXPR: + case STATEMENT_LIST: + case LOOP_EXPR: + case COND_EXPR: + break; + case LABEL_EXPR: + case CASE_LABEL_EXPR: + if (label_matches (ctx, jump_target, t)) + /* Found it. */ + *jump_target = NULL_TREE; + return NULL_TREE; + default: + return NULL_TREE; + } + } if (t == error_mark_node) { *non_constant_p = true; @@ -3344,6 +3384,7 @@ cxx_eval_constant_expression (const cons case LABEL_DECL: case LABEL_EXPR: case CASE_LABEL_EXPR: + case PREDICT_EXPR: return t; case PARM_DECL: @@ -3461,6 +3502,7 @@ cxx_eval_constant_expression (const cons } /* else fall through */ case MODIFY_EXPR: + gcc_assert (jump_target == NULL || *jump_target == NULL_TREE); r = cxx_eval_store_expression (ctx, t, lval, non_constant_p, overflow_p); break; @@ -3691,6 +3733,22 @@ cxx_eval_constant_expression (const cons break; case COND_EXPR: + if (jump_target && *jump_target) + { + /* When jumping to a label, the label might be either in the + then or else blocks, so process then block first in skipping + mode first, and if we are still in the skipping mode at its end, + process the else block too. */ + r = cxx_eval_constant_expression (ctx, TREE_OPERAND (t, 1), + lval, non_constant_p, overflow_p, + jump_target); + if (*jump_target) + r = cxx_eval_constant_expression (ctx, TREE_OPERAND (t, 2), + lval, non_constant_p, overflow_p, + jump_target); + break; + } + /* FALLTHRU */ case VEC_COND_EXPR: r = cxx_eval_conditional_expression (ctx, t, lval, non_constant_p, overflow_p, @@ -3876,7 +3934,7 @@ cxx_eval_outermost_constant_expr (tree t bool overflow_p = false; hash_map<tree,tree> map; - constexpr_ctx ctx = { NULL, &map, NULL, NULL, NULL, + constexpr_ctx ctx = { NULL, &map, NULL, NULL, NULL, NULL, allow_non_constant, strict }; tree type = initialized_type (t); @@ -3987,7 +4045,7 @@ is_sub_constant_expr (tree t) bool overflow_p = false; hash_map <tree, tree> map; - constexpr_ctx ctx = { NULL, &map, NULL, NULL, NULL, true, true }; + constexpr_ctx ctx = { NULL, &map, NULL, NULL, NULL, NULL, true, true }; cxx_eval_constant_expression (&ctx, t, false, &non_constant_p, &overflow_p); --- gcc/testsuite/g++.dg/cpp1y/constexpr-77467.C (nonexistent) +++ gcc/testsuite/g++.dg/cpp1y/constexpr-77467.C (revision 243390) @@ -0,0 +1,128 @@ +// PR c++/77467 +// { dg-do compile { target c++14 } } + +constexpr int +foo (const int x, const unsigned n) noexcept +{ + switch (n) + { + case 0: + return 1; + case 1: + return x; + default: + const auto m = (n >> 1); + const auto y = foo (x, m); + return ((m << 1) == n) ? y * y : x * y * y; + } +} + +static_assert (foo (3, 2) == 9, ""); +static_assert (foo (2, 3) == 8, ""); + +constexpr int +bar (int x) +{ + int a = x; + switch (x) + a = x + 1; + return a; +} + +static_assert (bar (0) == 0, ""); +static_assert (bar (1) == 1, ""); + +constexpr int +baz (const int x, int y) noexcept +{ + switch (x) + { + case 0: + return 1; + case 1: + return x; + case 2: + if ((y += 2) == 0) + { + case 3: + y += 4; + break; + } + else + { + case 4: + y += 8; + break; + } + break; + case 5: + for (y = 0; y < 3; y++) + { + case 7: + if (y == -4) + y += 3; + if (y == -3) + continue; + if (y == -2) + { + y += 18; + break; + } + if (y == 2) + { + case 6: + y += 12; + default: + y++; + break; + } + } + break; + case -1: + case -2: + switch (y) + { + case 19: + y += 2; + break; + case 20: + y += 3; + if (x == 2) + case 21:; + y += 2; + if (x == 3) + default:; + y += 4; + break; + } + return x + y + 1; + } + return x + y; +} + +static_assert (baz (0, 7) == 1, ""); +static_assert (baz (1, 7) == 1, ""); +static_assert (baz (2, -2) == 6, ""); +static_assert (baz (2, 0) == 12, ""); +static_assert (baz (3, 1) == 8, ""); +static_assert (baz (4, 2) == 14, ""); +static_assert (baz (5, -20) == 20, ""); +static_assert (baz (6, 5) == 24, ""); +static_assert (baz (7, -5) == 22, ""); +static_assert (baz (7, -4) == 22, ""); +static_assert (baz (7, -3) == 23, ""); +static_assert (baz (7, -2) == 23, ""); +static_assert (baz (7, -1) == 22, ""); +static_assert (baz (7, 0) == 22, ""); +static_assert (baz (7, 2) == 22, ""); +static_assert (baz (7, 6) == 14, ""); +static_assert (baz (8, 9) == 18, ""); +static_assert (baz (8, -2) == 7, ""); +static_assert (baz (-1, 19) == 21, ""); +static_assert (baz (-1, 20) == 29, ""); +static_assert (baz (-1, 21) == 27, ""); +static_assert (baz (-1, 5) == 9, ""); +static_assert (baz (-2, 19) == 20, ""); +static_assert (baz (-2, 20) == 28, ""); +static_assert (baz (-2, 21) == 26, ""); +static_assert (baz (-2, 5) == 8, ""); 2017-05-30 Jakub Jelinek <jakub@redhat.com> Backported from mainline 2016-10-05 Jakub Jelinek <jakub@redhat.com> PR sanitizer/66343 * ubsan.c (ubsan_ids): New GTY(()) array. (ubsan_type_descriptor, ubsan_create_data): Use ubsan_ids instead of static local counters. * gcc.dg/pch/pr66343-1.c: New test. * gcc.dg/pch/pr66343-1.hs: New file. * gcc.dg/pch/pr66343-2.c: New test. * gcc.dg/pch/pr66343-2.hs: New file. --- gcc/ubsan.c (revision 243390) +++ gcc/ubsan.c (revision 243391) @@ -314,6 +314,10 @@ get_ubsan_type_info_for_type (tree type) return 0; } +/* Counters for internal labels. ubsan_ids[0] for Lubsan_type, + ubsan_ids[1] for Lubsan_data labels. */ +static GTY(()) unsigned int ubsan_ids[2]; + /* Helper routine that returns ADDR_EXPR of a VAR_DECL of a type descriptor. It first looks into the hash table; if not found, create the VAR_DECL, put it into the hash table and return the @@ -461,10 +465,9 @@ ubsan_type_descriptor (tree type, enum u TREE_STATIC (str) = 1; char tmp_name[32]; - static unsigned int type_var_id_num; - ASM_GENERATE_INTERNAL_LABEL (tmp_name, "Lubsan_type", type_var_id_num++); + ASM_GENERATE_INTERNAL_LABEL (tmp_name, "Lubsan_type", ubsan_ids[0]++); decl = build_decl (UNKNOWN_LOCATION, VAR_DECL, get_identifier (tmp_name), - dtype); + dtype); TREE_STATIC (decl) = 1; TREE_PUBLIC (decl) = 0; DECL_ARTIFICIAL (decl) = 1; @@ -564,8 +567,7 @@ ubsan_create_data (const char *name, int /* Now, fill in the type. */ char tmp_name[32]; - static unsigned int ubsan_var_id_num; - ASM_GENERATE_INTERNAL_LABEL (tmp_name, "Lubsan_data", ubsan_var_id_num++); + ASM_GENERATE_INTERNAL_LABEL (tmp_name, "Lubsan_data", ubsan_ids[1]++); tree var = build_decl (UNKNOWN_LOCATION, VAR_DECL, get_identifier (tmp_name), ret); TREE_STATIC (var) = 1; --- gcc/testsuite/gcc.dg/pch/pr66343-1.c (nonexistent) +++ gcc/testsuite/gcc.dg/pch/pr66343-1.c (revision 243391) @@ -0,0 +1,15 @@ +/* PR sanitizer/66343 */ +/* { dg-do assemble } */ +/* { dg-options "-fsanitize=undefined" } */ + +#include "pr66343-1.h" + +void +bar (int a, int b) +{ + a / b; +} + +/* Hack to turn off PCH assembly comparison, as it is incompatible + with dg-do assemble. The target condition will be always false. */ +/* { dg-error "" "" { target { lp64 && { ! lp64 } } } } */ --- gcc/testsuite/gcc.dg/pch/pr66343-1.hs (nonexistent) +++ gcc/testsuite/gcc.dg/pch/pr66343-1.hs (revision 243391) @@ -0,0 +1,8 @@ +/* PR sanitizer/66343 */ +/* { dg-options "-fsanitize=undefined" } */ + +void +foo (int a, int b) +{ + a / b; +} --- gcc/testsuite/gcc.dg/pch/pr66343-2.c (nonexistent) +++ gcc/testsuite/gcc.dg/pch/pr66343-2.c (revision 243391) @@ -0,0 +1,10 @@ +/* PR sanitizer/66343 */ +/* { dg-options "-fsanitize=undefined" } */ + +#include "pr66343-2.h" + +void +bar (int a, int b) +{ + a / b; +} --- gcc/testsuite/gcc.dg/pch/pr66343-2.hs (nonexistent) +++ gcc/testsuite/gcc.dg/pch/pr66343-2.hs (revision 243391) @@ -0,0 +1,8 @@ +/* PR sanitizer/66343 */ +/* { dg-options "-fsanitize=undefined" } */ + +void +foo (int a, int b) +{ + a / b; +} 2017-05-30 Jakub Jelinek <jakub@redhat.com> Backported from mainline 2016-10-28 Jakub Jelinek <jakub@redhat.com> PR rtl-optimization/77919 * expr.c (expand_expr_real_1) <normal_inner_ref>: Force CONCAT into MEM if mode1 is not a complex mode. * g++.dg/torture/pr77919.C: New test. --- gcc/expr.c (revision 243393) +++ gcc/expr.c (revision 243394) @@ -10197,7 +10197,8 @@ expand_expr_real_1 (tree exp, rtx target if (GET_CODE (op0) == CONCAT && !must_force_mem) { if (bitpos == 0 - && bitsize == GET_MODE_BITSIZE (GET_MODE (op0))) + && bitsize == GET_MODE_BITSIZE (GET_MODE (op0)) + && COMPLEX_MODE_P (mode1)) return op0; if (bitpos == 0 && bitsize == GET_MODE_BITSIZE (GET_MODE (XEXP (op0, 0))) --- gcc/testsuite/g++.dg/torture/pr77919.C (nonexistent) +++ gcc/testsuite/g++.dg/torture/pr77919.C (revision 243394) @@ -0,0 +1,11 @@ +// PR rtl-optimization/77919 +// { dg-do compile } +// { dg-additional-options "-Wno-psabi" } + +struct A { A (double) {} _Complex double i; }; +typedef int __attribute__ ((vector_size (16))) B; +typedef struct { B b; } C; +struct D { D (const B &x) : b (x) {} B b; }; +static inline B foo (const double *x) { C *a; a = (C *) x; return a->b; } +static inline D baz (const A &x) { return foo ((double *) &x); } +D b = baz (0); 2017-05-30 Jakub Jelinek <jakub@redhat.com> Backported from mainline 2016-10-29 Jakub Jelinek <jakub@redhat.com> PR rtl-optimization/77919 * expr.c (expand_expr_real_1) <normal_inner_ref>: Only avoid forcing into memory if both modes are complex and their inner modes have the same precision. If the two modes are different complex modes, convert each part separately and generate a new CONCAT. * g++.dg/torture/pr77919-2.C: New test. --- gcc/expr.c (revision 243394) +++ gcc/expr.c (revision 243395) @@ -10198,8 +10198,35 @@ expand_expr_real_1 (tree exp, rtx target { if (bitpos == 0 && bitsize == GET_MODE_BITSIZE (GET_MODE (op0)) - && COMPLEX_MODE_P (mode1)) - return op0; + && COMPLEX_MODE_P (mode1) + && COMPLEX_MODE_P (GET_MODE (op0)) + && (GET_MODE_PRECISION (GET_MODE_INNER (mode1)) + == GET_MODE_PRECISION (GET_MODE_INNER (GET_MODE (op0))))) + { + if (mode1 != GET_MODE (op0)) + { + rtx parts[2]; + for (int i = 0; i < 2; i++) + { + rtx op = read_complex_part (op0, i != 0); + if (GET_CODE (op) == SUBREG) + op = force_reg (GET_MODE (op), op); + rtx temp = gen_lowpart_common (GET_MODE_INNER (mode1), + op); + if (temp) + op = temp; + else + { + if (!REG_P (op) && !MEM_P (op)) + op = force_reg (GET_MODE (op), op); + op = gen_lowpart (GET_MODE_INNER (mode1), op); + } + parts[i] = op; + } + op0 = gen_rtx_CONCAT (mode1, parts[0], parts[1]); + } + return op0; + } if (bitpos == 0 && bitsize == GET_MODE_BITSIZE (GET_MODE (XEXP (op0, 0))) && bitsize) --- gcc/testsuite/g++.dg/torture/pr77919-2.C (nonexistent) +++ gcc/testsuite/g++.dg/torture/pr77919-2.C (revision 243395) @@ -0,0 +1,10 @@ +// PR rtl-optimization/77919 +// { dg-do compile } + +typedef _Complex long long B; +struct A { A (double) {} _Complex double i; }; +typedef struct { B b; } C; +struct D { D (const B &x) : b (x) {} B b; }; +static inline B foo (const double *x) { C *a; a = (C *) x; return a->b; } +static inline D baz (const A &x) { return foo ((double *) &x); } +D b = baz (0); 2017-05-30 Jakub Jelinek <jakub@redhat.com> Backported from mainline 2016-10-31 Jakub Jelinek <jakub@redhat.com> PR c++/78089 * parser.c (cp_parser_postfix_expression): Replace return statement in the first switch with setting postfix_expression to the return expression and break;. * c-c++-common/builtin-shuffle-1.c: New test. --- gcc/cp/parser.c (revision 243395) +++ gcc/cp/parser.c (revision 243396) @@ -6404,7 +6404,10 @@ cp_parser_postfix_expression (cp_parser can be used in constant-expressions. */ if (!cast_valid_in_integral_constant_expression_p (type) && cp_parser_non_integral_constant_expression (parser, NIC_CAST)) - return error_mark_node; + { + postfix_expression = error_mark_node; + break; + } switch (keyword) { @@ -6484,7 +6487,7 @@ cp_parser_postfix_expression (cp_parser parser->type_definition_forbidden_message = saved_message; /* `typeid' may not appear in an integral constant expression. */ if (cp_parser_non_integral_constant_expression (parser, NIC_TYPEID)) - return error_mark_node; + postfix_expression = error_mark_node; } break; @@ -6576,23 +6579,28 @@ cp_parser_postfix_expression (cp_parser /*cast_p=*/false, /*allow_expansion_p=*/true, /*non_constant_p=*/NULL); if (vec == NULL) - return error_mark_node; + { + postfix_expression = error_mark_node; + break; + } FOR_EACH_VEC_ELT (*vec, i, p) mark_exp_read (p); if (vec->length () == 2) - return build_x_vec_perm_expr (loc, (*vec)[0], NULL_TREE, (*vec)[1], - tf_warning_or_error); + postfix_expression + = build_x_vec_perm_expr (loc, (*vec)[0], NULL_TREE, (*vec)[1], + tf_warning_or_error); else if (vec->length () == 3) - return build_x_vec_perm_expr (loc, (*vec)[0], (*vec)[1], (*vec)[2], - tf_warning_or_error); + postfix_expression + = build_x_vec_perm_expr (loc, (*vec)[0], (*vec)[1], (*vec)[2], + tf_warning_or_error); else - { - error_at (loc, "wrong number of arguments to " - "%<__builtin_shuffle%>"); - return error_mark_node; - } + { + error_at (loc, "wrong number of arguments to " + "%<__builtin_shuffle%>"); + postfix_expression = error_mark_node; + } break; } --- gcc/testsuite/c-c++-common/builtin-shuffle-1.c (nonexistent) +++ gcc/testsuite/c-c++-common/builtin-shuffle-1.c (revision 243396) @@ -0,0 +1,22 @@ +/* PR c++/78089 */ +/* { dg-do run } */ + +typedef int V __attribute__((vector_size (16))); +V a, b, c; + +int +foo () +{ + return __builtin_shuffle (a, b, c)[3]; +} + +int +main () +{ + a = (V) { 1, 2, 3, 4 }; + b = (V) { 5, 6, 7, 8 }; + c = (V) { 7, 2, 5, 6 }; + if (foo () != 7) + __builtin_abort (); + return 0; +} 2017-05-30 Jakub Jelinek <jakub@redhat.com> Backported from mainline 2016-11-01 Jakub Jelinek <jakub@redhat.com> * hashtab.h: Use standard GPLv3 with runtime exception boilerplate. --- libgomp/hashtab.h (revision 243396) +++ libgomp/hashtab.h (revision 243397) @@ -2,19 +2,27 @@ Copyright (C) 1999-2015 Free Software Foundation, Inc. Contributed by Vladimir Makarov <vmakarov@cygnus.com>. -This program 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 2 of the License, or -(at your option) any later version. - -This program 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 program; if not, write to the Free Software -Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */ + This file is part of the GNU Offloading and Multi Processing Library + (libgomp). + + Libgomp 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. + + Libgomp 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. + + Under Section 7 of GPL version 3, you are granted additional + permissions described in the GCC Runtime Library Exception, version + 3.1, as published by the Free Software Foundation. + + You should have received a copy of the GNU General Public License and + a copy of the GCC Runtime Library Exception along with this program; + see the files COPYING3 and COPYING.RUNTIME respectively. If not, see + <http://www.gnu.org/licenses/>. */ /* The hash table code copied from include/hashtab.[hc] and adjusted, so that the hash table entries are in the flexible array at the end 2017-05-30 Jakub Jelinek <jakub@redhat.com> Backported from mainline 2016-11-07 Jakub Jelinek <jakub@redhat.com> PR target/78227 * config/i386/i386.c (ix86_expand_sse_cmp): Force dest into cmp_mode argument even for -O0 if cmp_mode != mode and maskcmp. * gcc.target/i386/pr78227-1.c: New test. * gcc.target/i386/pr78227-2.c: New test. --- gcc/config/i386/i386.c (revision 243398) +++ gcc/config/i386/i386.c (revision 243399) @@ -21535,6 +21535,7 @@ ix86_expand_sse_cmp (rtx dest, enum rtx_ cmp_op1 = force_reg (cmp_ops_mode, cmp_op1); if (optimize + || (maskcmp && cmp_mode != mode) || reg_overlap_mentioned_p (dest, op_true) || reg_overlap_mentioned_p (dest, op_false)) dest = gen_reg_rtx (maskcmp ? cmp_mode : mode); --- gcc/testsuite/gcc.target/i386/pr78227-1.c (nonexistent) +++ gcc/testsuite/gcc.target/i386/pr78227-1.c (revision 243399) @@ -0,0 +1,30 @@ +/* PR target/78227 */ +/* { dg-do compile } */ +/* { dg-options "-mavx512f -O0 -Wno-psabi" } */ + +typedef int V __attribute__((vector_size (64))); +typedef long long int W __attribute__((vector_size (64))); + +V +foo1 (V v) +{ + return v > 0; +} + +V +bar1 (V v) +{ + return v != 0; +} + +W +foo2 (W w) +{ + return w > 0; +} + +W +bar2 (W w) +{ + return w != 0; +} --- gcc/testsuite/gcc.target/i386/pr78227-2.c (nonexistent) +++ gcc/testsuite/gcc.target/i386/pr78227-2.c (revision 243399) @@ -0,0 +1,30 @@ +/* PR target/78227 */ +/* { dg-do compile } */ +/* { dg-options "-mavx512bw -O0 -Wno-psabi" } */ + +typedef signed char V __attribute__((vector_size (64))); +typedef short int W __attribute__((vector_size (64))); + +V +foo1 (V v) +{ + return v > 0; +} + +V +bar1 (V v) +{ + return v != 0; +} + +W +foo2 (W w) +{ + return w > 0; +} + +W +bar2 (W w) +{ + return w != 0; +} 2017-05-30 Jakub Jelinek <jakub@redhat.com> Backported from mainline 2016-11-16 Jakub Jelinek <jakub@redhat.com> PR rtl-optimization/78378 * combine.c (make_extraction): Use force_to_mode for non-{REG,MEM} inner only if pos is 0. Fix up formatting. * gcc.c-torture/execute/pr78378.c: New test. --- gcc/combine.c (revision 243401) +++ gcc/combine.c (revision 243402) @@ -7369,6 +7369,7 @@ make_extraction (machine_mode mode, rtx if (tmode != BLKmode && ((pos_rtx == 0 && (pos % BITS_PER_WORD) == 0 && !MEM_P (inner) + && (pos == 0 || REG_P (inner)) && (inner_mode == tmode || !REG_P (inner) || TRULY_NOOP_TRUNCATION_MODES_P (tmode, inner_mode) @@ -7445,10 +7446,9 @@ make_extraction (machine_mode mode, rtx } else new_rtx = force_to_mode (inner, tmode, - len >= HOST_BITS_PER_WIDE_INT - ? ~(unsigned HOST_WIDE_INT) 0 - : ((unsigned HOST_WIDE_INT) 1 << len) - 1, - 0); + len >= HOST_BITS_PER_WIDE_INT + ? ~(unsigned HOST_WIDE_INT) 0 + : ((unsigned HOST_WIDE_INT) 1 << len) - 1, 0); /* If this extraction is going into the destination of a SET, make a STRICT_LOW_PART unless we made a MEM. */ --- gcc/testsuite/gcc.c-torture/execute/pr78378.c (nonexistent) +++ gcc/testsuite/gcc.c-torture/execute/pr78378.c (revision 243402) @@ -0,0 +1,18 @@ +/* PR rtl-optimization/78378 */ + +unsigned long long __attribute__ ((noinline, noclone)) +foo (unsigned long long x) +{ + x <<= 41; + x /= 232; + return 1 + (unsigned short) x; +} + +int +main () +{ + unsigned long long x = foo (1); + if (x != 0x2c24) + __builtin_abort(); + return 0; +} 2017-05-30 Jakub Jelinek <jakub@redhat.com> Backported from mainline 2016-11-18 Jakub Jelinek <jakub@redhat.com> PR c++/77285 * mangle.c (mangle_tls_init_fn, mangle_tls_wrapper_fn): Call check_abi_tags. * g++.dg/tls/pr77285-1.C: New test. * g++.dg/tls/pr77285-2.C: New test. --- gcc/cp/mangle.c (revision 243402) +++ gcc/cp/mangle.c (revision 243403) @@ -4068,6 +4068,7 @@ mangle_guard_variable (const tree variab tree mangle_tls_init_fn (const tree variable) { + check_abi_tags (variable); start_mangling (variable); write_string ("_ZTH"); write_guarded_var_name (variable); @@ -4082,6 +4083,7 @@ mangle_tls_init_fn (const tree variable) tree mangle_tls_wrapper_fn (const tree variable) { + check_abi_tags (variable); start_mangling (variable); write_string (TLS_WRAPPER_PREFIX); write_guarded_var_name (variable); --- gcc/testsuite/g++.dg/tls/pr77285-1.C (nonexistent) +++ gcc/testsuite/g++.dg/tls/pr77285-1.C (revision 243403) @@ -0,0 +1,7 @@ +// { dg-do link { target c++11 } } +// { dg-require-effective-target tls } +// { dg-additional-sources pr77285-2.C } + +struct __attribute__((abi_tag("tag"))) X { ~X () {} int i = 0; }; +thread_local X var1; +X var2; --- gcc/testsuite/g++.dg/tls/pr77285-2.C (nonexistent) +++ gcc/testsuite/g++.dg/tls/pr77285-2.C (revision 243403) @@ -0,0 +1,17 @@ +// PR c++/77285 +// { dg-do compile { target c++11 } } +// { dg-require-effective-target tls } +// { dg-final { scan-assembler "_Z4var1B3tag" } } +// { dg-final { scan-assembler "_Z4var2B3tag" } } +// { dg-final { scan-assembler "_ZTH4var1B3tag" } } +// { dg-final { scan-assembler "_ZTW4var1B3tag" } } + +struct __attribute__((abi_tag("tag"))) X { ~X () {} int i = 0; }; +extern thread_local X var1; +extern X var2; + +int +main () +{ + return var1.i + var2.i; +} 2017-05-30 Jakub Jelinek <jakub@redhat.com> Backported from mainline 2016-11-21 Jakub Jelinek <jakub@redhat.com> PR middle-end/67335 * omp-low.c (simd_clone_adjust_argument_types): Use NULL prefix for tmp simd array if DECL_NAME (parm) is NULL. * g++.dg/vect/simd-clone-7.cc: New test. --- gcc/omp-low.c (revision 243404) +++ gcc/omp-low.c (revision 243405) @@ -12946,7 +12946,9 @@ simd_clone_adjust_argument_types (struct if (node->definition) node->simdclone->args[i].simd_array - = create_tmp_simd_array (IDENTIFIER_POINTER (DECL_NAME (parm)), + = create_tmp_simd_array (DECL_NAME (parm) + ? IDENTIFIER_POINTER (DECL_NAME (parm)) + : NULL, parm_type, node->simdclone->simdlen); } adjustments.safe_push (adj); --- gcc/testsuite/g++.dg/vect/simd-clone-7.cc (nonexistent) +++ gcc/testsuite/g++.dg/vect/simd-clone-7.cc (revision 243405) @@ -0,0 +1,10 @@ +// PR middle-end/67335 +// { dg-do compile } +// { dg-additional-options "-fopenmp-simd" } + +#pragma omp declare simd notinbranch uniform(y) +float +bar (float x, float *y, int) +{ + return y[0] + y[1] * x; +} 2017-05-30 Jakub Jelinek <jakub@redhat.com> Backported from mainline 2016-11-22 Jakub Jelinek <jakub@redhat.com> PR middle-end/78416 * expmed.c (expand_divmod): Use wide_int for computation of op1_is_pow2. Don't set it if op1 is 0. Formatting fixes. Use size <= HOST_BITS_PER_WIDE_INT instead of HOST_BITS_PER_WIDE_INT >= size. * gcc.dg/torture/pr78416.c: New test. --- gcc/expmed.c (revision 243405) +++ gcc/expmed.c (revision 243406) @@ -4031,11 +4031,10 @@ expand_divmod (int rem_flag, enum tree_c op1_is_constant = CONST_INT_P (op1); if (op1_is_constant) { - unsigned HOST_WIDE_INT ext_op1 = UINTVAL (op1); - if (unsignedp) - ext_op1 &= GET_MODE_MASK (mode); - op1_is_pow2 = ((EXACT_POWER_OF_2_OR_ZERO_P (ext_op1) - || (! unsignedp && EXACT_POWER_OF_2_OR_ZERO_P (-ext_op1)))); + wide_int ext_op1 = rtx_mode_t (op1, mode); + op1_is_pow2 = (wi::popcount (ext_op1) == 1 + || (! unsignedp + && wi::popcount (wi::neg (ext_op1)) == 1)); } /* @@ -4116,11 +4115,10 @@ expand_divmod (int rem_flag, enum tree_c not straightforward to generalize this. Maybe we should make an array of possible modes in init_expmed? Save this for GCC 2.7. */ - optab1 = ((op1_is_pow2 && op1 != const0_rtx) + optab1 = (op1_is_pow2 ? (unsignedp ? lshr_optab : ashr_optab) : (unsignedp ? udiv_optab : sdiv_optab)); - optab2 = ((op1_is_pow2 && op1 != const0_rtx) - ? optab1 + optab2 = (op1_is_pow2 ? optab1 : (unsignedp ? udivmod_optab : sdivmod_optab)); for (compute_mode = mode; compute_mode != VOIDmode; @@ -4176,10 +4174,15 @@ expand_divmod (int rem_flag, enum tree_c /* convert_modes may have placed op1 into a register, so we must recompute the following. */ op1_is_constant = CONST_INT_P (op1); - op1_is_pow2 = (op1_is_constant - && ((EXACT_POWER_OF_2_OR_ZERO_P (INTVAL (op1)) - || (! unsignedp - && EXACT_POWER_OF_2_OR_ZERO_P (-UINTVAL (op1)))))); + if (op1_is_constant) + { + wide_int ext_op1 = rtx_mode_t (op1, compute_mode); + op1_is_pow2 = (wi::popcount (ext_op1) == 1 + || (! unsignedp + && wi::popcount (wi::neg (ext_op1)) == 1)); + } + else + op1_is_pow2 = 0; } /* If one of the operands is a volatile MEM, copy it into a register. */ @@ -4219,10 +4222,10 @@ expand_divmod (int rem_flag, enum tree_c unsigned HOST_WIDE_INT mh, ml; int pre_shift, post_shift; int dummy; - unsigned HOST_WIDE_INT d = (INTVAL (op1) - & GET_MODE_MASK (compute_mode)); + wide_int wd = rtx_mode_t (op1, compute_mode); + unsigned HOST_WIDE_INT d = wd.to_uhwi (); - if (EXACT_POWER_OF_2_OR_ZERO_P (d)) + if (wi::popcount (wd) == 1) { pre_shift = floor_log2 (d); if (rem_flag) @@ -4362,7 +4365,7 @@ expand_divmod (int rem_flag, enum tree_c else if (d == -1) quotient = expand_unop (compute_mode, neg_optab, op0, tquotient, 0); - else if (HOST_BITS_PER_WIDE_INT >= size + else if (size <= HOST_BITS_PER_WIDE_INT && abs_d == (unsigned HOST_WIDE_INT) 1 << (size - 1)) { /* This case is not handled correctly below. */ @@ -4372,6 +4375,7 @@ expand_divmod (int rem_flag, enum tree_c goto fail1; } else if (EXACT_POWER_OF_2_OR_ZERO_P (d) + && (size <= HOST_BITS_PER_WIDE_INT || d >= 0) && (rem_flag ? smod_pow2_cheap (speed, compute_mode) : sdiv_pow2_cheap (speed, compute_mode)) @@ -4385,7 +4389,9 @@ expand_divmod (int rem_flag, enum tree_c compute_mode) != CODE_FOR_nothing))) ; - else if (EXACT_POWER_OF_2_OR_ZERO_P (abs_d)) + else if (EXACT_POWER_OF_2_OR_ZERO_P (abs_d) + && (size <= HOST_BITS_PER_WIDE_INT + || abs_d != (unsigned HOST_WIDE_INT) d)) { if (rem_flag) { @@ -4520,7 +4526,7 @@ expand_divmod (int rem_flag, enum tree_c case FLOOR_DIV_EXPR: case FLOOR_MOD_EXPR: /* We will come here only for signed operations. */ - if (op1_is_constant && HOST_BITS_PER_WIDE_INT >= size) + if (op1_is_constant && size <= HOST_BITS_PER_WIDE_INT) { unsigned HOST_WIDE_INT mh, ml; int pre_shift, lgup, post_shift; @@ -4589,9 +4595,8 @@ expand_divmod (int rem_flag, enum tree_c op0, constm1_rtx), NULL_RTX); t2 = expand_binop (compute_mode, ior_optab, op0, t1, NULL_RTX, 0, OPTAB_WIDEN); - nsign = expand_shift - (RSHIFT_EXPR, compute_mode, t2, - size - 1, NULL_RTX, 0); + nsign = expand_shift (RSHIFT_EXPR, compute_mode, t2, + size - 1, NULL_RTX, 0); t3 = force_operand (gen_rtx_MINUS (compute_mode, t1, nsign), NULL_RTX); t4 = expand_divmod (0, TRUNC_DIV_EXPR, compute_mode, t3, op1, @@ -4700,7 +4705,10 @@ expand_divmod (int rem_flag, enum tree_c case CEIL_MOD_EXPR: if (unsignedp) { - if (op1_is_constant && EXACT_POWER_OF_2_OR_ZERO_P (INTVAL (op1))) + if (op1_is_constant + && EXACT_POWER_OF_2_OR_ZERO_P (INTVAL (op1)) + && (size <= HOST_BITS_PER_WIDE_INT + || INTVAL (op1) >= 0)) { rtx t1, t2, t3; unsigned HOST_WIDE_INT d = INTVAL (op1); @@ -4913,7 +4921,7 @@ expand_divmod (int rem_flag, enum tree_c break; case EXACT_DIV_EXPR: - if (op1_is_constant && HOST_BITS_PER_WIDE_INT >= size) + if (op1_is_constant && size <= HOST_BITS_PER_WIDE_INT) { HOST_WIDE_INT d = INTVAL (op1); unsigned HOST_WIDE_INT ml; --- gcc/testsuite/gcc.dg/torture/pr78416.c (nonexistent) +++ gcc/testsuite/gcc.dg/torture/pr78416.c (revision 243406) @@ -0,0 +1,17 @@ +/* PR middle-end/78416 */ +/* { dg-do run { target int128 } } */ + +int +main () +{ + unsigned __int128 x; + x = 0xFFFFFFFFFFFFFFFFULL; + x /= ~0x7FFFFFFFFFFFFFFFLL; + if (x != 0) + __builtin_abort (); + x = ~0x7FFFFFFFFFFFFFFELL; + x /= ~0x7FFFFFFFFFFFFFFFLL; + if (x != 1) + __builtin_abort (); + return 0; +} 2017-05-30 Jakub Jelinek <jakub@redhat.com> Backported from mainline 2016-11-23 Jakub Jelinek <jakub@redhat.com> PR c++/77739 * cp-gimplify.c (cp_gimplify_tree) <case VEC_INIT_EXPR>: Pass false as handle_invisiref_parm_p to cp_genericize_tree. (struct cp_genericize_data): Add handle_invisiref_parm_p field. (cp_genericize_r): Don't wrap is_invisiref_parm into references if !wtd->handle_invisiref_parm_p. (cp_genericize_tree): Add handle_invisiref_parm_p argument, set wtd.handle_invisiref_parm_p to it. (cp_genericize): Pass true as handle_invisiref_parm_p to cp_genericize_tree. Formatting fix. * g++.dg/cpp1y/pr77739.C: New test. --- gcc/cp/cp-gimplify.c (revision 243406) +++ gcc/cp/cp-gimplify.c (revision 243407) @@ -59,7 +59,7 @@ along with GCC; see the file COPYING3. /* Forward declarations. */ static tree cp_genericize_r (tree *, int *, void *); -static void cp_genericize_tree (tree*); +static void cp_genericize_tree (tree*, bool); /* Local declarations. */ @@ -592,7 +592,7 @@ cp_gimplify_expr (tree *expr_p, gimple_s init, VEC_INIT_EXPR_VALUE_INIT (*expr_p), from_array, tf_warning_or_error); - cp_genericize_tree (expr_p); + cp_genericize_tree (expr_p, false); ret = GS_OK; input_location = loc; } @@ -906,6 +906,7 @@ struct cp_genericize_data vec<tree> bind_expr_stack; struct cp_genericize_omp_taskreg *omp_ctx; bool no_sanitize_p; + bool handle_invisiref_parm_p; }; /* Perform any pre-gimplification lowering of C++ front end trees to @@ -926,7 +927,8 @@ cp_genericize_r (tree *stmt_p, int *walk && omp_var_to_track (stmt)) omp_cxx_notice_variable (wtd->omp_ctx, stmt); - if (is_invisiref_parm (stmt) + if (wtd->handle_invisiref_parm_p + && is_invisiref_parm (stmt) /* Don't dereference parms in a thunk, pass the references through. */ && !(DECL_THUNK_P (current_function_decl) && TREE_CODE (stmt) == PARM_DECL)) @@ -1279,7 +1281,7 @@ cp_genericize_r (tree *stmt_p, int *walk /* Lower C++ front end trees to GENERIC in T_P. */ static void -cp_genericize_tree (tree* t_p) +cp_genericize_tree (tree* t_p, bool handle_invisiref_parm_p) { struct cp_genericize_data wtd; @@ -1287,6 +1289,7 @@ cp_genericize_tree (tree* t_p) wtd.bind_expr_stack.create (0); wtd.omp_ctx = NULL; wtd.no_sanitize_p = false; + wtd.handle_invisiref_parm_p = handle_invisiref_parm_p; cp_walk_tree (t_p, cp_genericize_r, &wtd, NULL); delete wtd.p_set; wtd.bind_expr_stack.release (); @@ -1399,12 +1402,12 @@ cp_genericize (tree fndecl) /* Expand all the array notations here. */ if (flag_cilkplus && contains_array_notation_expr (DECL_SAVED_TREE (fndecl))) - DECL_SAVED_TREE (fndecl) = - expand_array_notation_exprs (DECL_SAVED_TREE (fndecl)); + DECL_SAVED_TREE (fndecl) + = expand_array_notation_exprs (DECL_SAVED_TREE (fndecl)); /* We do want to see every occurrence of the parms, so we can't just use walk_tree's hash functionality. */ - cp_genericize_tree (&DECL_SAVED_TREE (fndecl)); + cp_genericize_tree (&DECL_SAVED_TREE (fndecl), true); if (flag_sanitize & SANITIZE_RETURN && do_ubsan_in_current_function ()) --- gcc/testsuite/g++.dg/cpp1y/pr77739.C (nonexistent) +++ gcc/testsuite/g++.dg/cpp1y/pr77739.C (revision 243407) @@ -0,0 +1,15 @@ +// PR c++/77739 +// { dg-do compile { target c++14 } } + +struct A { + A(); + A(const A &); +}; +struct B { + B(); + template <typename... Args> auto g(Args &&... p1) { + return [=] { f(p1...); }; + } + void f(A, const char *); +}; +B::B() { g(A(), ""); } 2017-05-30 Jakub Jelinek <jakub@redhat.com> Backported from mainline 2016-11-23 Jakub Jelinek <jakub@redhat.com> PR middle-end/69183 * omp-low.c (build_outer_var_ref): Change lastprivate argument to code, pass it recursively, adjust uses. For OMP_CLAUSE_PRIVATE on worksharing constructs, treat it like clauses on simd construct. Formatting fix. (lower_rec_input_clauses): For OMP_CLAUSE_PRIVATE_OUTER_REF pass OMP_CLAUSE_PRIVATE as last argument to build_outer_var_ref. (lower_lastprivate_clauses): Pass OMP_CLAUSE_LASTPRIVATE instead of true as last argument to build_outer_var_ref. * gfortran.dg/gomp/pr69183.f90: New test. --- gcc/omp-low.c (revision 243407) +++ gcc/omp-low.c (revision 243408) @@ -1166,7 +1166,8 @@ build_receiver_ref (tree var, bool by_re this is some variable. */ static tree -build_outer_var_ref (tree var, omp_context *ctx) +build_outer_var_ref (tree var, omp_context *ctx, + enum omp_clause_code code = OMP_CLAUSE_ERROR) { tree x; @@ -1175,7 +1176,7 @@ build_outer_var_ref (tree var, omp_conte else if (is_variable_sized (var)) { x = TREE_OPERAND (DECL_VALUE_EXPR (var), 0); - x = build_outer_var_ref (x, ctx); + x = build_outer_var_ref (x, ctx, code); x = build_simple_mem_ref (x); } else if (is_taskreg_ctx (ctx)) @@ -1183,11 +1184,17 @@ build_outer_var_ref (tree var, omp_conte bool by_ref = use_pointer_for_field (var, NULL); x = build_receiver_ref (var, by_ref, ctx); } - else if (gimple_code (ctx->stmt) == GIMPLE_OMP_FOR - && gimple_omp_for_kind (ctx->stmt) & GF_OMP_FOR_SIMD) - { - /* #pragma omp simd isn't a worksharing construct, and can reference even - private vars in its linear etc. clauses. */ + else if ((gimple_code (ctx->stmt) == GIMPLE_OMP_FOR + && gimple_omp_for_kind (ctx->stmt) & GF_OMP_FOR_SIMD) + || (code == OMP_CLAUSE_PRIVATE + && (gimple_code (ctx->stmt) == GIMPLE_OMP_FOR + || gimple_code (ctx->stmt) == GIMPLE_OMP_SECTIONS + || gimple_code (ctx->stmt) == GIMPLE_OMP_SINGLE))) + { + /* #pragma omp simd isn't a worksharing construct, and can reference + even private vars in its linear etc. clauses. + Similarly for OMP_CLAUSE_PRIVATE with outer ref, that can refer + to private vars in all worksharing constructs. */ x = NULL_TREE; if (ctx->outer && is_taskreg_ctx (ctx)) x = lookup_decl (var, ctx->outer); @@ -3886,7 +3893,7 @@ lower_rec_input_clauses (tree clauses, g if (is_task_ctx (ctx)) x = build_receiver_ref (var, false, ctx); else - x = build_outer_var_ref (var, ctx); + x = build_outer_var_ref (var, ctx, OMP_CLAUSE_PRIVATE); } else x = NULL; --- gcc/testsuite/gfortran.dg/gomp/pr69183.f90 (nonexistent) +++ gcc/testsuite/gfortran.dg/gomp/pr69183.f90 (revision 243408) @@ -0,0 +1,11 @@ +! PR middle-end/69183 +! { dg-do compile } + +program pr69183 + integer, allocatable :: z + integer :: i + !$omp do private(z) + do i = 1, 2 + z = i + end do +end 2017-05-30 Jakub Jelinek <jakub@redhat.com> Backported from mainline 2016-11-28 Jakub Jelinek <jakub@redhat.com> PR fortran/78298 * tree-nested.c (convert_local_reference_stmt): After adding shared (FRAME.NN) clause to omp parallel, task or target, add it also to all outer omp parallel, task or target constructs. * gfortran.dg/gomp/pr78298.f90: New test. --- gcc/tree-nested.c (revision 243409) +++ gcc/tree-nested.c (revision 243410) @@ -1915,6 +1915,8 @@ convert_local_reference_stmt (gimple_stm struct nesting_info *info = (struct nesting_info *) wi->info; tree save_local_var_chain; bitmap save_suppress; + char save_static_chain_added; + bool frame_decl_added; gimple stmt = gsi_stmt (*gsi); switch (gimple_code (stmt)) @@ -1922,29 +1924,44 @@ convert_local_reference_stmt (gimple_stm case GIMPLE_OMP_PARALLEL: case GIMPLE_OMP_TASK: save_suppress = info->suppress_expansion; + frame_decl_added = false; if (convert_local_omp_clauses (gimple_omp_taskreg_clauses_ptr (stmt), wi)) { - tree c; + tree c = build_omp_clause (gimple_location (stmt), + OMP_CLAUSE_SHARED); (void) get_frame_type (info); - c = build_omp_clause (gimple_location (stmt), - OMP_CLAUSE_SHARED); OMP_CLAUSE_DECL (c) = info->frame_decl; OMP_CLAUSE_CHAIN (c) = gimple_omp_taskreg_clauses (stmt); gimple_omp_taskreg_set_clauses (stmt, c); + info->static_chain_added |= 4; + frame_decl_added = true; } save_local_var_chain = info->new_local_var_chain; + save_static_chain_added = info->static_chain_added; info->new_local_var_chain = NULL; + info->static_chain_added = 0; walk_body (convert_local_reference_stmt, convert_local_reference_op, info, gimple_omp_body_ptr (stmt)); + if ((info->static_chain_added & 4) != 0 && !frame_decl_added) + { + tree c = build_omp_clause (gimple_location (stmt), + OMP_CLAUSE_SHARED); + (void) get_frame_type (info); + OMP_CLAUSE_DECL (c) = info->frame_decl; + OMP_CLAUSE_CHAIN (c) = gimple_omp_taskreg_clauses (stmt); + info->static_chain_added |= 4; + gimple_omp_taskreg_set_clauses (stmt, c); + } if (info->new_local_var_chain) declare_vars (info->new_local_var_chain, gimple_seq_first_stmt (gimple_omp_body (stmt)), false); info->new_local_var_chain = save_local_var_chain; info->suppress_expansion = save_suppress; + info->static_chain_added |= save_static_chain_added; break; case GIMPLE_OMP_FOR: @@ -1985,29 +2002,46 @@ convert_local_reference_stmt (gimple_stm break; } save_suppress = info->suppress_expansion; + frame_decl_added = false; if (convert_local_omp_clauses (gimple_omp_target_clauses_ptr (stmt), wi)) { - tree c; + tree c = build_omp_clause (gimple_location (stmt), OMP_CLAUSE_MAP); (void) get_frame_type (info); - c = build_omp_clause (gimple_location (stmt), OMP_CLAUSE_MAP); OMP_CLAUSE_DECL (c) = info->frame_decl; OMP_CLAUSE_SET_MAP_KIND (c, GOMP_MAP_TOFROM); OMP_CLAUSE_SIZE (c) = DECL_SIZE_UNIT (info->frame_decl); OMP_CLAUSE_CHAIN (c) = gimple_omp_target_clauses (stmt); gimple_omp_target_set_clauses (as_a <gomp_target *> (stmt), c); + info->static_chain_added |= 4; + frame_decl_added = true; } save_local_var_chain = info->new_local_var_chain; + save_static_chain_added = info->static_chain_added; info->new_local_var_chain = NULL; + info->static_chain_added = 0; walk_body (convert_local_reference_stmt, convert_local_reference_op, info, gimple_omp_body_ptr (stmt)); + if ((info->static_chain_added & 4) != 0 && !frame_decl_added) + { + tree c = build_omp_clause (gimple_location (stmt), OMP_CLAUSE_MAP); + (void) get_frame_type (info); + OMP_CLAUSE_DECL (c) = info->frame_decl; + OMP_CLAUSE_SET_MAP_KIND (c, GOMP_MAP_TOFROM); + OMP_CLAUSE_SIZE (c) = DECL_SIZE_UNIT (info->frame_decl); + OMP_CLAUSE_CHAIN (c) = gimple_omp_target_clauses (stmt); + gimple_omp_target_set_clauses (as_a <gomp_target *> (stmt), c); + info->static_chain_added |= 4; + } + if (info->new_local_var_chain) declare_vars (info->new_local_var_chain, gimple_seq_first_stmt (gimple_omp_body (stmt)), false); info->new_local_var_chain = save_local_var_chain; info->suppress_expansion = save_suppress; + info->static_chain_added |= save_static_chain_added; break; case GIMPLE_OMP_TEAMS: --- gcc/testsuite/gfortran.dg/gomp/pr78298.f90 (nonexistent) +++ gcc/testsuite/gfortran.dg/gomp/pr78298.f90 (revision 243410) @@ -0,0 +1,28 @@ +! PR fortran/78298 +! { dg-do compile } +! { dg-additional-options "-O2" } + +program pr78298 + integer :: i, j, n + n = 2 + !$omp parallel + !$omp do + do i = 1, n + !$omp parallel + !$omp do + do j = 1, n + call sub(i) + end do + !$omp end parallel + end do + !$omp end parallel + !call unused() +contains + subroutine sub(x) + integer :: x + end + subroutine unused() + i = 0 + j = 0 + end +end 2017-05-30 Jakub Jelinek <jakub@redhat.com> Backported from mainline 2016-12-02 Jakub Jelinek <jakub@redhat.com> PR c++/78649 * pt.c (tsubst_init): Don't call build_value_init if decl's type is error_mark_node. * g++.dg/cpp0x/pr78649.C: New test. --- gcc/cp/pt.c (revision 243413) +++ gcc/cp/pt.c (revision 243414) @@ -13915,7 +13915,7 @@ tsubst_init (tree init, tree decl, tree init = tsubst_expr (init, args, complain, in_decl, false); - if (!init) + if (!init && TREE_TYPE (decl) != error_mark_node) { /* If we had an initializer but it instantiated to nothing, --- gcc/testsuite/g++.dg/cpp0x/pr78649.C (nonexistent) +++ gcc/testsuite/g++.dg/cpp0x/pr78649.C (revision 243414) @@ -0,0 +1,16 @@ +// PR c++/78649 +// { dg-do compile { target c++11 } } + +template <class> void foo (); +template <class T, class... U> +void +test () +{ + T t (foo<U>...); // { dg-error "declared void" } +} + +int +main () +{ + test<void> (); +} 2017-05-30 Jakub Jelinek <jakub@redhat.com> Backported from mainline 2016-12-13 Jakub Jelinek <jakub@redhat.com> PR c++/78761 * cp-demangle.c (cplus_demangle_type): Demangle Dc as decltype(auto). * testsuite/demangle-expected: Add test for decltype(auto). --- libiberty/cp-demangle.c (revision 243593) +++ libiberty/cp-demangle.c (revision 243594) @@ -2552,7 +2552,11 @@ cplus_demangle_type (struct d_info *di) /* auto */ ret = d_make_name (di, "auto", 4); break; - + case 'c': + /* decltype(auto) */ + ret = d_make_name (di, "decltype(auto)", 14); + break; + case 'f': /* 32-bit decimal floating point */ ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[26]); --- libiberty/testsuite/demangle-expected (revision 243593) +++ libiberty/testsuite/demangle-expected (revision 243594) @@ -4085,6 +4085,9 @@ decltype (new auto({parm#1})) f<int>(int _Z1fIiERDaRKT_S1_ auto& f<int>(int const&, int) --format=gnu-v3 +_Z1gIiEDcRKT_S0_ +decltype(auto) g<int>(int const&, int) +--format=gnu-v3 _Z1gILi1EEvR1AIXT_EER1BIXscbT_EE void g<1>(A<1>&, B<static_cast<bool>(1)>&) --format=gnu-v3 2017-05-30 Jakub Jelinek <jakub@redhat.com> Backported from mainline 2016-12-14 Wilco Dijkstra <wdijkstr@arm.com> Jakub Jelinek <jakub@redhat.com> PR target/78796 * config/aarch64/aarch64.c (aarch64_classify_symbol): Merge large model checks into switch. * gcc.dg/tls/pr78796.c: New test. --- gcc/config/aarch64/aarch64.c (revision 243645) +++ gcc/config/aarch64/aarch64.c (revision 243646) @@ -7069,9 +7069,6 @@ aarch64_classify_symbol (rtx x, rtx offs if (GET_CODE (x) == SYMBOL_REF) { - if (aarch64_cmodel == AARCH64_CMODEL_LARGE) - return SYMBOL_FORCE_TO_MEM; - if (aarch64_tls_symbol_p (x)) return aarch64_classify_tls_symbol (x); @@ -7110,6 +7107,9 @@ aarch64_classify_symbol (rtx x, rtx offs return SYMBOL_SMALL_GOT; return SYMBOL_SMALL_ABSOLUTE; + case AARCH64_CMODEL_LARGE: + return SYMBOL_FORCE_TO_MEM; + default: gcc_unreachable (); } --- gcc/testsuite/gcc.dg/tls/pr78796.c (nonexistent) +++ gcc/testsuite/gcc.dg/tls/pr78796.c (revision 243646) @@ -0,0 +1,32 @@ +/* PR target/78796 */ +/* { dg-do run } */ +/* { dg-options "-O2" } */ +/* { dg-additional-options "-mcmodel=large" { target aarch64-*-* } } */ +/* { dg-require-effective-target tls } */ + +struct S { int a, b, c, d, e; }; +struct S t; +__thread struct S s; + +__attribute__((used, noinline, noclone)) void +foo (int *x, int *y) +{ + asm volatile ("" : : "g" (x), "g" (y) : "memory"); + if (*x != 1 || *y != 2) + __builtin_abort (); +} + +__attribute__((used, noinline, noclone)) void +bar (void) +{ + foo (&t.c, &s.c); +} + +int +main () +{ + t.c = 1; + s.c = 2; + bar (); + return 0; +} 2017-05-30 Jakub Jelinek <jakub@redhat.com> Backported from mainline 2016-12-13 Jakub Jelinek <jakub@redhat.com> PR ipa/77905 * ipa-pure-const.c (cdtor_p): Return true for DECL_STATIC_{CON,DE}STRUCTOR even when it is DECL_LOOPING_CONST_OR_PURE_P. * g++.dg/ipa/pr77905.C: New test. --- gcc/ipa-pure-const.c (revision 243849) +++ gcc/ipa-pure-const.c (revision 243850) @@ -1160,7 +1160,8 @@ static bool cdtor_p (cgraph_node *n, void *) { if (DECL_STATIC_CONSTRUCTOR (n->decl) || DECL_STATIC_DESTRUCTOR (n->decl)) - return !TREE_READONLY (n->decl) && !DECL_PURE_P (n->decl); + return ((!TREE_READONLY (n->decl) && !DECL_PURE_P (n->decl)) + || DECL_LOOPING_CONST_OR_PURE_P (n->decl)); return false; } --- gcc/testsuite/g++.dg/ipa/pr77905.C (nonexistent) +++ gcc/testsuite/g++.dg/ipa/pr77905.C (revision 243850) @@ -0,0 +1,21 @@ +// PR ipa/77905 +// { dg-do compile } +// { dg-options "-O2" } + +struct A { + A(int); +}; +struct B : A { + B(); +} A; +struct C : virtual A { + C(int); +}; +A::A(int x) { + if (x) + A(0); +} + +B::B() : A(1) {} + +C::C(int) : A(1) {} 2017-05-30 Jakub Jelinek <jakub@redhat.com> Backported from mainline 2016-12-21 Jakub Jelinek <jakub@redhat.com> PR c/77767 * c-decl.c (grokdeclarator): If *expr is non-NULL, append expression to *expr instead of overwriting it. * gcc.c-torture/execute/pr77767.c: New test. --- gcc/c/c-decl.c (revision 243850) +++ gcc/c/c-decl.c (revision 243851) @@ -5400,11 +5400,21 @@ grokdeclarator (const struct c_declarato if (TREE_CODE (type) == ERROR_MARK) return error_mark_node; if (expr == NULL) - expr = &expr_dummy; + { + expr = &expr_dummy; + expr_dummy = NULL_TREE; + } if (expr_const_operands == NULL) expr_const_operands = &expr_const_operands_dummy; - *expr = declspecs->expr; + if (declspecs->expr) + { + if (*expr) + *expr = build2 (COMPOUND_EXPR, TREE_TYPE (declspecs->expr), *expr, + declspecs->expr); + else + *expr = declspecs->expr; + } *expr_const_operands = declspecs->expr_const_operands; if (decl_context == FUNCDEF) --- gcc/testsuite/gcc.c-torture/execute/pr77767.c (nonexistent) +++ gcc/testsuite/gcc.c-torture/execute/pr77767.c (revision 243851) @@ -0,0 +1,16 @@ +/* PR c/77767 */ + +void +foo (int a, int b[a++], int c, int d[c++]) +{ + if (a != 2 || c != 2) + __builtin_abort (); +} + +int +main () +{ + int e[10]; + foo (1, e, 1, e); + return 0; +} 2017-05-30 Jakub Jelinek <jakub@redhat.com> Backported from mainline 2016-12-21 Jakub Jelinek <jakub@redhat.com> PR fortran/78866 * openmp.c (resolve_omp_clauses): Diagnose assumed size arrays in OpenMP map, to and from clauses. * trans-openmp.c: Include diagnostic-core.h, temporarily redefining GCC_DIAG_STYLE to __gcc_tdiag__. (gfc_omp_finish_clause): Diagnose implicitly mapped assumed size arrays. * gfortran.dg/gomp/map-1.f90: Add expected error. * gfortran.dg/gomp/pr78866-1.f90: New test. * gfortran.dg/gomp/pr78866-2.f90: New test. --- gcc/fortran/openmp.c (revision 244548) +++ gcc/fortran/openmp.c (revision 244549) @@ -3166,6 +3166,11 @@ resolve_omp_clauses (gfc_code *code, loc else resolve_oacc_data_clauses (n->sym, *where, name); } + else if (list != OMP_LIST_DEPEND + && n->sym->as + && n->sym->as->type == AS_ASSUMED_SIZE) + gfc_error ("Assumed size array %qs in %s clause at %L", + n->sym->name, name, where); } if (list != OMP_LIST_DEPEND) --- gcc/fortran/trans-openmp.c (revision 244548) +++ gcc/fortran/trans-openmp.c (revision 244549) @@ -37,6 +37,11 @@ along with GCC; see the file COPYING3. #include "arith.h" #include "omp-low.h" #include "gomp-constants.h" +#undef GCC_DIAG_STYLE +#define GCC_DIAG_STYLE __gcc_tdiag__ +#include "diagnostic-core.h" +#undef GCC_DIAG_STYLE +#define GCC_DIAG_STYLE __gcc_gfc__ int ompws_flags; @@ -1028,6 +1033,21 @@ gfc_omp_finish_clause (tree c, gimple_se return; tree decl = OMP_CLAUSE_DECL (c); + + /* Assumed-size arrays can't be mapped implicitly, they have to be + mapped explicitly using array sections. */ + if (TREE_CODE (decl) == PARM_DECL + && GFC_ARRAY_TYPE_P (TREE_TYPE (decl)) + && GFC_TYPE_ARRAY_AKIND (TREE_TYPE (decl)) == GFC_ARRAY_UNKNOWN + && GFC_TYPE_ARRAY_UBOUND (TREE_TYPE (decl), + GFC_TYPE_ARRAY_RANK (TREE_TYPE (decl)) - 1) + == NULL) + { + error_at (OMP_CLAUSE_LOCATION (c), + "implicit mapping of assumed size array %qD", decl); + return; + } + tree c2 = NULL_TREE, c3 = NULL_TREE, c4 = NULL_TREE; if (POINTER_TYPE_P (TREE_TYPE (decl))) { --- gcc/testsuite/gfortran.dg/gomp/pr78866-1.f90 (nonexistent) +++ gcc/testsuite/gfortran.dg/gomp/pr78866-1.f90 (revision 244549) @@ -0,0 +1,19 @@ +! PR fortran/78866 +! { dg-do compile } + +subroutine pr78866(x) + integer :: x(*) +!$omp target map(x) ! { dg-error "Assumed size array" } + x(1) = 1 +!$omp end target +!$omp target data map(tofrom: x) ! { dg-error "Assumed size array" } +!$omp target update to(x) ! { dg-error "Assumed size array" } +!$omp target update from(x) ! { dg-error "Assumed size array" } +!$omp end target data +!$omp target map(x(:23)) ! { dg-bogus "Assumed size array" } + x(1) = 1 +!$omp end target +!$omp target map(x(:)) ! { dg-error "upper bound of assumed size array section" } + x(1) = 1 ! { dg-error "not a proper array section" "" { target *-*-* } 16 } +!$omp end target +end --- gcc/testsuite/gfortran.dg/gomp/pr78866-2.f90 (nonexistent) +++ gcc/testsuite/gfortran.dg/gomp/pr78866-2.f90 (revision 244549) @@ -0,0 +1,9 @@ +! PR fortran/78866 +! { dg-do compile } + +subroutine pr78866(x) + integer :: x(*) +!$omp target ! { dg-error "implicit mapping of assumed size array" } + x(1) = 1 +!$omp end target +end --- gcc/testsuite/gfortran.dg/gomp/map-1.f90 (revision 244548) +++ gcc/testsuite/gfortran.dg/gomp/map-1.f90 (revision 244549) @@ -70,7 +70,7 @@ subroutine test(aas) ! { dg-error "Rightmost upper bound of assumed size array section not specified" "" { target *-*-* } 68 } ! { dg-error "'aas' in MAP clause at \\\(1\\\) is not a proper array section" "" { target *-*-* } 68 } - !$omp target map(aas) ! { dg-error "The upper bound in the last dimension must appear" "" { xfail *-*-* } } + !$omp target map(aas) ! { dg-error "Assumed size array" } !$omp end target !$omp target map(aas(5:7)) 2017-05-30 Jakub Jelinek <jakub@redhat.com> Backported from mainline 2017-01-04 Jakub Jelinek <jakub@redhat.com> PR c++/78949 * typeck.c (cp_build_unary_op): Call mark_rvalue_use on arg if it has vector type. * c-c++-common/Wunused-var-16.c: New test. --- gcc/cp/typeck.c (revision 244551) +++ gcc/cp/typeck.c (revision 244552) @@ -5848,6 +5848,8 @@ cp_build_unary_op (enum tree_code code, errstring = _("wrong type argument to bit-complement"); else if (!noconvert && CP_INTEGRAL_TYPE_P (TREE_TYPE (arg))) arg = cp_perform_integral_promotions (arg, complain); + else if (!noconvert && VECTOR_TYPE_P (TREE_TYPE (arg))) + arg = mark_rvalue_use (arg); break; case ABS_EXPR: --- gcc/testsuite/c-c++-common/Wunused-var-16.c (nonexistent) +++ gcc/testsuite/c-c++-common/Wunused-var-16.c (revision 244552) @@ -0,0 +1,15 @@ +/* PR c++/78949 */ +/* { dg-do compile } */ +/* { dg-options "-Wunused" } */ + +typedef unsigned char V __attribute__((vector_size(16))); +V v; + +void +foo () +{ + V y = {}; + V x = {}; // { dg-bogus "set but not used" } + y &= ~x; + v = y; +} 2017-05-30 Jakub Jelinek <jakub@redhat.com> Backported from mainline 2017-01-11 Jakub Jelinek <jakub@redhat.com> PR middle-end/50199 * lto-lang.c (lto_post_options): Force flag_merge_constants = 1 if it was 0. * gcc.dg/lto/pr50199_0.c: New test. --- gcc/lto/lto-lang.c (revision 244552) +++ gcc/lto/lto-lang.c (revision 244553) @@ -852,6 +852,12 @@ lto_post_options (const char **pfilename support. */ flag_excess_precision_cmdline = EXCESS_PRECISION_FAST; + /* When partitioning, we can tear appart STRING_CSTs uses from the same + TU into multiple partitions. Without constant merging the constants + might not be equal at runtime. See PR50199. */ + if (!flag_merge_constants) + flag_merge_constants = 1; + /* Initialize the compiler back end. */ return false; } --- gcc/testsuite/gcc.dg/lto/pr50199_0.c (nonexistent) +++ gcc/testsuite/gcc.dg/lto/pr50199_0.c (revision 244553) @@ -0,0 +1,17 @@ +/* PR middle-end/50199 */ +/* { dg-lto-options {{-O2 -flto -fno-merge-constants --param=lto-min-partition=1}} } */ + +__attribute__ ((noinline)) const char * +foo (const char *x) +{ + return x; +} + +int +main () +{ + const char *a = "ab"; + if (a != foo (a)) + __builtin_abort (); + return 0; +} 2017-05-30 Jakub Jelinek <jakub@redhat.com> Backported from mainline 2017-01-11 Jakub Jelinek <jakub@redhat.com> PR c++/78341 * parser.c (cp_parser_std_attribute_spec): Remove over-eager assertion. Formatting fix. * g++.dg/cpp0x/pr78341.C: New test. --- gcc/cp/parser.c (revision 244553) +++ gcc/cp/parser.c (revision 244554) @@ -24142,11 +24142,7 @@ cp_parser_std_attribute_spec (cp_parser if (!cp_parser_parse_definitely (parser)) { - gcc_assert (alignas_expr == error_mark_node - || alignas_expr == NULL_TREE); - - alignas_expr = - cp_parser_assignment_expression (parser); + alignas_expr = cp_parser_assignment_expression (parser); if (alignas_expr == error_mark_node) cp_parser_skip_to_end_of_statement (parser); if (alignas_expr == NULL_TREE --- gcc/testsuite/g++.dg/cpp0x/pr78341.C (nonexistent) +++ gcc/testsuite/g++.dg/cpp0x/pr78341.C (revision 244554) @@ -0,0 +1,4 @@ +// PR c++/78341 +// { dg-do compile { target c++11 } } + +alignas (alignas double // { dg-error "" } 2017-05-30 Jakub Jelinek <jakub@redhat.com> Backported from mainline 2017-02-02 Jakub Jelinek <jakub@redhat.com> PR target/79197 * config/rs6000/rs6000.md (*fixuns_trunc<mode>di2_fctiduz): Rename to ... (fixuns_trunc<mode>di2): ... this, remove previous expander. Put all conditions on a single line. * gcc.target/powerpc/pr79197.c: New test. * gcc.c-torture/compile/pr79197.c: New test. --- gcc/config/rs6000/rs6000.md (revision 245466) +++ gcc/config/rs6000/rs6000.md (revision 245467) @@ -5429,17 +5429,10 @@ (define_insn_and_split "fixuns_trunc<mod [(set_attr "length" "12") (set_attr "type" "fp")]) -(define_expand "fixuns_trunc<mode>di2" - [(set (match_operand:DI 0 "register_operand" "") - (unsigned_fix:DI (match_operand:SFDF 1 "register_operand" "")))] - "TARGET_HARD_FLOAT && (TARGET_FCTIDUZ || VECTOR_UNIT_VSX_P (<MODE>mode))" - "") - -(define_insn "*fixuns_trunc<mode>di2_fctiduz" +(define_insn "fixuns_trunc<mode>di2" [(set (match_operand:DI 0 "gpc_reg_operand" "=d,wi") (unsigned_fix:DI (match_operand:SFDF 1 "gpc_reg_operand" "<Ff>,<Fa>")))] - "TARGET_HARD_FLOAT && TARGET_DOUBLE_FLOAT && TARGET_FPRS - && TARGET_FCTIDUZ" + "TARGET_HARD_FLOAT && TARGET_DOUBLE_FLOAT && TARGET_FPRS && TARGET_FCTIDUZ" "@ fctiduz %0,%1 xscvdpuxds %x0,%x1" --- gcc/testsuite/gcc.target/powerpc/pr79197.c (nonexistent) +++ gcc/testsuite/gcc.target/powerpc/pr79197.c (revision 245467) @@ -0,0 +1,11 @@ +/* PR target/79197 */ +/* { dg-do compile } */ +/* { dg-options "-O0 -mno-popcntd" } */ + +unsigned a; + +void +foo (void) +{ + a = *(double *) (__UINTPTR_TYPE__) 0x400000; +} --- gcc/testsuite/gcc.c-torture/compile/pr79197.c (nonexistent) +++ gcc/testsuite/gcc.c-torture/compile/pr79197.c (revision 245467) @@ -0,0 +1,10 @@ +/* PR target/79197 */ + +unsigned long b; + +unsigned long +foo (float *a, float *x) +{ + __builtin_memcpy (a, x, sizeof (float)); + return *a; +} 2017-05-30 Jakub Jelinek <jakub@redhat.com> Backported from mainline 2017-02-07 Jakub Jelinek <jakub@redhat.com> Richard Biener <rguenther@suse.de> PR middle-end/79399 * ira-int.h (struct target_ira_int): Change x_max_struct_costs_size type from int to size_t. * ira-costs.c (struct_costs_size): Change type from int to size_t. --- gcc/ira-int.h (revision 245469) +++ gcc/ira-int.h (revision 245470) @@ -782,7 +782,7 @@ struct target_ira_int { /* Initialized once. It is a maximal possible size of the allocated struct costs. */ - int x_max_struct_costs_size; + size_t x_max_struct_costs_size; /* Allocated and initialized once, and used to initialize cost values for each insn. */ --- gcc/ira-costs.c (revision 245469) +++ gcc/ira-costs.c (revision 245470) @@ -73,7 +73,7 @@ static struct costs *costs; static struct costs *total_allocno_costs; /* It is the current size of struct costs. */ -static int struct_costs_size; +static size_t struct_costs_size; /* Return pointer to structure containing costs of allocno or pseudo with given NUM in array ARR. */ 2017-05-30 Jakub Jelinek <jakub@redhat.com> Backported from mainline 2017-02-10 Jakub Jelinek <jakub@redhat.com> PR tree-optimization/79411 * tree-ssa-reassoc.c (is_reassociable_op): Return false if stmt operands are SSA_NAMEs used in abnormal phis. (can_reassociate_p): Return false if op is SSA_NAME used in abnormal phis. * gcc.c-torture/compile/pr79411.c: New test. --- gcc/tree-ssa-reassoc.c (revision 245472) +++ gcc/tree-ssa-reassoc.c (revision 245473) @@ -663,7 +663,18 @@ is_reassociable_op (gimple stmt, enum tr if (is_gimple_assign (stmt) && gimple_assign_rhs_code (stmt) == code && has_single_use (gimple_assign_lhs (stmt))) - return true; + { + tree rhs1 = gimple_assign_rhs1 (stmt); + tree rhs2 = gimple_assign_rhs1 (stmt); + if (TREE_CODE (rhs1) == SSA_NAME + && SSA_NAME_OCCURS_IN_ABNORMAL_PHI (rhs1)) + return false; + if (rhs2 + && TREE_CODE (rhs2) == SSA_NAME + && SSA_NAME_OCCURS_IN_ABNORMAL_PHI (rhs2)) + return false; + return true; + } return false; } @@ -4342,6 +4353,8 @@ static bool can_reassociate_p (tree op) { tree type = TREE_TYPE (op); + if (TREE_CODE (op) == SSA_NAME && SSA_NAME_OCCURS_IN_ABNORMAL_PHI (op)) + return false; if ((INTEGRAL_TYPE_P (type) && TYPE_OVERFLOW_WRAPS (type)) || NON_SAT_FIXED_POINT_TYPE_P (type) || (flag_associative_math && FLOAT_TYPE_P (type))) --- gcc/testsuite/gcc.c-torture/compile/pr79411.c (nonexistent) +++ gcc/testsuite/gcc.c-torture/compile/pr79411.c (revision 245473) @@ -0,0 +1,22 @@ +/* PR tree-optimization/79411 */ + +typedef struct __jmp_buf_tag { char buf[1024]; } jmp_buf[1]; +extern int setjmp (jmp_buf); +extern int bar (unsigned int *); +extern jmp_buf *baz (void); +struct C { int c1; unsigned int c2, c3, c4; }; + +void +foo (struct C *x, const int *y, unsigned int *z, unsigned int e, unsigned int g) +{ + unsigned int d = 0; + unsigned long f; + setjmp (*baz ()); + f = 1 + d; + if ((x->c1 || x->c2) && g && (!e || d >= 8)) + d = 16; + else + d = 8; + if ((!x->c3 && !x->c4 || *y == 0) && !e && bar (z)) + *z = 1 + f; +} 2017-05-30 Jakub Jelinek <jakub@redhat.com> Backported from mainline 2017-02-16 Jakub Jelinek <jakub@redhat.com> PR c++/79512 * c-parser.c (c_parser_omp_target): For -fopenmp-simd ignore #pragma omp target even when not followed by identifier. * parser.c (cp_parser_omp_target): For -fopenmp-simd ignore #pragma omp target even when not followed by identifier. * c-c++-common/gomp/pr79512.c: New test. --- gcc/c/c-parser.c (revision 247666) +++ gcc/c/c-parser.c (revision 247667) @@ -13980,6 +13980,11 @@ c_parser_omp_target (c_parser *parser, e } } + if (!flag_openmp) /* flag_openmp_simd */ + { + c_parser_skip_to_pragma_eol (parser, false); + return false; + } tree stmt = make_node (OMP_TARGET); TREE_TYPE (stmt) = void_type_node; --- gcc/cp/parser.c (revision 247666) +++ gcc/cp/parser.c (revision 247667) @@ -31566,6 +31566,11 @@ cp_parser_omp_target (cp_parser *parser, } } + if (!flag_openmp) /* flag_openmp_simd */ + { + cp_parser_skip_to_pragma_eol (parser, pragma_tok); + return false; + } tree stmt = make_node (OMP_TARGET); TREE_TYPE (stmt) = void_type_node; --- gcc/testsuite/c-c++-common/gomp/pr79512.c (nonexistent) +++ gcc/testsuite/c-c++-common/gomp/pr79512.c (revision 247667) @@ -0,0 +1,14 @@ +/* PR c++/79512 */ +/* { dg-options "-fopenmp-simd" } */ + +void +foo (void) +{ + #pragma omp target + #pragma omp teams + { + int i; + for (i = 0; i < 10; i++) + ; + } +} 2017-05-30 Jakub Jelinek <jakub@redhat.com> Backported from mainline 2017-02-18 Jakub Jelinek <jakub@redhat.com> PR target/79559 * config/i386/i386.c (ix86_print_operand): Use output_operand_lossage instead of gcc_assert for K, r and R code checks. Formatting fixes. * gcc.target/i386/pr79559.c: New test. --- gcc/config/i386/i386.c (revision 247667) +++ gcc/config/i386/i386.c (revision 247668) @@ -16812,8 +16812,8 @@ ix86_print_operand (FILE *file, rtx x, i break; default: - output_operand_lossage - ("invalid operand size for operand code 'O'"); + output_operand_lossage ("invalid operand size for operand " + "code 'O'"); return; } @@ -16847,15 +16847,14 @@ ix86_print_operand (FILE *file, rtx x, i return; default: - output_operand_lossage - ("invalid operand size for operand code 'z'"); + output_operand_lossage ("invalid operand size for operand " + "code 'z'"); return; } } if (GET_MODE_CLASS (GET_MODE (x)) == MODE_FLOAT) - warning - (0, "non-integer operand used with operand code 'z'"); + warning (0, "non-integer operand used with operand code 'z'"); /* FALLTHRU */ case 'Z': @@ -16917,13 +16916,12 @@ ix86_print_operand (FILE *file, rtx x, i } else { - output_operand_lossage - ("invalid operand type used with operand code 'Z'"); + output_operand_lossage ("invalid operand type used with " + "operand code 'Z'"); return; } - output_operand_lossage - ("invalid operand size for operand code 'Z'"); + output_operand_lossage ("invalid operand size for operand code 'Z'"); return; case 'd': @@ -17115,7 +17113,12 @@ ix86_print_operand (FILE *file, rtx x, i break; case 'K': - gcc_assert (CONST_INT_P (x)); + if (!CONST_INT_P (x)) + { + output_operand_lossage ("operand is not an integer, invalid " + "operand code 'K'"); + return; + } if (INTVAL (x) & IX86_HLE_ACQUIRE) #ifdef HAVE_AS_IX86_HLE @@ -17138,8 +17141,12 @@ ix86_print_operand (FILE *file, rtx x, i return; case 'r': - gcc_assert (CONST_INT_P (x)); - gcc_assert (INTVAL (x) == ROUND_SAE); + if (!CONST_INT_P (x) || INTVAL (x) != ROUND_SAE) + { + output_operand_lossage ("operand is not a specific integer, " + "invalid operand code 'r'"); + return; + } if (ASSEMBLER_DIALECT == ASM_INTEL) fputs (", ", file); @@ -17152,7 +17159,12 @@ ix86_print_operand (FILE *file, rtx x, i return; case 'R': - gcc_assert (CONST_INT_P (x)); + if (!CONST_INT_P (x)) + { + output_operand_lossage ("operand is not an integer, invalid " + "operand code 'R'"); + return; + } if (ASSEMBLER_DIALECT == ASM_INTEL) fputs (", ", file); @@ -17267,7 +17279,7 @@ ix86_print_operand (FILE *file, rtx x, i return; default: - output_operand_lossage ("invalid operand code '%c'", code); + output_operand_lossage ("invalid operand code '%c'", code); } } --- gcc/testsuite/gcc.target/i386/pr79559.c (nonexistent) +++ gcc/testsuite/gcc.target/i386/pr79559.c (revision 247668) @@ -0,0 +1,11 @@ +/* PR target/79559 */ +/* { dg-do compile } */ + +void +foo (int x) +{ + __asm__ volatile ("# %K0" : : "r" (x)); /* { dg-error "invalid operand code" } */ + __asm__ volatile ("# %r0" : : "r" (x)); /* { dg-error "invalid operand code" } */ + __asm__ volatile ("# %r0" : : "n" (129)); /* { dg-error "invalid operand code" } */ + __asm__ volatile ("# %R0" : : "r" (x)); /* { dg-error "invalid operand code" } */ +} 2017-05-30 Jakub Jelinek <jakub@redhat.com> Backported from mainline 2017-02-20 Jakub Jelinek <jakub@redhat.com> PR target/79568 * config/i386/i386.c (ix86_expand_builtin): Handle OPTION_MASK_ISA_AVX512VL and OPTION_MASK_ISA_64BIT in ix86_builtins_isa[fcode].isa as a requirement of those flags and any other flag in the bitmask. (ix86_init_mmx_sse_builtins): Use 0 instead of ~OPTION_MASK_ISA_64BIT as mask. * config/i386/i386-builtin.def (bdesc_special_args, bdesc_args): Likewise. * gcc.target/i386/pr79568-1.c: New test. * gcc.target/i386/pr79568-2.c: New test. * gcc.target/i386/pr79568-3.c: New test. --- gcc/config/i386/i386.c (revision 247668) +++ gcc/config/i386/i386.c (revision 247669) @@ -32727,9 +32727,9 @@ static const struct builtin_description /* Special builtins with variable number of arguments. */ static const struct builtin_description bdesc_special_args[] = { - { ~OPTION_MASK_ISA_64BIT, CODE_FOR_nothing, "__builtin_ia32_rdtsc", IX86_BUILTIN_RDTSC, UNKNOWN, (int) UINT64_FTYPE_VOID }, - { ~OPTION_MASK_ISA_64BIT, CODE_FOR_nothing, "__builtin_ia32_rdtscp", IX86_BUILTIN_RDTSCP, UNKNOWN, (int) UINT64_FTYPE_PUNSIGNED }, - { ~OPTION_MASK_ISA_64BIT, CODE_FOR_pause, "__builtin_ia32_pause", IX86_BUILTIN_PAUSE, UNKNOWN, (int) VOID_FTYPE_VOID }, + { 0, CODE_FOR_nothing, "__builtin_ia32_rdtsc", IX86_BUILTIN_RDTSC, UNKNOWN, (int) UINT64_FTYPE_VOID }, + { 0, CODE_FOR_nothing, "__builtin_ia32_rdtscp", IX86_BUILTIN_RDTSCP, UNKNOWN, (int) UINT64_FTYPE_PUNSIGNED }, + { 0, CODE_FOR_pause, "__builtin_ia32_pause", IX86_BUILTIN_PAUSE, UNKNOWN, (int) VOID_FTYPE_VOID }, /* 80387 (for use internally for atomic compound assignment). */ { 0, CODE_FOR_fnstenv, "__builtin_ia32_fnstenv", IX86_BUILTIN_FNSTENV, UNKNOWN, (int) VOID_FTYPE_PVOID }, @@ -33024,13 +33024,13 @@ static const struct builtin_description /* Builtins with variable number of arguments. */ static const struct builtin_description bdesc_args[] = { - { ~OPTION_MASK_ISA_64BIT, CODE_FOR_bsr, "__builtin_ia32_bsrsi", IX86_BUILTIN_BSRSI, UNKNOWN, (int) INT_FTYPE_INT }, + { 0, CODE_FOR_bsr, "__builtin_ia32_bsrsi", IX86_BUILTIN_BSRSI, UNKNOWN, (int) INT_FTYPE_INT }, { OPTION_MASK_ISA_64BIT, CODE_FOR_bsr_rex64, "__builtin_ia32_bsrdi", IX86_BUILTIN_BSRDI, UNKNOWN, (int) INT64_FTYPE_INT64 }, - { ~OPTION_MASK_ISA_64BIT, CODE_FOR_nothing, "__builtin_ia32_rdpmc", IX86_BUILTIN_RDPMC, UNKNOWN, (int) UINT64_FTYPE_INT }, - { ~OPTION_MASK_ISA_64BIT, CODE_FOR_rotlqi3, "__builtin_ia32_rolqi", IX86_BUILTIN_ROLQI, UNKNOWN, (int) UINT8_FTYPE_UINT8_INT }, - { ~OPTION_MASK_ISA_64BIT, CODE_FOR_rotlhi3, "__builtin_ia32_rolhi", IX86_BUILTIN_ROLHI, UNKNOWN, (int) UINT16_FTYPE_UINT16_INT }, - { ~OPTION_MASK_ISA_64BIT, CODE_FOR_rotrqi3, "__builtin_ia32_rorqi", IX86_BUILTIN_RORQI, UNKNOWN, (int) UINT8_FTYPE_UINT8_INT }, - { ~OPTION_MASK_ISA_64BIT, CODE_FOR_rotrhi3, "__builtin_ia32_rorhi", IX86_BUILTIN_RORHI, UNKNOWN, (int) UINT16_FTYPE_UINT16_INT }, + { 0, CODE_FOR_nothing, "__builtin_ia32_rdpmc", IX86_BUILTIN_RDPMC, UNKNOWN, (int) UINT64_FTYPE_INT }, + { 0, CODE_FOR_rotlqi3, "__builtin_ia32_rolqi", IX86_BUILTIN_ROLQI, UNKNOWN, (int) UINT8_FTYPE_UINT8_INT }, + { 0, CODE_FOR_rotlhi3, "__builtin_ia32_rolhi", IX86_BUILTIN_ROLHI, UNKNOWN, (int) UINT16_FTYPE_UINT16_INT }, + { 0, CODE_FOR_rotrqi3, "__builtin_ia32_rorqi", IX86_BUILTIN_RORQI, UNKNOWN, (int) UINT8_FTYPE_UINT8_INT }, + { 0, CODE_FOR_rotrhi3, "__builtin_ia32_rorhi", IX86_BUILTIN_RORHI, UNKNOWN, (int) UINT16_FTYPE_UINT16_INT }, /* MMX */ { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_addv8qi3, "__builtin_ia32_paddb", IX86_BUILTIN_PADDB, UNKNOWN, (int) V8QI_FTYPE_V8QI_V8QI }, @@ -36097,11 +36097,11 @@ ix86_init_mmx_sse_builtins (void) IX86_BUILTIN_SBB64); /* Read/write FLAGS. */ - def_builtin (~OPTION_MASK_ISA_64BIT, "__builtin_ia32_readeflags_u32", + def_builtin (0, "__builtin_ia32_readeflags_u32", UNSIGNED_FTYPE_VOID, IX86_BUILTIN_READ_FLAGS); def_builtin (OPTION_MASK_ISA_64BIT, "__builtin_ia32_readeflags_u64", UINT64_FTYPE_VOID, IX86_BUILTIN_READ_FLAGS); - def_builtin (~OPTION_MASK_ISA_64BIT, "__builtin_ia32_writeeflags_u32", + def_builtin (0, "__builtin_ia32_writeeflags_u32", VOID_FTYPE_UNSIGNED, IX86_BUILTIN_WRITE_FLAGS); def_builtin (OPTION_MASK_ISA_64BIT, "__builtin_ia32_writeeflags_u64", VOID_FTYPE_UINT64, IX86_BUILTIN_WRITE_FLAGS); @@ -40530,9 +40530,18 @@ ix86_expand_builtin (tree exp, rtx targe Originally the builtin was not created if it wasn't applicable to the current ISA based on the command line switches. With function specific options, we need to check in the context of the function making the call - whether it is supported. */ - if (ix86_builtins_isa[fcode].isa - && !(ix86_builtins_isa[fcode].isa & ix86_isa_flags)) + whether it is supported. Treat AVX512VL specially. For other flags, + if isa includes more than one ISA bit, treat those are requiring any + of them. For AVX512VL, require both AVX512VL and the non-AVX512VL + ISAs. Similarly for 64BIT, but we shouldn't be building such builtins + at all, -m64 is a whole TU option. */ + if (((ix86_builtins_isa[fcode].isa + & ~(OPTION_MASK_ISA_AVX512VL | OPTION_MASK_ISA_64BIT)) + && !(ix86_builtins_isa[fcode].isa + & ~(OPTION_MASK_ISA_AVX512VL | OPTION_MASK_ISA_64BIT) + & ix86_isa_flags)) + || ((ix86_builtins_isa[fcode].isa & OPTION_MASK_ISA_AVX512VL) + && !(ix86_isa_flags & OPTION_MASK_ISA_AVX512VL))) { char *opts = ix86_target_string (ix86_builtins_isa[fcode].isa, 0, NULL, NULL, (enum fpmath_unit) 0, false); --- gcc/testsuite/gcc.target/i386/pr79568-1.c (nonexistent) +++ gcc/testsuite/gcc.target/i386/pr79568-1.c (revision 247669) @@ -0,0 +1,18 @@ +/* PR target/79568 */ +/* { dg-do compile } */ +/* { dg-options "-mno-avx512vl -mavx512bw -O2" } */ + +#pragma GCC push_options +#pragma GCC target ("avx512vl,avx512bw") +void +foo (char __attribute__ ((__vector_size__(32))) *x, char __attribute__ ((__vector_size__(32))) *y, int z) +{ + __builtin_ia32_storedquqi256_mask (x, *y, z); +} +#pragma GCC pop_options + +void +bar (char __attribute__ ((__vector_size__(32))) *x, char __attribute__ ((__vector_size__(32))) *y, int z) +{ + __builtin_ia32_storedquqi256_mask (x, *y, z); /* { dg-error "needs isa option" } */ +} --- gcc/testsuite/gcc.target/i386/pr79568-2.c (nonexistent) +++ gcc/testsuite/gcc.target/i386/pr79568-2.c (revision 247669) @@ -0,0 +1,18 @@ +/* PR target/79568 */ +/* { dg-do compile { target lp64 } } */ +/* { dg-options "-mno-lwp" } */ + +#pragma GCC push_options +#pragma GCC target ("lwp") +void +foo (unsigned long x, unsigned int y) +{ + __builtin_ia32_lwpval64 (x, y, 1); +} +#pragma GCC pop_options + +void +bar (unsigned long x, unsigned int y) +{ + __builtin_ia32_lwpval64 (x, y, 1); /* { dg-error "needs isa option" } */ +} --- gcc/testsuite/gcc.target/i386/pr79568-3.c (nonexistent) +++ gcc/testsuite/gcc.target/i386/pr79568-3.c (revision 247669) @@ -0,0 +1,19 @@ +/* PR target/79568 */ +/* { dg-do compile } */ +/* { dg-options "-mno-sahf -mno-mmx -mno-sse" } */ +/* { dg-additional-options "-march=i386" { target ia32 } } */ + +#pragma GCC push_options +#pragma GCC target ("sse") +void +foo (void) +{ + __builtin_ia32_pause (); +} +#pragma GCC pop_options + +void +bar (void) +{ + __builtin_ia32_pause (); +} 2017-05-30 Jakub Jelinek <jakub@redhat.com> Backported from mainline 2017-02-21 Jakub Jelinek <jakub@redhat.com> PR target/79494 * config/i386/i386.c (ix86_expand_split_stack_prologue): Call make_reg_eh_region_note_nothrow_nononlocal on call_insn. * gcc.dg/pr79494.c: New test. --- gcc/config/i386/i386.c (revision 247669) +++ gcc/config/i386/i386.c (revision 247670) @@ -14027,6 +14027,8 @@ ix86_expand_split_stack_prologue (void) GEN_INT (UNITS_PER_WORD), constm1_rtx, NULL_RTX, false); add_function_usage_to (call_insn, call_fusage); + /* Indicate that this function can't jump to non-local gotos. */ + make_reg_eh_region_note_nothrow_nononlocal (as_a <rtx_insn *> (call_insn)); /* In order to make call/return prediction work right, we now need to execute a return instruction. See --- gcc/testsuite/gcc.dg/pr79494.c (nonexistent) +++ gcc/testsuite/gcc.dg/pr79494.c (revision 247670) @@ -0,0 +1,22 @@ +/* PR target/79494 */ +/* { dg-do compile } */ +/* { dg-require-effective-target split_stack } */ +/* { dg-options "-O2 -fsplit-stack -g" } */ + +void +foo (int a) +{ + __label__ lab; + __attribute__((noinline, noclone)) void bar (int b) + { + switch (b) + { + case 1: + goto lab; + case 2: + goto lab; + } + } + bar (a); +lab:; +} 2017-05-30 Jakub Jelinek <jakub@redhat.com> Backported from mainline 2017-02-21 Jakub Jelinek <jakub@redhat.com> PR c++/79641 * c-common.c (handle_mode_attribute): Use build_qualified_type to preserve quals. * c-c++-common/pr79641.c: New test. --- gcc/c-family/c-common.c (revision 247671) +++ gcc/c-family/c-common.c (revision 247672) @@ -7596,7 +7596,7 @@ handle_mode_attribute (tree *node, tree return NULL_TREE; } - *node = typefm; + *node = build_qualified_type (typefm, TYPE_QUALS (type)); } return NULL_TREE; --- gcc/testsuite/c-c++-common/pr79641.c (nonexistent) +++ gcc/testsuite/c-c++-common/pr79641.c (revision 247672) @@ -0,0 +1,4 @@ +/* PR c++/79641 */ +/* { dg-do compile } */ + +const int __attribute__((__mode__ (__QI__))) i = 0; 2017-05-30 Jakub Jelinek <jakub@redhat.com> Backported from mainline 2017-02-21 Jakub Jelinek <jakub@redhat.com> PR target/79570 * sel-sched.c (moveup_expr_cached): Don't call sel_bb_head on temporarily removed DEBUG_INSNs. * gcc.dg/pr79570.c: New test. --- gcc/sel-sched.c (revision 247672) +++ gcc/sel-sched.c (revision 247673) @@ -2528,6 +2528,7 @@ moveup_expr_cached (expr_t expr, insn_t } if (DEBUG_INSN_P (EXPR_INSN_RTX (expr)) + && BLOCK_FOR_INSN (EXPR_INSN_RTX (expr)) && (sel_bb_head (BLOCK_FOR_INSN (EXPR_INSN_RTX (expr))) == EXPR_INSN_RTX (expr))) /* Don't use cached information for debug insns that are heads of --- gcc/testsuite/gcc.dg/pr79570.c (nonexistent) +++ gcc/testsuite/gcc.dg/pr79570.c (revision 247673) @@ -0,0 +1,12 @@ +/* PR target/79570 */ +/* { dg-do compile { target powerpc*-*-* ia64-*-* i?86-*-* x86_64-*-* } } */ +/* { dg-options "-O2 -fselective-scheduling2 -fvar-tracking-assignments" } */ +/* { dg-warning "changes selective scheduling" "" { target *-*-* } 0 } */ + +void +fn1 (char *b, char *d, int *c, int i) +{ + for (; i; i++, d++) + if (b[i]) + *d = c[i]; +} 2017-05-30 Jakub Jelinek <jakub@redhat.com> Backported from mainline 2017-02-22 Jakub Jelinek <jakub@redhat.com> PR c++/79664 * parser.c (cp_parser_omp_teams, cp_parser_omp_target): Use SET_EXPR_LOCATION on OMP_TARGET/OMP_TEAMS tree. * constexpr.c (potential_constant_expression_1): Handle OMP_*, OACC_* and CILK_* trees. * g++.dg/gomp/pr79664.C: New test. --- gcc/cp/constexpr.c (revision 247674) +++ gcc/cp/constexpr.c (revision 247675) @@ -4985,10 +4985,37 @@ potential_constant_expression_1 (tree t, case DELETE_EXPR: case VEC_DELETE_EXPR: case THROW_EXPR: + case OMP_PARALLEL: + case OMP_TASK: + case OMP_FOR: + case OMP_DISTRIBUTE: + case OMP_TEAMS: + case OMP_TARGET_DATA: + case OMP_TARGET: + case OMP_SECTIONS: + case OMP_ORDERED: + case OMP_CRITICAL: + case OMP_SINGLE: + case OMP_SECTION: + case OMP_MASTER: + case OMP_TASKGROUP: + case OMP_TARGET_UPDATE: case OMP_ATOMIC: case OMP_ATOMIC_READ: case OMP_ATOMIC_CAPTURE_OLD: case OMP_ATOMIC_CAPTURE_NEW: + case OACC_PARALLEL: + case OACC_KERNELS: + case OACC_DATA: + case OACC_HOST_DATA: + case OACC_LOOP: + case OACC_CACHE: + case OACC_DECLARE: + case OACC_ENTER_DATA: + case OACC_EXIT_DATA: + case OACC_UPDATE: + case CILK_SIMD: + case CILK_FOR: /* GCC internal stuff. */ case VA_ARG_EXPR: case OBJ_TYPE_REF: @@ -4997,7 +5027,8 @@ potential_constant_expression_1 (tree t, case AT_ENCODE_EXPR: fail: if (flags & tf_error) - error ("expression %qE is not a constant-expression", t); + error_at (EXPR_LOC_OR_LOC (t, input_location), + "expression %qE is not a constant-expression", t); return false; case TYPEID_EXPR: --- gcc/cp/parser.c (revision 247674) +++ gcc/cp/parser.c (revision 247675) @@ -31400,6 +31400,7 @@ cp_parser_omp_teams (cp_parser *parser, OMP_TEAMS_CLAUSES (ret) = clauses; OMP_TEAMS_BODY (ret) = body; OMP_TEAMS_COMBINED (ret) = 1; + SET_EXPR_LOCATION (ret, loc); return add_stmt (ret); } } @@ -31421,6 +31422,7 @@ cp_parser_omp_teams (cp_parser *parser, TREE_TYPE (stmt) = void_type_node; OMP_TEAMS_CLAUSES (stmt) = clauses; OMP_TEAMS_BODY (stmt) = cp_parser_omp_structured_block (parser); + SET_EXPR_LOCATION (stmt, loc); return add_stmt (stmt); } @@ -31545,6 +31547,7 @@ cp_parser_omp_target (cp_parser *parser, TREE_TYPE (stmt) = void_type_node; OMP_TARGET_CLAUSES (stmt) = cclauses[C_OMP_CLAUSE_SPLIT_TARGET]; OMP_TARGET_BODY (stmt) = body; + SET_EXPR_LOCATION (stmt, pragma_tok->location); add_stmt (stmt); return true; } --- gcc/testsuite/g++.dg/gomp/pr79664.C (nonexistent) +++ gcc/testsuite/g++.dg/gomp/pr79664.C (revision 247675) @@ -0,0 +1,142 @@ +// PR c++/79664 +// { dg-do compile } +// { dg-options "-std=c++14 -fopenmp" } + +constexpr int +f1 () +{ + int i = 0; +#pragma omp parallel for // { dg-error "is not a constant-expression" } + for (i = 0; i < 10; ++i) + ; + return 0; +} + +constexpr int +f2 () +{ + int i = 0; +#pragma omp parallel // { dg-error "is not a constant-expression" } + i = 5; + return 0; +} + +constexpr int +f3 () +{ + int i = 0; +#pragma omp task // { dg-error "is not a constant-expression" } + i = 5; + return 0; +} + +constexpr int +f4 () +{ + int i = 0; +#pragma omp for // { dg-error "is not a constant-expression" } + for (i = 0; i < 10; ++i) + ; + return 0; +} + +constexpr int +f6 () +{ + int i = 0; +#pragma omp target teams // { dg-error "is not a constant-expression" } + i = 5; + return 0; +} + +constexpr int +f7 () +{ + int i = 0; +#pragma omp target data map(tofrom:i) // { dg-error "is not a constant-expression" } + i = 5; + return 0; +} + +constexpr int +f8 () +{ + int i = 0; +#pragma omp target // { dg-error "is not a constant-expression" } + i = 5; + return 0; +} + +constexpr int +f9 () +{ + int i = 0; +#pragma omp sections // { dg-error "is not a constant-expression" } + { +#pragma omp section + i = 5; + } + return 0; +} + +constexpr int +f10 () +{ + int i = 0; +#pragma omp ordered // { dg-error "is not a constant-expression" } + i = 1; + return 0; +} + +constexpr int +f11 () +{ + int i = 0; +#pragma omp critical // { dg-error "is not a constant-expression" } + i = 1; + return 0; +} + +constexpr int +f12 () +{ + int i = 0; +#pragma omp single // { dg-error "is not a constant-expression" } + i = 1; + return 0; +} + +constexpr int +f13 () +{ + int i = 0; +#pragma omp master // { dg-error "is not a constant-expression" } + i = 1; + return 0; +} + +constexpr int +f14 () +{ + int i = 0; +#pragma omp taskgroup // { dg-error "is not a constant-expression" } + i = 1; + return 0; +} + +constexpr int +f15 () +{ + int i = 0; +#pragma omp target update to(i) // { dg-error "is not a constant-expression" } + i = 1; + return 0; +} + +constexpr int +f16 () +{ + int i = 0; +#pragma omp target update to(i) // { dg-error "is not a constant-expression" } + return 0; +} 2017-05-30 Jakub Jelinek <jakub@redhat.com> Backported from mainline 2017-02-25 Jakub Jelinek <jakub@redhat.com> PR middle-end/79396 * tree-eh.c (operation_could_trap_p, stmt_could_throw_1_p): Handle FMA_EXPR like tcc_binary or tcc_unary. * g++.dg/opt/pr79396.C: New test. --- gcc/tree-eh.c (revision 247675) +++ gcc/tree-eh.c (revision 247676) @@ -2513,7 +2513,8 @@ operation_could_trap_p (enum tree_code o if (TREE_CODE_CLASS (op) != tcc_comparison && TREE_CODE_CLASS (op) != tcc_unary - && TREE_CODE_CLASS (op) != tcc_binary) + && TREE_CODE_CLASS (op) != tcc_binary + && op != FMA_EXPR) return false; return operation_could_trap_helper_p (op, fp_operation, honor_trapv, @@ -2738,7 +2739,8 @@ stmt_could_throw_1_p (gimple *stmt) if (TREE_CODE_CLASS (code) == tcc_comparison || TREE_CODE_CLASS (code) == tcc_unary - || TREE_CODE_CLASS (code) == tcc_binary) + || TREE_CODE_CLASS (code) == tcc_binary + || code == FMA_EXPR) { if (is_gimple_assign (stmt) && TREE_CODE_CLASS (code) == tcc_comparison) --- gcc/testsuite/g++.dg/opt/pr79396.C (nonexistent) +++ gcc/testsuite/g++.dg/opt/pr79396.C (revision 247676) @@ -0,0 +1,13 @@ +// PR middle-end/79396 +// { dg-do compile } +// { dg-options "-fnon-call-exceptions -O2" } +// { dg-additional-options "-mfma" { target i?86-*-* x86_64-*-* } } + +struct A { A (); ~A (); }; + +float +foo (float x) +{ + A a; + return __builtin_pow (x, 2) + 2; +} 2017-05-30 Jakub Jelinek <jakub@redhat.com> Backported from mainline 2017-02-28 Jakub Jelinek <jakub@redhat.com> PR target/79729 * config/i386/i386.c (ix86_print_operand) <case 'R'>: Replace gcc_unreachable with output_operand_lossage. * gcc.target/i386/pr79729.c: New test. --- gcc/config/i386/i386.c (revision 247676) +++ gcc/config/i386/i386.c (revision 247677) @@ -17186,7 +17186,8 @@ ix86_print_operand (FILE *file, rtx x, i fputs ("{rz-sae}", file); break; default: - gcc_unreachable (); + output_operand_lossage ("operand is not a specific integer, " + "invalid operand code 'R'"); } if (ASSEMBLER_DIALECT == ASM_ATT) --- gcc/testsuite/gcc.target/i386/pr79729.c (nonexistent) +++ gcc/testsuite/gcc.target/i386/pr79729.c (revision 247677) @@ -0,0 +1,8 @@ +/* PR target/79729 */ +/* { dg-do compile } */ + +void +foo (int x) +{ + __asm__ volatile ("# %R0" : : "n" (129)); /* { dg-error "invalid operand code" } */ +} 2017-05-30 Jakub Jelinek <jakub@redhat.com> Backported from mainline 2017-03-03 Jakub Jelinek <jakub@redhat.com> PR target/79807 * config/i386/i386.c (ix86_expand_multi_arg_builtin): If target is a memory operand, increase num_memory. (ix86_expand_args_builtin): Likewise. * gcc.target/i386/pr79807.c: New test. --- gcc/config/i386/i386.c (revision 247678) +++ gcc/config/i386/i386.c (revision 247679) @@ -38077,6 +38077,8 @@ ix86_expand_multi_arg_builtin (enum insn || GET_MODE (target) != tmode || !insn_data[icode].operand[0].predicate (target, tmode)) target = gen_reg_rtx (tmode); + else if (memory_operand (target, tmode)) + num_memory++; gcc_assert (nargs <= 4); @@ -39351,6 +39353,8 @@ ix86_expand_args_builtin (const struct b || GET_MODE (target) != tmode || !insn_p->operand[0].predicate (target, tmode)) target = gen_reg_rtx (tmode); + else if (memory_operand (target, tmode)) + num_memory++; real_target = target; } else --- gcc/testsuite/gcc.target/i386/pr79807.c (nonexistent) +++ gcc/testsuite/gcc.target/i386/pr79807.c (revision 247679) @@ -0,0 +1,12 @@ +/* PR target/79807 */ +/* { dg-do compile } */ +/* { dg-options "-O0 -mavx -ffloat-store" } */ + +typedef double __v2df __attribute__ ((__vector_size__ (16))); +typedef double __v4df __attribute__ ((__vector_size__ (32))); + +__v2df +foo (__v4df x) +{ + return __builtin_ia32_pd_pd256 (x); +} 2017-05-30 Jakub Jelinek <jakub@redhat.com> Backported from mainline 2017-03-07 Jakub Jelinek <jakub@redhat.com> PR rtl-optimization/79901 * expr.c (expand_expr_real_2): For vector MIN/MAX, if there is no min/max expander, expand it using expand_vec_cond_expr. --- gcc/expr.c (revision 247679) +++ gcc/expr.c (revision 247680) @@ -8785,6 +8785,18 @@ expand_expr_real_2 (sepops ops, rtx targ if (temp != 0) return temp; + /* For vector MIN <x, y>, expand it a VEC_COND_EXPR <x <= y, x, y> + and similarly for MAX <x, y>. */ + if (VECTOR_TYPE_P (type)) + { + tree t0 = make_tree (type, op0); + tree t1 = make_tree (type, op1); + tree comparison = build2 (code == MIN_EXPR ? LE_EXPR : GE_EXPR, + type, t0, t1); + return expand_vec_cond_expr (type, comparison, t0, t1, + original_target); + } + /* At this point, a MEM target is no longer useful; we will get better code without it. */ 2017-05-30 Jakub Jelinek <jakub@redhat.com> Backported from mainline 2017-03-07 Jakub Jelinek <jakub@redhat.com> PR rtl-optimization/79901 * config/i386/sse.md (*avx512bw_<code><mode>3<mask_name>): Renamed to ... (*avx512f_<code><mode>3<mask_name>): ... this. (<code><mode>3 with maxmin code iterator): Use VI8_AVX2_AVX512F iterator instead of VI8_AVX2_AVX512BW. * gcc.target/i386/pr79901.c: New test. --- gcc/config/i386/sse.md (revision 247680) +++ gcc/config/i386/sse.md (revision 247681) @@ -10728,7 +10728,7 @@ (define_expand "<code><mode>3_mask" "TARGET_AVX512F" "ix86_fixup_binary_operands_no_copy (<CODE>, <MODE>mode, operands);") -(define_insn "*avx512bw_<code><mode>3<mask_name>" +(define_insn "*avx512f_<code><mode>3<mask_name>" [(set (match_operand:VI48_AVX512VL 0 "register_operand" "=v") (maxmin:VI48_AVX512VL (match_operand:VI48_AVX512VL 1 "nonimmediate_operand" "%v") @@ -10752,10 +10752,10 @@ (define_insn "<mask_codefor><code><mode> (set_attr "mode" "<sseinsnmode>")]) (define_expand "<code><mode>3" - [(set (match_operand:VI8_AVX2_AVX512BW 0 "register_operand") - (maxmin:VI8_AVX2_AVX512BW - (match_operand:VI8_AVX2_AVX512BW 1 "register_operand") - (match_operand:VI8_AVX2_AVX512BW 2 "register_operand")))] + [(set (match_operand:VI8_AVX2_AVX512F 0 "register_operand") + (maxmin:VI8_AVX2_AVX512F + (match_operand:VI8_AVX2_AVX512F 1 "register_operand") + (match_operand:VI8_AVX2_AVX512F 2 "register_operand")))] "TARGET_SSE4_2" { if (TARGET_AVX512F --- gcc/testsuite/gcc.target/i386/pr79901.c (nonexistent) +++ gcc/testsuite/gcc.target/i386/pr79901.c (revision 247681) @@ -0,0 +1,22 @@ +/* PR rtl-optimization/79901 */ +/* { dg-do compile } */ +/* { dg-options "-O3 -mavx512f -fno-ssa-phiopt" } */ + +unsigned int +foo (const unsigned long long x) +{ + if (x < 0) + return 0; + else if ( x > ~0U) + return ~0U; + else + return (unsigned int) x; +} + +void +bar (unsigned x, unsigned int *y, unsigned int z) +{ + unsigned i; + for (i = 0; i < x; i++) + y[i] = foo (y[i] * (unsigned long long) z); +} 2017-05-30 Jakub Jelinek <jakub@redhat.com> Backported from mainline 2017-03-09 Jakub Jelinek <jakub@redhat.com> PR target/79932 * config/i386/avx512bwintrin.h (_mm512_packs_epi32, _mm512_maskz_packs_epi32, _mm512_mask_packs_epi32, _mm512_packus_epi32, _mm512_maskz_packus_epi32, _mm512_mask_packus_epi32): Move definitions outside of __OPTIMIZE__ guarded section. * gcc.target/i386/pr79932-1.c: New test. --- gcc/config/i386/avx512bwintrin.h (revision 247682) +++ gcc/config/i386/avx512bwintrin.h (revision 247683) @@ -2420,6 +2420,72 @@ _mm512_cmple_epi16_mask (__m512i __X, __ (__mmask32) -1); } +extern __inline __m512i +__attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) +_mm512_packs_epi32 (__m512i __A, __m512i __B) +{ + return (__m512i) __builtin_ia32_packssdw512_mask ((__v16si) __A, + (__v16si) __B, + (__v32hi) + _mm512_setzero_hi (), + (__mmask32) -1); +} + +extern __inline __m512i +__attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) +_mm512_maskz_packs_epi32 (__mmask32 __M, __m512i __A, __m512i __B) +{ + return (__m512i) __builtin_ia32_packssdw512_mask ((__v16si) __A, + (__v16si) __B, + (__v32hi) + _mm512_setzero_hi (), + __M); +} + +extern __inline __m512i +__attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) +_mm512_mask_packs_epi32 (__m512i __W, __mmask32 __M, __m512i __A, + __m512i __B) +{ + return (__m512i) __builtin_ia32_packssdw512_mask ((__v16si) __A, + (__v16si) __B, + (__v32hi) __W, + __M); +} + +extern __inline __m512i +__attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) +_mm512_packus_epi32 (__m512i __A, __m512i __B) +{ + return (__m512i) __builtin_ia32_packusdw512_mask ((__v16si) __A, + (__v16si) __B, + (__v32hi) + _mm512_setzero_hi (), + (__mmask32) -1); +} + +extern __inline __m512i +__attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) +_mm512_maskz_packus_epi32 (__mmask32 __M, __m512i __A, __m512i __B) +{ + return (__m512i) __builtin_ia32_packusdw512_mask ((__v16si) __A, + (__v16si) __B, + (__v32hi) + _mm512_setzero_hi (), + __M); +} + +extern __inline __m512i +__attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) +_mm512_mask_packus_epi32 (__m512i __W, __mmask32 __M, __m512i __A, + __m512i __B) +{ + return (__m512i) __builtin_ia32_packusdw512_mask ((__v16si) __A, + (__v16si) __B, + (__v32hi) __W, + __M); +} + #ifdef __OPTIMIZE__ extern __inline __m512i __attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) @@ -2744,72 +2810,6 @@ _mm512_cmp_epu8_mask (__m512i __X, __m51 } extern __inline __m512i -__attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) -_mm512_packs_epi32 (__m512i __A, __m512i __B) -{ - return (__m512i) __builtin_ia32_packssdw512_mask ((__v16si) __A, - (__v16si) __B, - (__v32hi) - _mm512_setzero_hi (), - (__mmask32) -1); -} - -extern __inline __m512i -__attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) -_mm512_maskz_packs_epi32 (__mmask32 __M, __m512i __A, __m512i __B) -{ - return (__m512i) __builtin_ia32_packssdw512_mask ((__v16si) __A, - (__v16si) __B, - (__v32hi) - _mm512_setzero_hi(), - __M); -} - -extern __inline __m512i -__attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) -_mm512_mask_packs_epi32 (__m512i __W, __mmask32 __M, __m512i __A, - __m512i __B) -{ - return (__m512i) __builtin_ia32_packssdw512_mask ((__v16si) __A, - (__v16si) __B, - (__v32hi) __W, - __M); -} - -extern __inline __m512i -__attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) -_mm512_packus_epi32 (__m512i __A, __m512i __B) -{ - return (__m512i) __builtin_ia32_packusdw512_mask ((__v16si) __A, - (__v16si) __B, - (__v32hi) - _mm512_setzero_hi (), - (__mmask32) -1); -} - -extern __inline __m512i -__attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) -_mm512_maskz_packus_epi32 (__mmask32 __M, __m512i __A, __m512i __B) -{ - return (__m512i) __builtin_ia32_packusdw512_mask ((__v16si) __A, - (__v16si) __B, - (__v32hi) - _mm512_setzero_hi(), - __M); -} - -extern __inline __m512i -__attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) -_mm512_mask_packus_epi32 (__m512i __W, __mmask32 __M, __m512i __A, - __m512i __B) -{ - return (__m512i) __builtin_ia32_packusdw512_mask ((__v16si) __A, - (__v16si) __B, - (__v32hi) __W, - __M); -} - -extern __inline __m512i __attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) _mm512_bslli_epi128 (__m512i __A, const int __N) { --- gcc/testsuite/gcc.target/i386/pr79932-1.c (nonexistent) +++ gcc/testsuite/gcc.target/i386/pr79932-1.c (revision 247683) @@ -0,0 +1,19 @@ +/* PR target/79932 */ +/* { dg-do compile } */ +/* { dg-options "-O0 -mavx512bw" } */ + +#include <x86intrin.h> + +__m512i a, b, c, d, e, f, g, h, i; +__mmask32 m; + +void +foo (void) +{ + d = _mm512_packs_epi32 (a, b); + e = _mm512_maskz_packs_epi32 (m, a, b); + f = _mm512_mask_packs_epi32 (c, m, a, b); + g = _mm512_packus_epi32 (a, b); + h = _mm512_maskz_packus_epi32 (m, a, b); + i = _mm512_mask_packus_epi32 (c, m, a, b); +} 2017-05-30 Jakub Jelinek <jakub@redhat.com> Backported from mainline 2017-03-09 Jakub Jelinek <jakub@redhat.com> PR target/79932 * config/i386/avx512vlintrin.h (_mm256_cmpge_epi32_mask, _mm256_cmpge_epi64_mask, _mm256_cmpge_epu32_mask, _mm256_cmpge_epu64_mask, _mm256_cmple_epi32_mask, _mm256_cmple_epi64_mask, _mm256_cmple_epu32_mask, _mm256_cmple_epu64_mask, _mm256_cmplt_epi32_mask, _mm256_cmplt_epi64_mask, _mm256_cmplt_epu32_mask, _mm256_cmplt_epu64_mask, _mm256_cmpneq_epi32_mask, _mm256_cmpneq_epi64_mask, _mm256_cmpneq_epu32_mask, _mm256_cmpneq_epu64_mask, _mm256_mask_cmpge_epi32_mask, _mm256_mask_cmpge_epi64_mask, _mm256_mask_cmpge_epu32_mask, _mm256_mask_cmpge_epu64_mask, _mm256_mask_cmple_epi32_mask, _mm256_mask_cmple_epi64_mask, _mm256_mask_cmple_epu32_mask, _mm256_mask_cmple_epu64_mask, _mm256_mask_cmplt_epi32_mask, _mm256_mask_cmplt_epi64_mask, _mm256_mask_cmplt_epu32_mask, _mm256_mask_cmplt_epu64_mask, _mm256_mask_cmpneq_epi32_mask, _mm256_mask_cmpneq_epi64_mask, _mm256_mask_cmpneq_epu32_mask, _mm256_mask_cmpneq_epu64_mask, _mm_cmpge_epi32_mask, _mm_cmpge_epi64_mask, _mm_cmpge_epu32_mask, _mm_cmpge_epu64_mask, _mm_cmple_epi32_mask, _mm_cmple_epi64_mask, _mm_cmple_epu32_mask, _mm_cmple_epu64_mask, _mm_cmplt_epi32_mask, _mm_cmplt_epi64_mask, _mm_cmplt_epu32_mask, _mm_cmplt_epu64_mask, _mm_cmpneq_epi32_mask, _mm_cmpneq_epi64_mask, _mm_cmpneq_epu32_mask, _mm_cmpneq_epu64_mask, _mm_mask_cmpge_epi32_mask, _mm_mask_cmpge_epi64_mask, _mm_mask_cmpge_epu32_mask, _mm_mask_cmpge_epu64_mask, _mm_mask_cmple_epi32_mask, _mm_mask_cmple_epi64_mask, _mm_mask_cmple_epu32_mask, _mm_mask_cmple_epu64_mask, _mm_mask_cmplt_epi32_mask, _mm_mask_cmplt_epi64_mask, _mm_mask_cmplt_epu32_mask, _mm_mask_cmplt_epu64_mask, _mm_mask_cmpneq_epi32_mask, _mm_mask_cmpneq_epi64_mask, _mm_mask_cmpneq_epu32_mask, _mm_mask_cmpneq_epu64_mask): Move definitions outside of __OPTIMIZE__ guarded section. * gcc.target/i386/pr79932-2.c: New test. --- gcc/config/i386/avx512vlintrin.h (revision 247683) +++ gcc/config/i386/avx512vlintrin.h (revision 247684) @@ -9159,6 +9159,582 @@ _mm256_mask_permutexvar_epi32 (__m256i _ __M); } +extern __inline __mmask8 + __attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) +_mm256_mask_cmpneq_epu32_mask (__mmask8 __M, __m256i __X, __m256i __Y) +{ + return (__mmask8) __builtin_ia32_ucmpd256_mask ((__v8si) __X, + (__v8si) __Y, 4, + (__mmask8) __M); +} + +extern __inline __mmask8 + __attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) +_mm256_cmpneq_epu32_mask (__m256i __X, __m256i __Y) +{ + return (__mmask8) __builtin_ia32_ucmpd256_mask ((__v8si) __X, + (__v8si) __Y, 4, + (__mmask8) -1); +} + +extern __inline __mmask8 + __attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) +_mm256_mask_cmplt_epu32_mask (__mmask8 __M, __m256i __X, __m256i __Y) +{ + return (__mmask8) __builtin_ia32_ucmpd256_mask ((__v8si) __X, + (__v8si) __Y, 1, + (__mmask8) __M); +} + +extern __inline __mmask8 + __attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) +_mm256_cmplt_epu32_mask (__m256i __X, __m256i __Y) +{ + return (__mmask8) __builtin_ia32_ucmpd256_mask ((__v8si) __X, + (__v8si) __Y, 1, + (__mmask8) -1); +} + +extern __inline __mmask8 + __attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) +_mm256_mask_cmpge_epu32_mask (__mmask8 __M, __m256i __X, __m256i __Y) +{ + return (__mmask8) __builtin_ia32_ucmpd256_mask ((__v8si) __X, + (__v8si) __Y, 5, + (__mmask8) __M); +} + +extern __inline __mmask8 + __attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) +_mm256_cmpge_epu32_mask (__m256i __X, __m256i __Y) +{ + return (__mmask8) __builtin_ia32_ucmpd256_mask ((__v8si) __X, + (__v8si) __Y, 5, + (__mmask8) -1); +} + +extern __inline __mmask8 + __attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) +_mm256_mask_cmple_epu32_mask (__mmask8 __M, __m256i __X, __m256i __Y) +{ + return (__mmask8) __builtin_ia32_ucmpd256_mask ((__v8si) __X, + (__v8si) __Y, 2, + (__mmask8) __M); +} + +extern __inline __mmask8 + __attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) +_mm256_cmple_epu32_mask (__m256i __X, __m256i __Y) +{ + return (__mmask8) __builtin_ia32_ucmpd256_mask ((__v8si) __X, + (__v8si) __Y, 2, + (__mmask8) -1); +} + +extern __inline __mmask8 + __attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) +_mm256_mask_cmpneq_epu64_mask (__mmask8 __M, __m256i __X, __m256i __Y) +{ + return (__mmask8) __builtin_ia32_ucmpq256_mask ((__v4di) __X, + (__v4di) __Y, 4, + (__mmask8) __M); +} + +extern __inline __mmask8 + __attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) +_mm256_cmpneq_epu64_mask (__m256i __X, __m256i __Y) +{ + return (__mmask8) __builtin_ia32_ucmpq256_mask ((__v4di) __X, + (__v4di) __Y, 4, + (__mmask8) -1); +} + +extern __inline __mmask8 + __attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) +_mm256_mask_cmplt_epu64_mask (__mmask8 __M, __m256i __X, __m256i __Y) +{ + return (__mmask8) __builtin_ia32_ucmpq256_mask ((__v4di) __X, + (__v4di) __Y, 1, + (__mmask8) __M); +} + +extern __inline __mmask8 + __attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) +_mm256_cmplt_epu64_mask (__m256i __X, __m256i __Y) +{ + return (__mmask8) __builtin_ia32_ucmpq256_mask ((__v4di) __X, + (__v4di) __Y, 1, + (__mmask8) -1); +} + +extern __inline __mmask8 + __attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) +_mm256_mask_cmpge_epu64_mask (__mmask8 __M, __m256i __X, __m256i __Y) +{ + return (__mmask8) __builtin_ia32_ucmpq256_mask ((__v4di) __X, + (__v4di) __Y, 5, + (__mmask8) __M); +} + +extern __inline __mmask8 + __attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) +_mm256_cmpge_epu64_mask (__m256i __X, __m256i __Y) +{ + return (__mmask8) __builtin_ia32_ucmpq256_mask ((__v4di) __X, + (__v4di) __Y, 5, + (__mmask8) -1); +} + +extern __inline __mmask8 + __attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) +_mm256_mask_cmple_epu64_mask (__mmask8 __M, __m256i __X, __m256i __Y) +{ + return (__mmask8) __builtin_ia32_ucmpq256_mask ((__v4di) __X, + (__v4di) __Y, 2, + (__mmask8) __M); +} + +extern __inline __mmask8 + __attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) +_mm256_cmple_epu64_mask (__m256i __X, __m256i __Y) +{ + return (__mmask8) __builtin_ia32_ucmpq256_mask ((__v4di) __X, + (__v4di) __Y, 2, + (__mmask8) -1); +} + +extern __inline __mmask8 + __attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) +_mm256_mask_cmpneq_epi32_mask (__mmask8 __M, __m256i __X, __m256i __Y) +{ + return (__mmask8) __builtin_ia32_cmpd256_mask ((__v8si) __X, + (__v8si) __Y, 4, + (__mmask8) __M); +} + +extern __inline __mmask8 + __attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) +_mm256_cmpneq_epi32_mask (__m256i __X, __m256i __Y) +{ + return (__mmask8) __builtin_ia32_cmpd256_mask ((__v8si) __X, + (__v8si) __Y, 4, + (__mmask8) -1); +} + +extern __inline __mmask8 + __attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) +_mm256_mask_cmplt_epi32_mask (__mmask8 __M, __m256i __X, __m256i __Y) +{ + return (__mmask8) __builtin_ia32_cmpd256_mask ((__v8si) __X, + (__v8si) __Y, 1, + (__mmask8) __M); +} + +extern __inline __mmask8 + __attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) +_mm256_cmplt_epi32_mask (__m256i __X, __m256i __Y) +{ + return (__mmask8) __builtin_ia32_cmpd256_mask ((__v8si) __X, + (__v8si) __Y, 1, + (__mmask8) -1); +} + +extern __inline __mmask8 + __attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) +_mm256_mask_cmpge_epi32_mask (__mmask8 __M, __m256i __X, __m256i __Y) +{ + return (__mmask8) __builtin_ia32_cmpd256_mask ((__v8si) __X, + (__v8si) __Y, 5, + (__mmask8) __M); +} + +extern __inline __mmask8 + __attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) +_mm256_cmpge_epi32_mask (__m256i __X, __m256i __Y) +{ + return (__mmask8) __builtin_ia32_cmpd256_mask ((__v8si) __X, + (__v8si) __Y, 5, + (__mmask8) -1); +} + +extern __inline __mmask8 + __attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) +_mm256_mask_cmple_epi32_mask (__mmask8 __M, __m256i __X, __m256i __Y) +{ + return (__mmask8) __builtin_ia32_cmpd256_mask ((__v8si) __X, + (__v8si) __Y, 2, + (__mmask8) __M); +} + +extern __inline __mmask8 + __attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) +_mm256_cmple_epi32_mask (__m256i __X, __m256i __Y) +{ + return (__mmask8) __builtin_ia32_cmpd256_mask ((__v8si) __X, + (__v8si) __Y, 2, + (__mmask8) -1); +} + +extern __inline __mmask8 + __attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) +_mm256_mask_cmpneq_epi64_mask (__mmask8 __M, __m256i __X, __m256i __Y) +{ + return (__mmask8) __builtin_ia32_cmpq256_mask ((__v4di) __X, + (__v4di) __Y, 4, + (__mmask8) __M); +} + +extern __inline __mmask8 + __attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) +_mm256_cmpneq_epi64_mask (__m256i __X, __m256i __Y) +{ + return (__mmask8) __builtin_ia32_cmpq256_mask ((__v4di) __X, + (__v4di) __Y, 4, + (__mmask8) -1); +} + +extern __inline __mmask8 + __attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) +_mm256_mask_cmplt_epi64_mask (__mmask8 __M, __m256i __X, __m256i __Y) +{ + return (__mmask8) __builtin_ia32_cmpq256_mask ((__v4di) __X, + (__v4di) __Y, 1, + (__mmask8) __M); +} + +extern __inline __mmask8 + __attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) +_mm256_cmplt_epi64_mask (__m256i __X, __m256i __Y) +{ + return (__mmask8) __builtin_ia32_cmpq256_mask ((__v4di) __X, + (__v4di) __Y, 1, + (__mmask8) -1); +} + +extern __inline __mmask8 + __attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) +_mm256_mask_cmpge_epi64_mask (__mmask8 __M, __m256i __X, __m256i __Y) +{ + return (__mmask8) __builtin_ia32_cmpq256_mask ((__v4di) __X, + (__v4di) __Y, 5, + (__mmask8) __M); +} + +extern __inline __mmask8 + __attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) +_mm256_cmpge_epi64_mask (__m256i __X, __m256i __Y) +{ + return (__mmask8) __builtin_ia32_cmpq256_mask ((__v4di) __X, + (__v4di) __Y, 5, + (__mmask8) -1); +} + +extern __inline __mmask8 + __attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) +_mm256_mask_cmple_epi64_mask (__mmask8 __M, __m256i __X, __m256i __Y) +{ + return (__mmask8) __builtin_ia32_cmpq256_mask ((__v4di) __X, + (__v4di) __Y, 2, + (__mmask8) __M); +} + +extern __inline __mmask8 + __attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) +_mm256_cmple_epi64_mask (__m256i __X, __m256i __Y) +{ + return (__mmask8) __builtin_ia32_cmpq256_mask ((__v4di) __X, + (__v4di) __Y, 2, + (__mmask8) -1); +} + +extern __inline __mmask8 + __attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) +_mm_mask_cmpneq_epu32_mask (__mmask8 __M, __m128i __X, __m128i __Y) +{ + return (__mmask8) __builtin_ia32_ucmpd128_mask ((__v4si) __X, + (__v4si) __Y, 4, + (__mmask8) __M); +} + +extern __inline __mmask8 + __attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) +_mm_cmpneq_epu32_mask (__m128i __X, __m128i __Y) +{ + return (__mmask8) __builtin_ia32_ucmpd128_mask ((__v4si) __X, + (__v4si) __Y, 4, + (__mmask8) -1); +} + +extern __inline __mmask8 + __attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) +_mm_mask_cmplt_epu32_mask (__mmask8 __M, __m128i __X, __m128i __Y) +{ + return (__mmask8) __builtin_ia32_ucmpd128_mask ((__v4si) __X, + (__v4si) __Y, 1, + (__mmask8) __M); +} + +extern __inline __mmask8 + __attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) +_mm_cmplt_epu32_mask (__m128i __X, __m128i __Y) +{ + return (__mmask8) __builtin_ia32_ucmpd128_mask ((__v4si) __X, + (__v4si) __Y, 1, + (__mmask8) -1); +} + +extern __inline __mmask8 + __attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) +_mm_mask_cmpge_epu32_mask (__mmask8 __M, __m128i __X, __m128i __Y) +{ + return (__mmask8) __builtin_ia32_ucmpd128_mask ((__v4si) __X, + (__v4si) __Y, 5, + (__mmask8) __M); +} + +extern __inline __mmask8 + __attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) +_mm_cmpge_epu32_mask (__m128i __X, __m128i __Y) +{ + return (__mmask8) __builtin_ia32_ucmpd128_mask ((__v4si) __X, + (__v4si) __Y, 5, + (__mmask8) -1); +} + +extern __inline __mmask8 + __attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) +_mm_mask_cmple_epu32_mask (__mmask8 __M, __m128i __X, __m128i __Y) +{ + return (__mmask8) __builtin_ia32_ucmpd128_mask ((__v4si) __X, + (__v4si) __Y, 2, + (__mmask8) __M); +} + +extern __inline __mmask8 + __attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) +_mm_cmple_epu32_mask (__m128i __X, __m128i __Y) +{ + return (__mmask8) __builtin_ia32_ucmpd128_mask ((__v4si) __X, + (__v4si) __Y, 2, + (__mmask8) -1); +} + +extern __inline __mmask8 + __attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) +_mm_mask_cmpneq_epu64_mask (__mmask8 __M, __m128i __X, __m128i __Y) +{ + return (__mmask8) __builtin_ia32_ucmpq128_mask ((__v2di) __X, + (__v2di) __Y, 4, + (__mmask8) __M); +} + +extern __inline __mmask8 + __attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) +_mm_cmpneq_epu64_mask (__m128i __X, __m128i __Y) +{ + return (__mmask8) __builtin_ia32_ucmpq128_mask ((__v2di) __X, + (__v2di) __Y, 4, + (__mmask8) -1); +} + +extern __inline __mmask8 + __attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) +_mm_mask_cmplt_epu64_mask (__mmask8 __M, __m128i __X, __m128i __Y) +{ + return (__mmask8) __builtin_ia32_ucmpq128_mask ((__v2di) __X, + (__v2di) __Y, 1, + (__mmask8) __M); +} + +extern __inline __mmask8 + __attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) +_mm_cmplt_epu64_mask (__m128i __X, __m128i __Y) +{ + return (__mmask8) __builtin_ia32_ucmpq128_mask ((__v2di) __X, + (__v2di) __Y, 1, + (__mmask8) -1); +} + +extern __inline __mmask8 + __attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) +_mm_mask_cmpge_epu64_mask (__mmask8 __M, __m128i __X, __m128i __Y) +{ + return (__mmask8) __builtin_ia32_ucmpq128_mask ((__v2di) __X, + (__v2di) __Y, 5, + (__mmask8) __M); +} + +extern __inline __mmask8 + __attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) +_mm_cmpge_epu64_mask (__m128i __X, __m128i __Y) +{ + return (__mmask8) __builtin_ia32_ucmpq128_mask ((__v2di) __X, + (__v2di) __Y, 5, + (__mmask8) -1); +} + +extern __inline __mmask8 + __attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) +_mm_mask_cmple_epu64_mask (__mmask8 __M, __m128i __X, __m128i __Y) +{ + return (__mmask8) __builtin_ia32_ucmpq128_mask ((__v2di) __X, + (__v2di) __Y, 2, + (__mmask8) __M); +} + +extern __inline __mmask8 + __attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) +_mm_cmple_epu64_mask (__m128i __X, __m128i __Y) +{ + return (__mmask8) __builtin_ia32_ucmpq128_mask ((__v2di) __X, + (__v2di) __Y, 2, + (__mmask8) -1); +} + +extern __inline __mmask8 + __attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) +_mm_mask_cmpneq_epi32_mask (__mmask8 __M, __m128i __X, __m128i __Y) +{ + return (__mmask8) __builtin_ia32_cmpd128_mask ((__v4si) __X, + (__v4si) __Y, 4, + (__mmask8) __M); +} + +extern __inline __mmask8 + __attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) +_mm_cmpneq_epi32_mask (__m128i __X, __m128i __Y) +{ + return (__mmask8) __builtin_ia32_cmpd128_mask ((__v4si) __X, + (__v4si) __Y, 4, + (__mmask8) -1); +} + +extern __inline __mmask8 + __attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) +_mm_mask_cmplt_epi32_mask (__mmask8 __M, __m128i __X, __m128i __Y) +{ + return (__mmask8) __builtin_ia32_cmpd128_mask ((__v4si) __X, + (__v4si) __Y, 1, + (__mmask8) __M); +} + +extern __inline __mmask8 + __attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) +_mm_cmplt_epi32_mask (__m128i __X, __m128i __Y) +{ + return (__mmask8) __builtin_ia32_cmpd128_mask ((__v4si) __X, + (__v4si) __Y, 1, + (__mmask8) -1); +} + +extern __inline __mmask8 + __attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) +_mm_mask_cmpge_epi32_mask (__mmask8 __M, __m128i __X, __m128i __Y) +{ + return (__mmask8) __builtin_ia32_cmpd128_mask ((__v4si) __X, + (__v4si) __Y, 5, + (__mmask8) __M); +} + +extern __inline __mmask8 + __attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) +_mm_cmpge_epi32_mask (__m128i __X, __m128i __Y) +{ + return (__mmask8) __builtin_ia32_cmpd128_mask ((__v4si) __X, + (__v4si) __Y, 5, + (__mmask8) -1); +} + +extern __inline __mmask8 + __attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) +_mm_mask_cmple_epi32_mask (__mmask8 __M, __m128i __X, __m128i __Y) +{ + return (__mmask8) __builtin_ia32_cmpd128_mask ((__v4si) __X, + (__v4si) __Y, 2, + (__mmask8) __M); +} + +extern __inline __mmask8 + __attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) +_mm_cmple_epi32_mask (__m128i __X, __m128i __Y) +{ + return (__mmask8) __builtin_ia32_cmpd128_mask ((__v4si) __X, + (__v4si) __Y, 2, + (__mmask8) -1); +} + +extern __inline __mmask8 + __attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) +_mm_mask_cmpneq_epi64_mask (__mmask8 __M, __m128i __X, __m128i __Y) +{ + return (__mmask8) __builtin_ia32_cmpq128_mask ((__v2di) __X, + (__v2di) __Y, 4, + (__mmask8) __M); +} + +extern __inline __mmask8 + __attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) +_mm_cmpneq_epi64_mask (__m128i __X, __m128i __Y) +{ + return (__mmask8) __builtin_ia32_cmpq128_mask ((__v2di) __X, + (__v2di) __Y, 4, + (__mmask8) -1); +} + +extern __inline __mmask8 + __attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) +_mm_mask_cmplt_epi64_mask (__mmask8 __M, __m128i __X, __m128i __Y) +{ + return (__mmask8) __builtin_ia32_cmpq128_mask ((__v2di) __X, + (__v2di) __Y, 1, + (__mmask8) __M); +} + +extern __inline __mmask8 + __attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) +_mm_cmplt_epi64_mask (__m128i __X, __m128i __Y) +{ + return (__mmask8) __builtin_ia32_cmpq128_mask ((__v2di) __X, + (__v2di) __Y, 1, + (__mmask8) -1); +} + +extern __inline __mmask8 + __attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) +_mm_mask_cmpge_epi64_mask (__mmask8 __M, __m128i __X, __m128i __Y) +{ + return (__mmask8) __builtin_ia32_cmpq128_mask ((__v2di) __X, + (__v2di) __Y, 5, + (__mmask8) __M); +} + +extern __inline __mmask8 + __attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) +_mm_cmpge_epi64_mask (__m128i __X, __m128i __Y) +{ + return (__mmask8) __builtin_ia32_cmpq128_mask ((__v2di) __X, + (__v2di) __Y, 5, + (__mmask8) -1); +} + +extern __inline __mmask8 + __attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) +_mm_mask_cmple_epi64_mask (__mmask8 __M, __m128i __X, __m128i __Y) +{ + return (__mmask8) __builtin_ia32_cmpq128_mask ((__v2di) __X, + (__v2di) __Y, 2, + (__mmask8) __M); +} + +extern __inline __mmask8 + __attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) +_mm_cmple_epi64_mask (__m128i __X, __m128i __Y) +{ + return (__mmask8) __builtin_ia32_cmpq128_mask ((__v2di) __X, + (__v2di) __Y, 2, + (__mmask8) -1); +} + #ifdef __OPTIMIZE__ extern __inline __m256i __attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) @@ -11771,582 +12347,6 @@ _mm256_permutex_pd (__m256d __X, const i (__mmask8) -1); } -extern __inline __mmask8 - __attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) -_mm256_mask_cmpneq_epu32_mask (__mmask8 __M, __m256i __X, __m256i __Y) -{ - return (__mmask8) __builtin_ia32_ucmpd256_mask ((__v8si) __X, - (__v8si) __Y, 4, - (__mmask8) __M); -} - -extern __inline __mmask8 - __attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) -_mm256_cmpneq_epu32_mask (__m256i __X, __m256i __Y) -{ - return (__mmask8) __builtin_ia32_ucmpd256_mask ((__v8si) __X, - (__v8si) __Y, 4, - (__mmask8) -1); -} - -extern __inline __mmask8 - __attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) -_mm256_mask_cmplt_epu32_mask (__mmask8 __M, __m256i __X, __m256i __Y) -{ - return (__mmask8) __builtin_ia32_ucmpd256_mask ((__v8si) __X, - (__v8si) __Y, 1, - (__mmask8) __M); -} - -extern __inline __mmask8 - __attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) -_mm256_cmplt_epu32_mask (__m256i __X, __m256i __Y) -{ - return (__mmask8) __builtin_ia32_ucmpd256_mask ((__v8si) __X, - (__v8si) __Y, 1, - (__mmask8) -1); -} - -extern __inline __mmask8 - __attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) -_mm256_mask_cmpge_epu32_mask (__mmask8 __M, __m256i __X, __m256i __Y) -{ - return (__mmask8) __builtin_ia32_ucmpd256_mask ((__v8si) __X, - (__v8si) __Y, 5, - (__mmask8) __M); -} - -extern __inline __mmask8 - __attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) -_mm256_cmpge_epu32_mask (__m256i __X, __m256i __Y) -{ - return (__mmask8) __builtin_ia32_ucmpd256_mask ((__v8si) __X, - (__v8si) __Y, 5, - (__mmask8) -1); -} - -extern __inline __mmask8 - __attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) -_mm256_mask_cmple_epu32_mask (__mmask8 __M, __m256i __X, __m256i __Y) -{ - return (__mmask8) __builtin_ia32_ucmpd256_mask ((__v8si) __X, - (__v8si) __Y, 2, - (__mmask8) __M); -} - -extern __inline __mmask8 - __attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) -_mm256_cmple_epu32_mask (__m256i __X, __m256i __Y) -{ - return (__mmask8) __builtin_ia32_ucmpd256_mask ((__v8si) __X, - (__v8si) __Y, 2, - (__mmask8) -1); -} - -extern __inline __mmask8 - __attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) -_mm256_mask_cmpneq_epu64_mask (__mmask8 __M, __m256i __X, __m256i __Y) -{ - return (__mmask8) __builtin_ia32_ucmpq256_mask ((__v4di) __X, - (__v4di) __Y, 4, - (__mmask8) __M); -} - -extern __inline __mmask8 - __attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) -_mm256_cmpneq_epu64_mask (__m256i __X, __m256i __Y) -{ - return (__mmask8) __builtin_ia32_ucmpq256_mask ((__v4di) __X, - (__v4di) __Y, 4, - (__mmask8) -1); -} - -extern __inline __mmask8 - __attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) -_mm256_mask_cmplt_epu64_mask (__mmask8 __M, __m256i __X, __m256i __Y) -{ - return (__mmask8) __builtin_ia32_ucmpq256_mask ((__v4di) __X, - (__v4di) __Y, 1, - (__mmask8) __M); -} - -extern __inline __mmask8 - __attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) -_mm256_cmplt_epu64_mask (__m256i __X, __m256i __Y) -{ - return (__mmask8) __builtin_ia32_ucmpq256_mask ((__v4di) __X, - (__v4di) __Y, 1, - (__mmask8) -1); -} - -extern __inline __mmask8 - __attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) -_mm256_mask_cmpge_epu64_mask (__mmask8 __M, __m256i __X, __m256i __Y) -{ - return (__mmask8) __builtin_ia32_ucmpq256_mask ((__v4di) __X, - (__v4di) __Y, 5, - (__mmask8) __M); -} - -extern __inline __mmask8 - __attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) -_mm256_cmpge_epu64_mask (__m256i __X, __m256i __Y) -{ - return (__mmask8) __builtin_ia32_ucmpq256_mask ((__v4di) __X, - (__v4di) __Y, 5, - (__mmask8) -1); -} - -extern __inline __mmask8 - __attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) -_mm256_mask_cmple_epu64_mask (__mmask8 __M, __m256i __X, __m256i __Y) -{ - return (__mmask8) __builtin_ia32_ucmpq256_mask ((__v4di) __X, - (__v4di) __Y, 2, - (__mmask8) __M); -} - -extern __inline __mmask8 - __attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) -_mm256_cmple_epu64_mask (__m256i __X, __m256i __Y) -{ - return (__mmask8) __builtin_ia32_ucmpq256_mask ((__v4di) __X, - (__v4di) __Y, 2, - (__mmask8) -1); -} - -extern __inline __mmask8 - __attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) -_mm256_mask_cmpneq_epi32_mask (__mmask8 __M, __m256i __X, __m256i __Y) -{ - return (__mmask8) __builtin_ia32_cmpd256_mask ((__v8si) __X, - (__v8si) __Y, 4, - (__mmask8) __M); -} - -extern __inline __mmask8 - __attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) -_mm256_cmpneq_epi32_mask (__m256i __X, __m256i __Y) -{ - return (__mmask8) __builtin_ia32_cmpd256_mask ((__v8si) __X, - (__v8si) __Y, 4, - (__mmask8) -1); -} - -extern __inline __mmask8 - __attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) -_mm256_mask_cmplt_epi32_mask (__mmask8 __M, __m256i __X, __m256i __Y) -{ - return (__mmask8) __builtin_ia32_cmpd256_mask ((__v8si) __X, - (__v8si) __Y, 1, - (__mmask8) __M); -} - -extern __inline __mmask8 - __attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) -_mm256_cmplt_epi32_mask (__m256i __X, __m256i __Y) -{ - return (__mmask8) __builtin_ia32_cmpd256_mask ((__v8si) __X, - (__v8si) __Y, 1, - (__mmask8) -1); -} - -extern __inline __mmask8 - __attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) -_mm256_mask_cmpge_epi32_mask (__mmask8 __M, __m256i __X, __m256i __Y) -{ - return (__mmask8) __builtin_ia32_cmpd256_mask ((__v8si) __X, - (__v8si) __Y, 5, - (__mmask8) __M); -} - -extern __inline __mmask8 - __attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) -_mm256_cmpge_epi32_mask (__m256i __X, __m256i __Y) -{ - return (__mmask8) __builtin_ia32_cmpd256_mask ((__v8si) __X, - (__v8si) __Y, 5, - (__mmask8) -1); -} - -extern __inline __mmask8 - __attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) -_mm256_mask_cmple_epi32_mask (__mmask8 __M, __m256i __X, __m256i __Y) -{ - return (__mmask8) __builtin_ia32_cmpd256_mask ((__v8si) __X, - (__v8si) __Y, 2, - (__mmask8) __M); -} - -extern __inline __mmask8 - __attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) -_mm256_cmple_epi32_mask (__m256i __X, __m256i __Y) -{ - return (__mmask8) __builtin_ia32_cmpd256_mask ((__v8si) __X, - (__v8si) __Y, 2, - (__mmask8) -1); -} - -extern __inline __mmask8 - __attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) -_mm256_mask_cmpneq_epi64_mask (__mmask8 __M, __m256i __X, __m256i __Y) -{ - return (__mmask8) __builtin_ia32_cmpq256_mask ((__v4di) __X, - (__v4di) __Y, 4, - (__mmask8) __M); -} - -extern __inline __mmask8 - __attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) -_mm256_cmpneq_epi64_mask (__m256i __X, __m256i __Y) -{ - return (__mmask8) __builtin_ia32_cmpq256_mask ((__v4di) __X, - (__v4di) __Y, 4, - (__mmask8) -1); -} - -extern __inline __mmask8 - __attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) -_mm256_mask_cmplt_epi64_mask (__mmask8 __M, __m256i __X, __m256i __Y) -{ - return (__mmask8) __builtin_ia32_cmpq256_mask ((__v4di) __X, - (__v4di) __Y, 1, - (__mmask8) __M); -} - -extern __inline __mmask8 - __attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) -_mm256_cmplt_epi64_mask (__m256i __X, __m256i __Y) -{ - return (__mmask8) __builtin_ia32_cmpq256_mask ((__v4di) __X, - (__v4di) __Y, 1, - (__mmask8) -1); -} - -extern __inline __mmask8 - __attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) -_mm256_mask_cmpge_epi64_mask (__mmask8 __M, __m256i __X, __m256i __Y) -{ - return (__mmask8) __builtin_ia32_cmpq256_mask ((__v4di) __X, - (__v4di) __Y, 5, - (__mmask8) __M); -} - -extern __inline __mmask8 - __attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) -_mm256_cmpge_epi64_mask (__m256i __X, __m256i __Y) -{ - return (__mmask8) __builtin_ia32_cmpq256_mask ((__v4di) __X, - (__v4di) __Y, 5, - (__mmask8) -1); -} - -extern __inline __mmask8 - __attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) -_mm256_mask_cmple_epi64_mask (__mmask8 __M, __m256i __X, __m256i __Y) -{ - return (__mmask8) __builtin_ia32_cmpq256_mask ((__v4di) __X, - (__v4di) __Y, 2, - (__mmask8) __M); -} - -extern __inline __mmask8 - __attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) -_mm256_cmple_epi64_mask (__m256i __X, __m256i __Y) -{ - return (__mmask8) __builtin_ia32_cmpq256_mask ((__v4di) __X, - (__v4di) __Y, 2, - (__mmask8) -1); -} - -extern __inline __mmask8 - __attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) -_mm_mask_cmpneq_epu32_mask (__mmask8 __M, __m128i __X, __m128i __Y) -{ - return (__mmask8) __builtin_ia32_ucmpd128_mask ((__v4si) __X, - (__v4si) __Y, 4, - (__mmask8) __M); -} - -extern __inline __mmask8 - __attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) -_mm_cmpneq_epu32_mask (__m128i __X, __m128i __Y) -{ - return (__mmask8) __builtin_ia32_ucmpd128_mask ((__v4si) __X, - (__v4si) __Y, 4, - (__mmask8) -1); -} - -extern __inline __mmask8 - __attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) -_mm_mask_cmplt_epu32_mask (__mmask8 __M, __m128i __X, __m128i __Y) -{ - return (__mmask8) __builtin_ia32_ucmpd128_mask ((__v4si) __X, - (__v4si) __Y, 1, - (__mmask8) __M); -} - -extern __inline __mmask8 - __attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) -_mm_cmplt_epu32_mask (__m128i __X, __m128i __Y) -{ - return (__mmask8) __builtin_ia32_ucmpd128_mask ((__v4si) __X, - (__v4si) __Y, 1, - (__mmask8) -1); -} - -extern __inline __mmask8 - __attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) -_mm_mask_cmpge_epu32_mask (__mmask8 __M, __m128i __X, __m128i __Y) -{ - return (__mmask8) __builtin_ia32_ucmpd128_mask ((__v4si) __X, - (__v4si) __Y, 5, - (__mmask8) __M); -} - -extern __inline __mmask8 - __attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) -_mm_cmpge_epu32_mask (__m128i __X, __m128i __Y) -{ - return (__mmask8) __builtin_ia32_ucmpd128_mask ((__v4si) __X, - (__v4si) __Y, 5, - (__mmask8) -1); -} - -extern __inline __mmask8 - __attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) -_mm_mask_cmple_epu32_mask (__mmask8 __M, __m128i __X, __m128i __Y) -{ - return (__mmask8) __builtin_ia32_ucmpd128_mask ((__v4si) __X, - (__v4si) __Y, 2, - (__mmask8) __M); -} - -extern __inline __mmask8 - __attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) -_mm_cmple_epu32_mask (__m128i __X, __m128i __Y) -{ - return (__mmask8) __builtin_ia32_ucmpd128_mask ((__v4si) __X, - (__v4si) __Y, 2, - (__mmask8) -1); -} - -extern __inline __mmask8 - __attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) -_mm_mask_cmpneq_epu64_mask (__mmask8 __M, __m128i __X, __m128i __Y) -{ - return (__mmask8) __builtin_ia32_ucmpq128_mask ((__v2di) __X, - (__v2di) __Y, 4, - (__mmask8) __M); -} - -extern __inline __mmask8 - __attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) -_mm_cmpneq_epu64_mask (__m128i __X, __m128i __Y) -{ - return (__mmask8) __builtin_ia32_ucmpq128_mask ((__v2di) __X, - (__v2di) __Y, 4, - (__mmask8) -1); -} - -extern __inline __mmask8 - __attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) -_mm_mask_cmplt_epu64_mask (__mmask8 __M, __m128i __X, __m128i __Y) -{ - return (__mmask8) __builtin_ia32_ucmpq128_mask ((__v2di) __X, - (__v2di) __Y, 1, - (__mmask8) __M); -} - -extern __inline __mmask8 - __attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) -_mm_cmplt_epu64_mask (__m128i __X, __m128i __Y) -{ - return (__mmask8) __builtin_ia32_ucmpq128_mask ((__v2di) __X, - (__v2di) __Y, 1, - (__mmask8) -1); -} - -extern __inline __mmask8 - __attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) -_mm_mask_cmpge_epu64_mask (__mmask8 __M, __m128i __X, __m128i __Y) -{ - return (__mmask8) __builtin_ia32_ucmpq128_mask ((__v2di) __X, - (__v2di) __Y, 5, - (__mmask8) __M); -} - -extern __inline __mmask8 - __attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) -_mm_cmpge_epu64_mask (__m128i __X, __m128i __Y) -{ - return (__mmask8) __builtin_ia32_ucmpq128_mask ((__v2di) __X, - (__v2di) __Y, 5, - (__mmask8) -1); -} - -extern __inline __mmask8 - __attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) -_mm_mask_cmple_epu64_mask (__mmask8 __M, __m128i __X, __m128i __Y) -{ - return (__mmask8) __builtin_ia32_ucmpq128_mask ((__v2di) __X, - (__v2di) __Y, 2, - (__mmask8) __M); -} - -extern __inline __mmask8 - __attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) -_mm_cmple_epu64_mask (__m128i __X, __m128i __Y) -{ - return (__mmask8) __builtin_ia32_ucmpq128_mask ((__v2di) __X, - (__v2di) __Y, 2, - (__mmask8) -1); -} - -extern __inline __mmask8 - __attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) -_mm_mask_cmpneq_epi32_mask (__mmask8 __M, __m128i __X, __m128i __Y) -{ - return (__mmask8) __builtin_ia32_cmpd128_mask ((__v4si) __X, - (__v4si) __Y, 4, - (__mmask8) __M); -} - -extern __inline __mmask8 - __attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) -_mm_cmpneq_epi32_mask (__m128i __X, __m128i __Y) -{ - return (__mmask8) __builtin_ia32_cmpd128_mask ((__v4si) __X, - (__v4si) __Y, 4, - (__mmask8) -1); -} - -extern __inline __mmask8 - __attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) -_mm_mask_cmplt_epi32_mask (__mmask8 __M, __m128i __X, __m128i __Y) -{ - return (__mmask8) __builtin_ia32_cmpd128_mask ((__v4si) __X, - (__v4si) __Y, 1, - (__mmask8) __M); -} - -extern __inline __mmask8 - __attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) -_mm_cmplt_epi32_mask (__m128i __X, __m128i __Y) -{ - return (__mmask8) __builtin_ia32_cmpd128_mask ((__v4si) __X, - (__v4si) __Y, 1, - (__mmask8) -1); -} - -extern __inline __mmask8 - __attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) -_mm_mask_cmpge_epi32_mask (__mmask8 __M, __m128i __X, __m128i __Y) -{ - return (__mmask8) __builtin_ia32_cmpd128_mask ((__v4si) __X, - (__v4si) __Y, 5, - (__mmask8) __M); -} - -extern __inline __mmask8 - __attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) -_mm_cmpge_epi32_mask (__m128i __X, __m128i __Y) -{ - return (__mmask8) __builtin_ia32_cmpd128_mask ((__v4si) __X, - (__v4si) __Y, 5, - (__mmask8) -1); -} - -extern __inline __mmask8 - __attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) -_mm_mask_cmple_epi32_mask (__mmask8 __M, __m128i __X, __m128i __Y) -{ - return (__mmask8) __builtin_ia32_cmpd128_mask ((__v4si) __X, - (__v4si) __Y, 2, - (__mmask8) __M); -} - -extern __inline __mmask8 - __attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) -_mm_cmple_epi32_mask (__m128i __X, __m128i __Y) -{ - return (__mmask8) __builtin_ia32_cmpd128_mask ((__v4si) __X, - (__v4si) __Y, 2, - (__mmask8) -1); -} - -extern __inline __mmask8 - __attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) -_mm_mask_cmpneq_epi64_mask (__mmask8 __M, __m128i __X, __m128i __Y) -{ - return (__mmask8) __builtin_ia32_cmpq128_mask ((__v2di) __X, - (__v2di) __Y, 4, - (__mmask8) __M); -} - -extern __inline __mmask8 - __attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) -_mm_cmpneq_epi64_mask (__m128i __X, __m128i __Y) -{ - return (__mmask8) __builtin_ia32_cmpq128_mask ((__v2di) __X, - (__v2di) __Y, 4, - (__mmask8) -1); -} - -extern __inline __mmask8 - __attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) -_mm_mask_cmplt_epi64_mask (__mmask8 __M, __m128i __X, __m128i __Y) -{ - return (__mmask8) __builtin_ia32_cmpq128_mask ((__v2di) __X, - (__v2di) __Y, 1, - (__mmask8) __M); -} - -extern __inline __mmask8 - __attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) -_mm_cmplt_epi64_mask (__m128i __X, __m128i __Y) -{ - return (__mmask8) __builtin_ia32_cmpq128_mask ((__v2di) __X, - (__v2di) __Y, 1, - (__mmask8) -1); -} - -extern __inline __mmask8 - __attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) -_mm_mask_cmpge_epi64_mask (__mmask8 __M, __m128i __X, __m128i __Y) -{ - return (__mmask8) __builtin_ia32_cmpq128_mask ((__v2di) __X, - (__v2di) __Y, 5, - (__mmask8) __M); -} - -extern __inline __mmask8 - __attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) -_mm_cmpge_epi64_mask (__m128i __X, __m128i __Y) -{ - return (__mmask8) __builtin_ia32_cmpq128_mask ((__v2di) __X, - (__v2di) __Y, 5, - (__mmask8) -1); -} - -extern __inline __mmask8 - __attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) -_mm_mask_cmple_epi64_mask (__mmask8 __M, __m128i __X, __m128i __Y) -{ - return (__mmask8) __builtin_ia32_cmpq128_mask ((__v2di) __X, - (__v2di) __Y, 2, - (__mmask8) __M); -} - -extern __inline __mmask8 - __attribute__ ((__gnu_inline__, __always_inline__, __artificial__)) -_mm_cmple_epi64_mask (__m128i __X, __m128i __Y) -{ - return (__mmask8) __builtin_ia32_cmpq128_mask ((__v2di) __X, - (__v2di) __Y, 2, - (__mmask8) -1); -} - #else #define _mm256_permutex_pd(X, M) \ ((__m256d) __builtin_ia32_permdf256_mask ((__v4df)(__m256d)(X), (int)(M), \ --- gcc/testsuite/gcc.target/i386/pr79932-2.c (nonexistent) +++ gcc/testsuite/gcc.target/i386/pr79932-2.c (revision 247684) @@ -0,0 +1,78 @@ +/* PR target/79932 */ +/* { dg-do compile } */ +/* { dg-options "-O0 -mavx512vl" } */ + +#include <x86intrin.h> + +__m256i a, b; +__m128i c, d; +__mmask32 e, f[64]; + +void +foo (void) +{ + f[0] = _mm256_cmpge_epi32_mask (a, b); + f[1] = _mm256_cmpge_epi64_mask (a, b); + f[2] = _mm256_cmpge_epu32_mask (a, b); + f[3] = _mm256_cmpge_epu64_mask (a, b); + f[4] = _mm256_cmple_epi32_mask (a, b); + f[5] = _mm256_cmple_epi64_mask (a, b); + f[6] = _mm256_cmple_epu32_mask (a, b); + f[7] = _mm256_cmple_epu64_mask (a, b); + f[8] = _mm256_cmplt_epi32_mask (a, b); + f[9] = _mm256_cmplt_epi64_mask (a, b); + f[10] = _mm256_cmplt_epu32_mask (a, b); + f[11] = _mm256_cmplt_epu64_mask (a, b); + f[12] = _mm256_cmpneq_epi32_mask (a, b); + f[13] = _mm256_cmpneq_epi64_mask (a, b); + f[14] = _mm256_cmpneq_epu32_mask (a, b); + f[15] = _mm256_cmpneq_epu64_mask (a, b); + f[16] = _mm256_mask_cmpge_epi32_mask (e, a, b); + f[17] = _mm256_mask_cmpge_epi64_mask (e, a, b); + f[18] = _mm256_mask_cmpge_epu32_mask (e, a, b); + f[19] = _mm256_mask_cmpge_epu64_mask (e, a, b); + f[20] = _mm256_mask_cmple_epi32_mask (e, a, b); + f[21] = _mm256_mask_cmple_epi64_mask (e, a, b); + f[22] = _mm256_mask_cmple_epu32_mask (e, a, b); + f[23] = _mm256_mask_cmple_epu64_mask (e, a, b); + f[24] = _mm256_mask_cmplt_epi32_mask (e, a, b); + f[25] = _mm256_mask_cmplt_epi64_mask (e, a, b); + f[26] = _mm256_mask_cmplt_epu32_mask (e, a, b); + f[27] = _mm256_mask_cmplt_epu64_mask (e, a, b); + f[28] = _mm256_mask_cmpneq_epi32_mask (e, a, b); + f[29] = _mm256_mask_cmpneq_epi64_mask (e, a, b); + f[30] = _mm256_mask_cmpneq_epu32_mask (e, a, b); + f[31] = _mm256_mask_cmpneq_epu64_mask (e, a, b); + f[32] = _mm_cmpge_epi32_mask (c, d); + f[33] = _mm_cmpge_epi64_mask (c, d); + f[34] = _mm_cmpge_epu32_mask (c, d); + f[35] = _mm_cmpge_epu64_mask (c, d); + f[36] = _mm_cmple_epi32_mask (c, d); + f[37] = _mm_cmple_epi64_mask (c, d); + f[38] = _mm_cmple_epu32_mask (c, d); + f[39] = _mm_cmple_epu64_mask (c, d); + f[40] = _mm_cmplt_epi32_mask (c, d); + f[41] = _mm_cmplt_epi64_mask (c, d); + f[42] = _mm_cmplt_epu32_mask (c, d); + f[43] = _mm_cmplt_epu64_mask (c, d); + f[44] = _mm_cmpneq_epi32_mask (c, d); + f[45] = _mm_cmpneq_epi64_mask (c, d); + f[46] = _mm_cmpneq_epu32_mask (c, d); + f[47] = _mm_cmpneq_epu64_mask (c, d); + f[48] = _mm_mask_cmpge_epi32_mask (e, c, d); + f[49] = _mm_mask_cmpge_epi64_mask (e, c, d); + f[50] = _mm_mask_cmpge_epu32_mask (e, c, d); + f[51] = _mm_mask_cmpge_epu64_mask (e, c, d); + f[52] = _mm_mask_cmple_epi32_mask (e, c, d); + f[53] = _mm_mask_cmple_epi64_mask (e, c, d); + f[54] = _mm_mask_cmple_epu32_mask (e, c, d); + f[55] = _mm_mask_cmple_epu64_mask (e, c, d); + f[56] = _mm_mask_cmplt_epi32_mask (e, c, d); + f[57] = _mm_mask_cmplt_epi64_mask (e, c, d); + f[58] = _mm_mask_cmplt_epu32_mask (e, c, d); + f[59] = _mm_mask_cmplt_epu64_mask (e, c, d); + f[60] = _mm_mask_cmpneq_epi32_mask (e, c, d); + f[61] = _mm_mask_cmpneq_epi64_mask (e, c, d); + f[62] = _mm_mask_cmpneq_epu32_mask (e, c, d); + f[63] = _mm_mask_cmpneq_epu64_mask (e, c, d); +} 2017-05-30 Jakub Jelinek <jakub@redhat.com> Backported from mainline 2017-03-09 Jakub Jelinek <jakub@redhat.com> PR sanitizer/79944 * asan.c (get_mem_refs_of_builtin_call): For BUILT_IN_ATOMIC* and BUILT_IN_SYNC*, determine the access type from the size suffix and always build a MEM_REF with that type. Handle forgotten BUILT_IN_SYNC_FETCH_AND_NAND_16 and BUILT_IN_SYNC_NAND_AND_FETCH_16. * c-c++-common/asan/pr79944.c: New test. --- gcc/asan.c (revision 247684) +++ gcc/asan.c (revision 247685) @@ -587,218 +587,208 @@ get_mem_refs_of_builtin_call (const gcal case BUILT_IN_STRLEN: source0 = gimple_call_arg (call, 0); len = gimple_call_lhs (call); - break ; + break; /* And now the __atomic* and __sync builtins. These are handled differently from the classical memory memory access builtins above. */ case BUILT_IN_ATOMIC_LOAD_1: - case BUILT_IN_ATOMIC_LOAD_2: - case BUILT_IN_ATOMIC_LOAD_4: - case BUILT_IN_ATOMIC_LOAD_8: - case BUILT_IN_ATOMIC_LOAD_16: is_store = false; - /* fall through. */ - + /* FALLTHRU */ case BUILT_IN_SYNC_FETCH_AND_ADD_1: - case BUILT_IN_SYNC_FETCH_AND_ADD_2: - case BUILT_IN_SYNC_FETCH_AND_ADD_4: - case BUILT_IN_SYNC_FETCH_AND_ADD_8: - case BUILT_IN_SYNC_FETCH_AND_ADD_16: - case BUILT_IN_SYNC_FETCH_AND_SUB_1: - case BUILT_IN_SYNC_FETCH_AND_SUB_2: - case BUILT_IN_SYNC_FETCH_AND_SUB_4: - case BUILT_IN_SYNC_FETCH_AND_SUB_8: - case BUILT_IN_SYNC_FETCH_AND_SUB_16: - case BUILT_IN_SYNC_FETCH_AND_OR_1: - case BUILT_IN_SYNC_FETCH_AND_OR_2: - case BUILT_IN_SYNC_FETCH_AND_OR_4: - case BUILT_IN_SYNC_FETCH_AND_OR_8: - case BUILT_IN_SYNC_FETCH_AND_OR_16: - case BUILT_IN_SYNC_FETCH_AND_AND_1: - case BUILT_IN_SYNC_FETCH_AND_AND_2: - case BUILT_IN_SYNC_FETCH_AND_AND_4: - case BUILT_IN_SYNC_FETCH_AND_AND_8: - case BUILT_IN_SYNC_FETCH_AND_AND_16: - case BUILT_IN_SYNC_FETCH_AND_XOR_1: - case BUILT_IN_SYNC_FETCH_AND_XOR_2: - case BUILT_IN_SYNC_FETCH_AND_XOR_4: - case BUILT_IN_SYNC_FETCH_AND_XOR_8: - case BUILT_IN_SYNC_FETCH_AND_XOR_16: - case BUILT_IN_SYNC_FETCH_AND_NAND_1: - case BUILT_IN_SYNC_FETCH_AND_NAND_2: - case BUILT_IN_SYNC_FETCH_AND_NAND_4: - case BUILT_IN_SYNC_FETCH_AND_NAND_8: - case BUILT_IN_SYNC_ADD_AND_FETCH_1: - case BUILT_IN_SYNC_ADD_AND_FETCH_2: - case BUILT_IN_SYNC_ADD_AND_FETCH_4: - case BUILT_IN_SYNC_ADD_AND_FETCH_8: - case BUILT_IN_SYNC_ADD_AND_FETCH_16: - case BUILT_IN_SYNC_SUB_AND_FETCH_1: - case BUILT_IN_SYNC_SUB_AND_FETCH_2: - case BUILT_IN_SYNC_SUB_AND_FETCH_4: - case BUILT_IN_SYNC_SUB_AND_FETCH_8: - case BUILT_IN_SYNC_SUB_AND_FETCH_16: - case BUILT_IN_SYNC_OR_AND_FETCH_1: - case BUILT_IN_SYNC_OR_AND_FETCH_2: - case BUILT_IN_SYNC_OR_AND_FETCH_4: - case BUILT_IN_SYNC_OR_AND_FETCH_8: - case BUILT_IN_SYNC_OR_AND_FETCH_16: - case BUILT_IN_SYNC_AND_AND_FETCH_1: - case BUILT_IN_SYNC_AND_AND_FETCH_2: - case BUILT_IN_SYNC_AND_AND_FETCH_4: - case BUILT_IN_SYNC_AND_AND_FETCH_8: - case BUILT_IN_SYNC_AND_AND_FETCH_16: - case BUILT_IN_SYNC_XOR_AND_FETCH_1: - case BUILT_IN_SYNC_XOR_AND_FETCH_2: - case BUILT_IN_SYNC_XOR_AND_FETCH_4: - case BUILT_IN_SYNC_XOR_AND_FETCH_8: - case BUILT_IN_SYNC_XOR_AND_FETCH_16: - case BUILT_IN_SYNC_NAND_AND_FETCH_1: - case BUILT_IN_SYNC_NAND_AND_FETCH_2: - case BUILT_IN_SYNC_NAND_AND_FETCH_4: - case BUILT_IN_SYNC_NAND_AND_FETCH_8: - case BUILT_IN_SYNC_BOOL_COMPARE_AND_SWAP_1: - case BUILT_IN_SYNC_BOOL_COMPARE_AND_SWAP_2: - case BUILT_IN_SYNC_BOOL_COMPARE_AND_SWAP_4: - case BUILT_IN_SYNC_BOOL_COMPARE_AND_SWAP_8: - case BUILT_IN_SYNC_BOOL_COMPARE_AND_SWAP_16: - case BUILT_IN_SYNC_VAL_COMPARE_AND_SWAP_1: - case BUILT_IN_SYNC_VAL_COMPARE_AND_SWAP_2: - case BUILT_IN_SYNC_VAL_COMPARE_AND_SWAP_4: - case BUILT_IN_SYNC_VAL_COMPARE_AND_SWAP_8: - case BUILT_IN_SYNC_VAL_COMPARE_AND_SWAP_16: - case BUILT_IN_SYNC_LOCK_TEST_AND_SET_1: - case BUILT_IN_SYNC_LOCK_TEST_AND_SET_2: - case BUILT_IN_SYNC_LOCK_TEST_AND_SET_4: - case BUILT_IN_SYNC_LOCK_TEST_AND_SET_8: - case BUILT_IN_SYNC_LOCK_TEST_AND_SET_16: - case BUILT_IN_SYNC_LOCK_RELEASE_1: - case BUILT_IN_SYNC_LOCK_RELEASE_2: - case BUILT_IN_SYNC_LOCK_RELEASE_4: - case BUILT_IN_SYNC_LOCK_RELEASE_8: - case BUILT_IN_SYNC_LOCK_RELEASE_16: - case BUILT_IN_ATOMIC_EXCHANGE_1: - case BUILT_IN_ATOMIC_EXCHANGE_2: - case BUILT_IN_ATOMIC_EXCHANGE_4: - case BUILT_IN_ATOMIC_EXCHANGE_8: - case BUILT_IN_ATOMIC_EXCHANGE_16: - case BUILT_IN_ATOMIC_COMPARE_EXCHANGE_1: - case BUILT_IN_ATOMIC_COMPARE_EXCHANGE_2: - case BUILT_IN_ATOMIC_COMPARE_EXCHANGE_4: - case BUILT_IN_ATOMIC_COMPARE_EXCHANGE_8: - case BUILT_IN_ATOMIC_COMPARE_EXCHANGE_16: - case BUILT_IN_ATOMIC_STORE_1: - case BUILT_IN_ATOMIC_STORE_2: - case BUILT_IN_ATOMIC_STORE_4: - case BUILT_IN_ATOMIC_STORE_8: - case BUILT_IN_ATOMIC_STORE_16: - case BUILT_IN_ATOMIC_ADD_FETCH_1: - case BUILT_IN_ATOMIC_ADD_FETCH_2: - case BUILT_IN_ATOMIC_ADD_FETCH_4: - case BUILT_IN_ATOMIC_ADD_FETCH_8: - case BUILT_IN_ATOMIC_ADD_FETCH_16: - case BUILT_IN_ATOMIC_SUB_FETCH_1: - case BUILT_IN_ATOMIC_SUB_FETCH_2: - case BUILT_IN_ATOMIC_SUB_FETCH_4: - case BUILT_IN_ATOMIC_SUB_FETCH_8: - case BUILT_IN_ATOMIC_SUB_FETCH_16: - case BUILT_IN_ATOMIC_AND_FETCH_1: - case BUILT_IN_ATOMIC_AND_FETCH_2: - case BUILT_IN_ATOMIC_AND_FETCH_4: - case BUILT_IN_ATOMIC_AND_FETCH_8: - case BUILT_IN_ATOMIC_AND_FETCH_16: - case BUILT_IN_ATOMIC_NAND_FETCH_1: - case BUILT_IN_ATOMIC_NAND_FETCH_2: - case BUILT_IN_ATOMIC_NAND_FETCH_4: - case BUILT_IN_ATOMIC_NAND_FETCH_8: - case BUILT_IN_ATOMIC_NAND_FETCH_16: - case BUILT_IN_ATOMIC_XOR_FETCH_1: - case BUILT_IN_ATOMIC_XOR_FETCH_2: - case BUILT_IN_ATOMIC_XOR_FETCH_4: - case BUILT_IN_ATOMIC_XOR_FETCH_8: - case BUILT_IN_ATOMIC_XOR_FETCH_16: - case BUILT_IN_ATOMIC_OR_FETCH_1: - case BUILT_IN_ATOMIC_OR_FETCH_2: - case BUILT_IN_ATOMIC_OR_FETCH_4: - case BUILT_IN_ATOMIC_OR_FETCH_8: - case BUILT_IN_ATOMIC_OR_FETCH_16: - case BUILT_IN_ATOMIC_FETCH_ADD_1: - case BUILT_IN_ATOMIC_FETCH_ADD_2: - case BUILT_IN_ATOMIC_FETCH_ADD_4: - case BUILT_IN_ATOMIC_FETCH_ADD_8: - case BUILT_IN_ATOMIC_FETCH_ADD_16: - case BUILT_IN_ATOMIC_FETCH_SUB_1: - case BUILT_IN_ATOMIC_FETCH_SUB_2: - case BUILT_IN_ATOMIC_FETCH_SUB_4: - case BUILT_IN_ATOMIC_FETCH_SUB_8: - case BUILT_IN_ATOMIC_FETCH_SUB_16: - case BUILT_IN_ATOMIC_FETCH_AND_1: - case BUILT_IN_ATOMIC_FETCH_AND_2: - case BUILT_IN_ATOMIC_FETCH_AND_4: - case BUILT_IN_ATOMIC_FETCH_AND_8: - case BUILT_IN_ATOMIC_FETCH_AND_16: - case BUILT_IN_ATOMIC_FETCH_NAND_1: - case BUILT_IN_ATOMIC_FETCH_NAND_2: - case BUILT_IN_ATOMIC_FETCH_NAND_4: - case BUILT_IN_ATOMIC_FETCH_NAND_8: - case BUILT_IN_ATOMIC_FETCH_NAND_16: - case BUILT_IN_ATOMIC_FETCH_XOR_1: - case BUILT_IN_ATOMIC_FETCH_XOR_2: - case BUILT_IN_ATOMIC_FETCH_XOR_4: - case BUILT_IN_ATOMIC_FETCH_XOR_8: - case BUILT_IN_ATOMIC_FETCH_XOR_16: - case BUILT_IN_ATOMIC_FETCH_OR_1: + access_size = 1; + goto do_atomic; + + case BUILT_IN_ATOMIC_LOAD_2: + is_store = false; + /* FALLTHRU */ + case BUILT_IN_SYNC_FETCH_AND_ADD_2: + case BUILT_IN_SYNC_FETCH_AND_SUB_2: + case BUILT_IN_SYNC_FETCH_AND_OR_2: + case BUILT_IN_SYNC_FETCH_AND_AND_2: + case BUILT_IN_SYNC_FETCH_AND_XOR_2: + case BUILT_IN_SYNC_FETCH_AND_NAND_2: + case BUILT_IN_SYNC_ADD_AND_FETCH_2: + case BUILT_IN_SYNC_SUB_AND_FETCH_2: + case BUILT_IN_SYNC_OR_AND_FETCH_2: + case BUILT_IN_SYNC_AND_AND_FETCH_2: + case BUILT_IN_SYNC_XOR_AND_FETCH_2: + case BUILT_IN_SYNC_NAND_AND_FETCH_2: + case BUILT_IN_SYNC_BOOL_COMPARE_AND_SWAP_2: + case BUILT_IN_SYNC_VAL_COMPARE_AND_SWAP_2: + case BUILT_IN_SYNC_LOCK_TEST_AND_SET_2: + case BUILT_IN_SYNC_LOCK_RELEASE_2: + case BUILT_IN_ATOMIC_EXCHANGE_2: + case BUILT_IN_ATOMIC_COMPARE_EXCHANGE_2: + case BUILT_IN_ATOMIC_STORE_2: + case BUILT_IN_ATOMIC_ADD_FETCH_2: + case BUILT_IN_ATOMIC_SUB_FETCH_2: + case BUILT_IN_ATOMIC_AND_FETCH_2: + case BUILT_IN_ATOMIC_NAND_FETCH_2: + case BUILT_IN_ATOMIC_XOR_FETCH_2: + case BUILT_IN_ATOMIC_OR_FETCH_2: + case BUILT_IN_ATOMIC_FETCH_ADD_2: + case BUILT_IN_ATOMIC_FETCH_SUB_2: + case BUILT_IN_ATOMIC_FETCH_AND_2: + case BUILT_IN_ATOMIC_FETCH_NAND_2: + case BUILT_IN_ATOMIC_FETCH_XOR_2: case BUILT_IN_ATOMIC_FETCH_OR_2: + access_size = 2; + goto do_atomic; + + case BUILT_IN_ATOMIC_LOAD_4: + is_store = false; + /* FALLTHRU */ + case BUILT_IN_SYNC_FETCH_AND_ADD_4: + case BUILT_IN_SYNC_FETCH_AND_SUB_4: + case BUILT_IN_SYNC_FETCH_AND_OR_4: + case BUILT_IN_SYNC_FETCH_AND_AND_4: + case BUILT_IN_SYNC_FETCH_AND_XOR_4: + case BUILT_IN_SYNC_FETCH_AND_NAND_4: + case BUILT_IN_SYNC_ADD_AND_FETCH_4: + case BUILT_IN_SYNC_SUB_AND_FETCH_4: + case BUILT_IN_SYNC_OR_AND_FETCH_4: + case BUILT_IN_SYNC_AND_AND_FETCH_4: + case BUILT_IN_SYNC_XOR_AND_FETCH_4: + case BUILT_IN_SYNC_NAND_AND_FETCH_4: + case BUILT_IN_SYNC_BOOL_COMPARE_AND_SWAP_4: + case BUILT_IN_SYNC_VAL_COMPARE_AND_SWAP_4: + case BUILT_IN_SYNC_LOCK_TEST_AND_SET_4: + case BUILT_IN_SYNC_LOCK_RELEASE_4: + case BUILT_IN_ATOMIC_EXCHANGE_4: + case BUILT_IN_ATOMIC_COMPARE_EXCHANGE_4: + case BUILT_IN_ATOMIC_STORE_4: + case BUILT_IN_ATOMIC_ADD_FETCH_4: + case BUILT_IN_ATOMIC_SUB_FETCH_4: + case BUILT_IN_ATOMIC_AND_FETCH_4: + case BUILT_IN_ATOMIC_NAND_FETCH_4: + case BUILT_IN_ATOMIC_XOR_FETCH_4: + case BUILT_IN_ATOMIC_OR_FETCH_4: + case BUILT_IN_ATOMIC_FETCH_ADD_4: + case BUILT_IN_ATOMIC_FETCH_SUB_4: + case BUILT_IN_ATOMIC_FETCH_AND_4: + case BUILT_IN_ATOMIC_FETCH_NAND_4: + case BUILT_IN_ATOMIC_FETCH_XOR_4: case BUILT_IN_ATOMIC_FETCH_OR_4: + access_size = 4; + goto do_atomic; + + case BUILT_IN_ATOMIC_LOAD_8: + is_store = false; + /* FALLTHRU */ + case BUILT_IN_SYNC_FETCH_AND_ADD_8: + case BUILT_IN_SYNC_FETCH_AND_SUB_8: + case BUILT_IN_SYNC_FETCH_AND_OR_8: + case BUILT_IN_SYNC_FETCH_AND_AND_8: + case BUILT_IN_SYNC_FETCH_AND_XOR_8: + case BUILT_IN_SYNC_FETCH_AND_NAND_8: + case BUILT_IN_SYNC_ADD_AND_FETCH_8: + case BUILT_IN_SYNC_SUB_AND_FETCH_8: + case BUILT_IN_SYNC_OR_AND_FETCH_8: + case BUILT_IN_SYNC_AND_AND_FETCH_8: + case BUILT_IN_SYNC_XOR_AND_FETCH_8: + case BUILT_IN_SYNC_NAND_AND_FETCH_8: + case BUILT_IN_SYNC_BOOL_COMPARE_AND_SWAP_8: + case BUILT_IN_SYNC_VAL_COMPARE_AND_SWAP_8: + case BUILT_IN_SYNC_LOCK_TEST_AND_SET_8: + case BUILT_IN_SYNC_LOCK_RELEASE_8: + case BUILT_IN_ATOMIC_EXCHANGE_8: + case BUILT_IN_ATOMIC_COMPARE_EXCHANGE_8: + case BUILT_IN_ATOMIC_STORE_8: + case BUILT_IN_ATOMIC_ADD_FETCH_8: + case BUILT_IN_ATOMIC_SUB_FETCH_8: + case BUILT_IN_ATOMIC_AND_FETCH_8: + case BUILT_IN_ATOMIC_NAND_FETCH_8: + case BUILT_IN_ATOMIC_XOR_FETCH_8: + case BUILT_IN_ATOMIC_OR_FETCH_8: + case BUILT_IN_ATOMIC_FETCH_ADD_8: + case BUILT_IN_ATOMIC_FETCH_SUB_8: + case BUILT_IN_ATOMIC_FETCH_AND_8: + case BUILT_IN_ATOMIC_FETCH_NAND_8: + case BUILT_IN_ATOMIC_FETCH_XOR_8: case BUILT_IN_ATOMIC_FETCH_OR_8: + access_size = 8; + goto do_atomic; + + case BUILT_IN_ATOMIC_LOAD_16: + is_store = false; + /* FALLTHRU */ + case BUILT_IN_SYNC_FETCH_AND_ADD_16: + case BUILT_IN_SYNC_FETCH_AND_SUB_16: + case BUILT_IN_SYNC_FETCH_AND_OR_16: + case BUILT_IN_SYNC_FETCH_AND_AND_16: + case BUILT_IN_SYNC_FETCH_AND_XOR_16: + case BUILT_IN_SYNC_FETCH_AND_NAND_16: + case BUILT_IN_SYNC_ADD_AND_FETCH_16: + case BUILT_IN_SYNC_SUB_AND_FETCH_16: + case BUILT_IN_SYNC_OR_AND_FETCH_16: + case BUILT_IN_SYNC_AND_AND_FETCH_16: + case BUILT_IN_SYNC_XOR_AND_FETCH_16: + case BUILT_IN_SYNC_NAND_AND_FETCH_16: + case BUILT_IN_SYNC_BOOL_COMPARE_AND_SWAP_16: + case BUILT_IN_SYNC_VAL_COMPARE_AND_SWAP_16: + case BUILT_IN_SYNC_LOCK_TEST_AND_SET_16: + case BUILT_IN_SYNC_LOCK_RELEASE_16: + case BUILT_IN_ATOMIC_EXCHANGE_16: + case BUILT_IN_ATOMIC_COMPARE_EXCHANGE_16: + case BUILT_IN_ATOMIC_STORE_16: + case BUILT_IN_ATOMIC_ADD_FETCH_16: + case BUILT_IN_ATOMIC_SUB_FETCH_16: + case BUILT_IN_ATOMIC_AND_FETCH_16: + case BUILT_IN_ATOMIC_NAND_FETCH_16: + case BUILT_IN_ATOMIC_XOR_FETCH_16: + case BUILT_IN_ATOMIC_OR_FETCH_16: + case BUILT_IN_ATOMIC_FETCH_ADD_16: + case BUILT_IN_ATOMIC_FETCH_SUB_16: + case BUILT_IN_ATOMIC_FETCH_AND_16: + case BUILT_IN_ATOMIC_FETCH_NAND_16: + case BUILT_IN_ATOMIC_FETCH_XOR_16: case BUILT_IN_ATOMIC_FETCH_OR_16: + access_size = 16; + /* FALLTHRU */ + do_atomic: { dest = gimple_call_arg (call, 0); /* DEST represents the address of a memory location. instrument_derefs wants the memory location, so lets dereference the address DEST before handing it to instrument_derefs. */ - if (TREE_CODE (dest) == ADDR_EXPR) - dest = TREE_OPERAND (dest, 0); - else if (TREE_CODE (dest) == SSA_NAME || TREE_CODE (dest) == INTEGER_CST) - dest = build2 (MEM_REF, TREE_TYPE (TREE_TYPE (dest)), - dest, build_int_cst (TREE_TYPE (dest), 0)); - else - gcc_unreachable (); - - access_size = int_size_in_bytes (TREE_TYPE (dest)); + tree type = build_nonstandard_integer_type (access_size + * BITS_PER_UNIT, 1); + dest = build2 (MEM_REF, type, dest, + build_int_cst (build_pointer_type (char_type_node), 0)); + break; } default: --- gcc/testsuite/c-c++-common/asan/pr79944.c (nonexistent) +++ gcc/testsuite/c-c++-common/asan/pr79944.c (revision 247685) @@ -0,0 +1,18 @@ +/* PR sanitizer/79944 */ +/* { dg-do run } */ + +struct S { int i; char p[1024]; }; + +int +main () +{ + struct S *p = (struct S *) __builtin_malloc (__builtin_offsetof (struct S, p) + 64); + p->i = 5; + asm volatile ("" : "+r" (p) : : "memory"); + __atomic_fetch_add ((int *) p, 5, __ATOMIC_RELAXED); + asm volatile ("" : "+r" (p) : : "memory"); + if (p->i != 10) + __builtin_abort (); + __builtin_free (p); + return 0; +} 2017-05-30 Jakub Jelinek <jakub@redhat.com> Backported from mainline 2017-03-10 Jakub Jelinek <jakub@redhat.com> PR c++/79896 * decl.c (finish_enum_value_list): If value is error_mark_node, don't copy it and change its type. * init.c (constant_value_1): Return error_mark_node if DECL_INITIAL of CONST_DECL is error_mark_node. * g++.dg/ext/int128-5.C: New test. --- gcc/cp/init.c (revision 247685) +++ gcc/cp/init.c (revision 247686) @@ -2077,7 +2077,8 @@ constant_value_1 (tree decl, bool strict init = DECL_INITIAL (decl); if (init == error_mark_node) { - if (DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl)) + if (TREE_CODE (decl) == CONST_DECL + || DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl)) /* Treat the error as a constant to avoid cascading errors on excessively recursive template instantiation (c++/9335). */ return init; --- gcc/cp/decl.c (revision 247685) +++ gcc/cp/decl.c (revision 247686) @@ -13497,9 +13497,12 @@ finish_enum_value_list (tree enumtype) input_location = saved_location; /* Do not clobber shared ints. */ - value = copy_node (value); + if (value != error_mark_node) + { + value = copy_node (value); - TREE_TYPE (value) = enumtype; + TREE_TYPE (value) = enumtype; + } DECL_INITIAL (decl) = value; } --- gcc/testsuite/g++.dg/ext/int128-5.C (nonexistent) +++ gcc/testsuite/g++.dg/ext/int128-5.C (revision 247686) @@ -0,0 +1,10 @@ +// PR c++/79896 +// { dg-do compile { target { ilp32 && { ! int128 } } } } +// { dg-options "" } + +enum E +{ + e1 = 0xffffffffffffffffULL, + e2, // { dg-error "overflow in enumeration values" } + e3 +} e = e3; 2017-05-30 Jakub Jelinek <jakub@redhat.com> Backported from mainline 2017-03-21 Jakub Jelinek <jakub@redhat.com> PR c/80097 * c-typeck.c (build_binary_op): Add EXCESS_PRECISION_EXPR only around optional COMPOUND_EXPR with ubsan instrumentation. * gcc.dg/ubsan/pr80097.c: New test. --- gcc/c/c-typeck.c (revision 247686) +++ gcc/c/c-typeck.c (revision 247687) @@ -11627,14 +11627,16 @@ build_binary_op (location_t location, en else if (TREE_CODE (ret) != INTEGER_CST && int_operands && !in_late_binary_op) ret = note_integer_operands (ret); - if (semantic_result_type) - ret = build1 (EXCESS_PRECISION_EXPR, semantic_result_type, ret); protected_set_expr_location (ret, location); if (instrument_expr != NULL) ret = fold_build2 (COMPOUND_EXPR, TREE_TYPE (ret), instrument_expr, ret); + if (semantic_result_type) + ret = build1_loc (location, EXCESS_PRECISION_EXPR, + semantic_result_type, ret); + return ret; } --- gcc/testsuite/gcc.dg/ubsan/pr80097.c (nonexistent) +++ gcc/testsuite/gcc.dg/ubsan/pr80097.c (revision 247687) @@ -0,0 +1,10 @@ +/* PR c/80097 */ +/* { dg-do compile } */ +/* { dg-options "-std=c89 -fsanitize=float-divide-by-zero" } */ + +int +foo (double a) +{ + int b = (1 / a >= 1); + return b; +} 2017-05-30 Jakub Jelinek <jakub@redhat.com> Backported from mainline 2017-03-22 Jakub Jelinek <jakub@redhat.com> PR c++/80129 * gimplify.c (gimplify_modify_expr_rhs) <case COND_EXPR>: Clear TREE_READONLY on result if writing it more than once. * g++.dg/torture/pr80129.C: New test. --- gcc/gimplify.c (revision 247687) +++ gcc/gimplify.c (revision 247688) @@ -4362,6 +4362,14 @@ gimplify_modify_expr_rhs (tree *expr_p, if (ret != GS_ERROR) ret = GS_OK; + /* If we are going to write RESULT more than once, clear + TREE_READONLY flag, otherwise we might incorrectly promote + the variable to static const and initialize it at compile + time in one of the branches. */ + if (VAR_P (result) + && TREE_TYPE (TREE_OPERAND (cond, 1)) != void_type_node + && TREE_TYPE (TREE_OPERAND (cond, 2)) != void_type_node) + TREE_READONLY (result) = 0; if (TREE_TYPE (TREE_OPERAND (cond, 1)) != void_type_node) TREE_OPERAND (cond, 1) = build2 (code, void_type_node, result, --- gcc/testsuite/g++.dg/torture/pr80129.C (nonexistent) +++ gcc/testsuite/g++.dg/torture/pr80129.C (revision 247688) @@ -0,0 +1,14 @@ +// PR c++/80129 +// { dg-do run } +// { dg-options "-std=c++11" } + +struct A { bool a; int b; }; + +int +main () +{ + bool c = false; + const A x = c ? A {true, 1} : A {false, 0}; + if (x.a) + __builtin_abort (); +} 2017-05-30 Jakub Jelinek <jakub@redhat.com> Backported from mainline 2017-03-22 Jakub Jelinek <jakub@redhat.com> PR c++/80141 * semantics.c (finish_omp_clause) <case OMP_CLAUSE_SIMDLEN, case OMP_CLAUSE_ALIGNED>: Call maybe_constant_value only when not processing_template_decl. * g++.dg/gomp/pr80141.C: New test. --- gcc/cp/semantics.c (revision 247688) +++ gcc/cp/semantics.c (revision 247689) @@ -5546,9 +5546,9 @@ finish_omp_clauses (tree clauses) else { t = mark_rvalue_use (t); - t = maybe_constant_value (t); if (!processing_template_decl) { + t = maybe_constant_value (t); if (TREE_CODE (t) != INTEGER_CST || tree_int_cst_sgn (t) != 1) { @@ -5726,9 +5726,9 @@ finish_omp_clauses (tree clauses) else { t = mark_rvalue_use (t); - t = maybe_constant_value (t); if (!processing_template_decl) { + t = maybe_constant_value (t); if (TREE_CODE (t) != INTEGER_CST || tree_int_cst_sgn (t) != 1) { --- gcc/testsuite/g++.dg/gomp/pr80141.C (nonexistent) +++ gcc/testsuite/g++.dg/gomp/pr80141.C (revision 247689) @@ -0,0 +1,8 @@ +// PR c++/80141 +// { dg-do compile } + +#pragma omp declare simd aligned (p : 2 && 2) +template<int> void foo (int *p); + +#pragma omp declare simd simdlen (2 && 2) +template<int> void bar (int *p); 2017-05-30 Jakub Jelinek <jakub@redhat.com> Backported from mainline 2017-03-24 Jakub Jelinek <jakub@redhat.com> PR rtl-optimization/80112 * loop-doloop.c (doloop_condition_get): Don't check condition if cmp isn't SET with IF_THEN_ELSE src. * gcc.dg/pr80112.c: New test. --- gcc/loop-doloop.c (revision 247689) +++ gcc/loop-doloop.c (revision 247690) @@ -152,10 +152,13 @@ doloop_condition_get (rtx doloop_pat) } else inc = PATTERN (prev_insn); - /* We expect the condition to be of the form (reg != 0) */ - cond = XEXP (SET_SRC (cmp), 0); - if (GET_CODE (cond) != NE || XEXP (cond, 1) != const0_rtx) - return 0; + if (GET_CODE (cmp) == SET && GET_CODE (SET_SRC (cmp)) == IF_THEN_ELSE) + { + /* We expect the condition to be of the form (reg != 0) */ + cond = XEXP (SET_SRC (cmp), 0); + if (GET_CODE (cond) != NE || XEXP (cond, 1) != const0_rtx) + return 0; + } } else { --- gcc/testsuite/gcc.dg/pr80112.c (nonexistent) +++ gcc/testsuite/gcc.dg/pr80112.c (revision 247690) @@ -0,0 +1,21 @@ +/* PR rtl-optimization/80112 */ +/* { dg-do compile } */ +/* { dg-options "-Os -fmodulo-sched" } */ + +void **a; + +void +foo (int c) +{ + void *d[] = {&&e, &&f}; + a = d; + switch (c) + { + f: + c = 9; + /* FALLTHRU */ + case 9: + goto *a++; + e:; + } +} 2017-05-30 Jakub Jelinek <jakub@redhat.com> Backported from mainline 2017-03-27 Jakub Jelinek <jakub@redhat.com> PR sanitizer/80168 * asan.c (instrument_derefs): Copy over last operand from original COMPONENT_REF to the new COMPONENT_REF with DECL_BIT_FIELD_REPRESENTATIVE. * ubsan.c (instrument_object_size): Likewise. * gcc.dg/asan/pr80168.c: New test. --- gcc/asan.c (revision 247690) +++ gcc/asan.c (revision 247691) @@ -1791,7 +1791,8 @@ instrument_derefs (gimple_stmt_iterator tree repr = DECL_BIT_FIELD_REPRESENTATIVE (TREE_OPERAND (t, 1)); instrument_derefs (iter, build3 (COMPONENT_REF, TREE_TYPE (repr), TREE_OPERAND (t, 0), repr, - NULL_TREE), location, is_store); + TREE_OPERAND (t, 2)), + location, is_store); return; } --- gcc/ubsan.c (revision 247690) +++ gcc/ubsan.c (revision 247691) @@ -1760,7 +1760,7 @@ instrument_object_size (gimple_stmt_iter { tree repr = DECL_BIT_FIELD_REPRESENTATIVE (TREE_OPERAND (t, 1)); t = build3 (COMPONENT_REF, TREE_TYPE (repr), TREE_OPERAND (t, 0), - repr, NULL_TREE); + repr, TREE_OPERAND (t, 2)); } break; case ARRAY_REF: --- gcc/testsuite/gcc.dg/asan/pr80168.c (nonexistent) +++ gcc/testsuite/gcc.dg/asan/pr80168.c (revision 247691) @@ -0,0 +1,12 @@ +/* PR sanitizer/80168 */ +/* { dg-do compile } */ + +int a; + +int +foo (void) +{ + struct S { int c[a]; int q : 8; int e : 4; } f; + f.e = 4; + return f.e; +} 2017-05-30 Jakub Jelinek <jakub@redhat.com> Backported from mainline 2017-03-30 Jakub Jelinek <jakub@redhat.com> * env.c (initialize_env): Initialize stacksize to 0. --- libgomp/env.c (revision 247691) +++ libgomp/env.c (revision 247692) @@ -1182,7 +1182,7 @@ handle_omp_display_env (unsigned long st static void __attribute__((constructor)) initialize_env (void) { - unsigned long thread_limit_var, stacksize; + unsigned long thread_limit_var, stacksize = 0; int wait_policy; /* Do a compile time check that mkomp_h.pl did good job. */ 2017-05-30 Jakub Jelinek <jakub@redhat.com> Backported from mainline 2017-03-31 Jakub Jelinek <jakub@redhat.com> PR debug/80025 * cselib.c (cselib_hasher::equal): Pass 0 to rtx_equal_for_cselib_1. (rtx_equal_for_cselib_1): Add depth argument. If depth is 128, don't look up VALUE locs and punt. Increment depth in recursive calls when walking VALUE locs. * gcc.dg/torture/pr80025.c: New test. --- gcc/cselib.c (revision 247692) +++ gcc/cselib.c (revision 247693) @@ -49,7 +49,7 @@ static void unchain_one_value (cselib_va static void unchain_one_elt_list (struct elt_list **); static void unchain_one_elt_loc_list (struct elt_loc_list **); static void remove_useless_values (void); -static int rtx_equal_for_cselib_1 (rtx, rtx, machine_mode); +static int rtx_equal_for_cselib_1 (rtx, rtx, machine_mode, int); static unsigned int cselib_hash_rtx (rtx, int, machine_mode); static cselib_val *new_cselib_val (unsigned int, machine_mode, rtx); static void add_mem_for_addr (cselib_val *, cselib_val *, rtx); @@ -125,7 +125,7 @@ cselib_hasher::equal (const cselib_val * /* We don't guarantee that distinct rtx's have different hash values, so we need to do a comparison. */ for (l = v->locs; l; l = l->next) - if (rtx_equal_for_cselib_1 (l->loc, x, memmode)) + if (rtx_equal_for_cselib_1 (l->loc, x, memmode, 0)) { promote_debug_loc (l); return true; @@ -794,7 +794,7 @@ cselib_reg_set_mode (const_rtx x) int rtx_equal_for_cselib_p (rtx x, rtx y) { - return rtx_equal_for_cselib_1 (x, y, VOIDmode); + return rtx_equal_for_cselib_1 (x, y, VOIDmode, 0); } /* If x is a PLUS or an autoinc operation, expand the operation, @@ -844,7 +844,7 @@ autoinc_split (rtx x, rtx *off, machine_ addresses, MEMMODE should be VOIDmode. */ static int -rtx_equal_for_cselib_1 (rtx x, rtx y, machine_mode memmode) +rtx_equal_for_cselib_1 (rtx x, rtx y, machine_mode memmode, int depth) { enum rtx_code code; const char *fmt; @@ -877,6 +877,9 @@ rtx_equal_for_cselib_1 (rtx x, rtx y, ma if (GET_CODE (y) == VALUE) return e == canonical_cselib_val (CSELIB_VAL_PTR (y)); + if (depth == 128) + return 0; + for (l = e->locs; l; l = l->next) { rtx t = l->loc; @@ -886,7 +889,7 @@ rtx_equal_for_cselib_1 (rtx x, rtx y, ma list. */ if (REG_P (t) || MEM_P (t) || GET_CODE (t) == VALUE) continue; - else if (rtx_equal_for_cselib_1 (t, y, memmode)) + else if (rtx_equal_for_cselib_1 (t, y, memmode, depth + 1)) return 1; } @@ -897,13 +900,16 @@ rtx_equal_for_cselib_1 (rtx x, rtx y, ma cselib_val *e = canonical_cselib_val (CSELIB_VAL_PTR (y)); struct elt_loc_list *l; + if (depth == 128) + return 0; + for (l = e->locs; l; l = l->next) { rtx t = l->loc; if (REG_P (t) || MEM_P (t) || GET_CODE (t) == VALUE) continue; - else if (rtx_equal_for_cselib_1 (x, t, memmode)) + else if (rtx_equal_for_cselib_1 (x, t, memmode, depth + 1)) return 1; } @@ -924,12 +930,12 @@ rtx_equal_for_cselib_1 (rtx x, rtx y, ma if (!xoff != !yoff) return 0; - if (xoff && !rtx_equal_for_cselib_1 (xoff, yoff, memmode)) + if (xoff && !rtx_equal_for_cselib_1 (xoff, yoff, memmode, depth)) return 0; /* Don't recurse if nothing changed. */ if (x != xorig || y != yorig) - return rtx_equal_for_cselib_1 (x, y, memmode); + return rtx_equal_for_cselib_1 (x, y, memmode, depth); return 0; } @@ -963,7 +969,8 @@ rtx_equal_for_cselib_1 (rtx x, rtx y, ma case MEM: /* We have to compare any autoinc operations in the addresses using this MEM's mode. */ - return rtx_equal_for_cselib_1 (XEXP (x, 0), XEXP (y, 0), GET_MODE (x)); + return rtx_equal_for_cselib_1 (XEXP (x, 0), XEXP (y, 0), GET_MODE (x), + depth); default: break; @@ -998,17 +1005,20 @@ rtx_equal_for_cselib_1 (rtx x, rtx y, ma /* And the corresponding elements must match. */ for (j = 0; j < XVECLEN (x, i); j++) if (! rtx_equal_for_cselib_1 (XVECEXP (x, i, j), - XVECEXP (y, i, j), memmode)) + XVECEXP (y, i, j), memmode, depth)) return 0; break; case 'e': if (i == 1 && targetm.commutative_p (x, UNKNOWN) - && rtx_equal_for_cselib_1 (XEXP (x, 1), XEXP (y, 0), memmode) - && rtx_equal_for_cselib_1 (XEXP (x, 0), XEXP (y, 1), memmode)) + && rtx_equal_for_cselib_1 (XEXP (x, 1), XEXP (y, 0), memmode, + depth) + && rtx_equal_for_cselib_1 (XEXP (x, 0), XEXP (y, 1), memmode, + depth)) return 1; - if (! rtx_equal_for_cselib_1 (XEXP (x, i), XEXP (y, i), memmode)) + if (! rtx_equal_for_cselib_1 (XEXP (x, i), XEXP (y, i), memmode, + depth)) return 0; break; --- gcc/testsuite/gcc.dg/torture/pr80025.c (nonexistent) +++ gcc/testsuite/gcc.dg/torture/pr80025.c (revision 247693) @@ -0,0 +1,24 @@ +/* PR debug/80025 */ +/* { dg-do compile } */ +/* { dg-options "-g -ftracer -w" } */ + +int a; +long int b, c; + +long int +foo (void) +{ +} + +void +bar (int x, short int y, unsigned short int z) +{ +} + +int +baz (void) +{ + a -= b; + b = !foo (); + bar (b ^= (c ^ 1) ? (c ^ 1) : foo (), (__INTPTR_TYPE__) &bar, a); +} 2017-05-30 Jakub Jelinek <jakub@redhat.com> Backported from mainline 2017-04-04 Jakub Jelinek <jakub@redhat.com> PR target/80286 * config/i386/i386.c (ix86_expand_args_builtin): If op has scalar int mode, convert_modes it to mode as unsigned, otherwise use lowpart_subreg to mode rather than SImode. * config/i386/sse.md (<mask_codefor>ashr<mode>3<mask_name>, ashr<mode>3, ashr<mode>3<mask_name>, <shift_insn><mode>3<mask_name>): Use DImode instead of SImode for the shift count operand. * config/i386/mmx.md (mmx_ashr<mode>3, mmx_<shift_insn><mode>3): Likewise. * gcc.target/i386/avx-pr80286.c: New test. * gcc.dg/pr80286.c: New test. --- gcc/config/i386/i386.c (revision 247695) +++ gcc/config/i386/i386.c (revision 247696) @@ -39374,10 +39374,17 @@ ix86_expand_args_builtin (const struct b { /* SIMD shift insns take either an 8-bit immediate or register as count. But builtin functions take int as - count. If count doesn't match, we put it in register. */ + count. If count doesn't match, we put it in register. + The instructions are using 64-bit count, if op is just + 32-bit, zero-extend it, as negative shift counts + are undefined behavior and zero-extension is more + efficient. */ if (!match) { - op = simplify_gen_subreg (SImode, op, GET_MODE (op), 0); + if (SCALAR_INT_MODE_P (GET_MODE (op))) + op = convert_modes (mode, GET_MODE (op), op, 1); + else + op = simplify_gen_subreg (mode, op, GET_MODE (op), 0); if (!insn_p->operand[i + 1].predicate (op, mode)) op = copy_to_reg (op); } --- gcc/config/i386/mmx.md (revision 247695) +++ gcc/config/i386/mmx.md (revision 247696) @@ -931,7 +931,7 @@ (define_insn "mmx_ashr<mode>3" [(set (match_operand:MMXMODE24 0 "register_operand" "=y") (ashiftrt:MMXMODE24 (match_operand:MMXMODE24 1 "register_operand" "0") - (match_operand:SI 2 "nonmemory_operand" "yN")))] + (match_operand:DI 2 "nonmemory_operand" "yN")))] "TARGET_MMX" "psra<mmxvecsize>\t{%2, %0|%0, %2}" [(set_attr "type" "mmxshft") @@ -945,7 +945,7 @@ (define_insn "mmx_<shift_insn><mode>3" [(set (match_operand:MMXMODE248 0 "register_operand" "=y") (any_lshift:MMXMODE248 (match_operand:MMXMODE248 1 "register_operand" "0") - (match_operand:SI 2 "nonmemory_operand" "yN")))] + (match_operand:DI 2 "nonmemory_operand" "yN")))] "TARGET_MMX" "p<vshift><mmxvecsize>\t{%2, %0|%0, %2}" [(set_attr "type" "mmxshft") --- gcc/config/i386/sse.md (revision 247695) +++ gcc/config/i386/sse.md (revision 247696) @@ -9936,7 +9936,7 @@ (define_insn "ashr<mode>3" [(set (match_operand:VI24_AVX2 0 "register_operand" "=x,x") (ashiftrt:VI24_AVX2 (match_operand:VI24_AVX2 1 "register_operand" "0,x") - (match_operand:SI 2 "nonmemory_operand" "xN,xN")))] + (match_operand:DI 2 "nonmemory_operand" "xN,xN")))] "TARGET_SSE2" "@ psra<ssemodesuffix>\t{%2, %0|%0, %2} @@ -9955,7 +9955,7 @@ (define_insn "<mask_codefor>ashr<mode>3< [(set (match_operand:VI24_AVX512BW_1 0 "register_operand" "=v,v") (ashiftrt:VI24_AVX512BW_1 (match_operand:VI24_AVX512BW_1 1 "nonimmediate_operand" "v,vm") - (match_operand:SI 2 "nonmemory_operand" "v,N")))] + (match_operand:DI 2 "nonmemory_operand" "v,N")))] "TARGET_AVX512VL" "vpsra<ssemodesuffix>\t{%2, %1, %0<mask_operand3>|%0<mask_operand3>, %1, %2}" [(set_attr "type" "sseishft") @@ -9983,7 +9983,7 @@ (define_insn "ashr<mode>3<mask_name>" [(set (match_operand:VI248_AVX512BW_AVX512VL 0 "register_operand" "=v,v") (ashiftrt:VI248_AVX512BW_AVX512VL (match_operand:VI248_AVX512BW_AVX512VL 1 "nonimmediate_operand" "v,vm") - (match_operand:SI 2 "nonmemory_operand" "v,N")))] + (match_operand:DI 2 "nonmemory_operand" "v,N")))] "TARGET_AVX512F" "vpsra<ssemodesuffix>\t{%2, %1, %0<mask_operand3>|%0<mask_operand3>, %1, %2}" [(set_attr "type" "sseishft") @@ -9997,7 +9997,7 @@ (define_insn "<shift_insn><mode>3<mask_n [(set (match_operand:VI2_AVX2_AVX512BW 0 "register_operand" "=x,v") (any_lshift:VI2_AVX2_AVX512BW (match_operand:VI2_AVX2_AVX512BW 1 "register_operand" "0,v") - (match_operand:SI 2 "nonmemory_operand" "xN,vN")))] + (match_operand:DI 2 "nonmemory_operand" "xN,vN")))] "TARGET_SSE2 && <mask_mode512bit_condition> && <mask_avx512bw_condition>" "@ p<vshift><ssemodesuffix>\t{%2, %0|%0, %2} @@ -10016,7 +10016,7 @@ (define_insn "<shift_insn><mode>3<mask_n [(set (match_operand:VI48_AVX2 0 "register_operand" "=x,v") (any_lshift:VI48_AVX2 (match_operand:VI48_AVX2 1 "register_operand" "0,v") - (match_operand:SI 2 "nonmemory_operand" "xN,vN")))] + (match_operand:DI 2 "nonmemory_operand" "xN,vN")))] "TARGET_SSE2 && <mask_mode512bit_condition>" "@ p<vshift><ssemodesuffix>\t{%2, %0|%0, %2} @@ -10035,7 +10035,7 @@ (define_insn "<shift_insn><mode>3<mask_n [(set (match_operand:VI48_512 0 "register_operand" "=v,v") (any_lshift:VI48_512 (match_operand:VI48_512 1 "nonimmediate_operand" "v,m") - (match_operand:SI 2 "nonmemory_operand" "vN,N")))] + (match_operand:DI 2 "nonmemory_operand" "vN,N")))] "TARGET_AVX512F && <mask_mode512bit_condition>" "vp<vshift><ssemodesuffix>\t{%2, %1, %0<mask_operand3>|%0<mask_operand3>, %1, %2}" [(set_attr "isa" "avx512f") --- gcc/testsuite/gcc.target/i386/avx-pr80286.c (nonexistent) +++ gcc/testsuite/gcc.target/i386/avx-pr80286.c (revision 247696) @@ -0,0 +1,26 @@ +/* PR target/80286 */ +/* { dg-do run { target avx } } */ +/* { dg-options "-O2 -mavx" } */ + +#include "avx-check.h" +#include <immintrin.h> + +__m256i m; + +__attribute__((noinline, noclone)) __m128i +foo (__m128i x) +{ + int s = _mm_cvtsi128_si32 (_mm256_castsi256_si128 (m)); + return _mm_srli_epi16 (x, s); +} + +static void +avx_test (void) +{ + __m128i a = (__m128i) (__v8hi) { 1 << 7, 2 << 8, 3 << 9, 4 << 10, 5 << 11, 6 << 12, 7 << 13, 8 << 12 }; + m = (__m256i) (__v8si) { 7, 8, 9, 10, 11, 12, 13, 14 }; + __m128i c = foo (a); + __m128i b = (__m128i) (__v8hi) { 1, 2 << 1, 3 << 2, 4 << 3, 5 << 4, 6 << 5, 7 << 6, 8 << 5 }; + if (__builtin_memcmp (&c, &b, sizeof (__m128i))) + __builtin_abort (); +} --- gcc/testsuite/gcc.dg/pr80286.c (nonexistent) +++ gcc/testsuite/gcc.dg/pr80286.c (revision 247696) @@ -0,0 +1,23 @@ +/* PR target/80286 */ +/* { dg-do run } */ +/* { dg-options "-O2 -Wno-psabi" } */ + +typedef int V __attribute__((vector_size (4 * sizeof (int)))); + +__attribute__((noinline, noclone)) V +foo (V x, V y) +{ + return x << y[0]; +} + +int +main () +{ + V x = { 1, 2, 3, 4 }; + V y = { 5, 6, 7, 8 }; + V z = foo (x, y); + V e = { 1 << 5, 2 << 5, 3 << 5, 4 << 5 }; + if (__builtin_memcmp (&z, &e, sizeof (V))) + __builtin_abort (); + return 0; +} 2017-05-30 Jakub Jelinek <jakub@redhat.com> Backported from mainline 2017-04-10 Jakub Jelinek <jakub@redhat.com> PR c++/80176 * tree.c (lvalue_kind): For COMPONENT_REF with BASELINK second operand, if it is a static member function, recurse on the BASELINK. * g++.dg/init/ref23.C: New test. --- gcc/cp/tree.c (revision 247697) +++ gcc/cp/tree.c (revision 247698) @@ -107,6 +107,17 @@ lvalue_kind (const_tree ref) return op1_lvalue_kind; case COMPONENT_REF: + if (BASELINK_P (TREE_OPERAND (ref, 1))) + { + tree fn = BASELINK_FUNCTIONS (TREE_OPERAND (ref, 1)); + + /* For static member function recurse on the BASELINK, we can get + here e.g. from reference_binding. If BASELINK_FUNCTIONS is + OVERLOAD, the overload is resolved first if possible through + resolve_address_of_overloaded_function. */ + if (TREE_CODE (fn) == FUNCTION_DECL && DECL_STATIC_FUNCTION_P (fn)) + return lvalue_kind (TREE_OPERAND (ref, 1)); + } op1_lvalue_kind = lvalue_kind (TREE_OPERAND (ref, 0)); /* Look at the member designator. */ if (!op1_lvalue_kind) --- gcc/testsuite/g++.dg/init/ref23.C (nonexistent) +++ gcc/testsuite/g++.dg/init/ref23.C (revision 247698) @@ -0,0 +1,15 @@ +// PR c++/80176 +// { dg-do compile } + +struct X { static void foo(); static void baz(int); static int baz(double); } x; +struct Y { void o(unsigned char); static void o(int); void o(double); } y; +void X::foo() {} +static void bar() {} +void (&r1)() = x.foo; +void (&r2)() = X::foo; +void (&r3)() = bar; +void (&r4)(int) = x.baz; +int (&r5)(double) = x.baz; +void (&r6)(int) = X::baz; +int (&r7)(double) = X::baz; +void (&r8)(int) = y.o; 2017-05-30 Jakub Jelinek <jakub@redhat.com> Backported from mainline 2017-04-11 Jakub Jelinek <jakub@redhat.com> PR c++/80363 * error.c (dump_expr): Handle VEC_COND_EXPR like COND_EXPR. * g++.dg/ext/pr80363.C: New test. --- gcc/cp/error.c (revision 247698) +++ gcc/cp/error.c (revision 247699) @@ -2029,6 +2029,7 @@ dump_expr (cxx_pretty_printer *pp, tree break; case COND_EXPR: + case VEC_COND_EXPR: pp_cxx_left_paren (pp); dump_expr (pp, TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS); pp_string (pp, " ? "); --- gcc/testsuite/g++.dg/ext/pr80363.C (nonexistent) +++ gcc/testsuite/g++.dg/ext/pr80363.C (revision 247699) @@ -0,0 +1,12 @@ +// PR c++/80363 +// { dg-do compile } + +typedef int V __attribute__((vector_size (16))); + +int +foo (V *a, V *b) +{ + if (*a < *b) // { dg-error "could not convert\[^#]*from" } + return 1; + return 0; +} 2017-05-30 Jakub Jelinek <jakub@redhat.com> Backported from mainline 2017-04-11 Jakub Jelinek <jakub@redhat.com> PR libgomp/80394 * omp-low.c (scan_omp_task): Don't optimize away empty tasks if they have any depend clauses. * testsuite/libgomp.c/pr80394.c: New test. --- gcc/omp-low.c (revision 247699) +++ gcc/omp-low.c (revision 247700) @@ -2711,9 +2711,11 @@ scan_omp_task (gimple_stmt_iterator *gsi tree name, t; gomp_task *stmt = as_a <gomp_task *> (gsi_stmt (*gsi)); - /* Ignore task directives with empty bodies. */ + /* Ignore task directives with empty bodies, unless they have depend + clause. */ if (optimize > 0 - && empty_body_p (gimple_omp_body (stmt))) + && empty_body_p (gimple_omp_body (stmt)) + && !find_omp_clause (gimple_omp_task_clauses (stmt), OMP_CLAUSE_DEPEND)) { gsi_replace (gsi, gimple_build_nop (), false); return; --- libgomp/testsuite/libgomp.c/pr80394.c (nonexistent) +++ libgomp/testsuite/libgomp.c/pr80394.c (revision 247700) @@ -0,0 +1,22 @@ +/* PR libgomp/80394 */ + +int +main () +{ + int x = 0; + #pragma omp parallel shared(x) + #pragma omp single + { + #pragma omp task depend(inout: x) + { + for (int i = 0; i < 100000; i++) + asm volatile ("" : : : "memory"); + x += 5; + } + #pragma omp task if (0) depend(inout: x) + ; + if (x != 5) + __builtin_abort (); + } + return 0; +} 2017-05-30 Jakub Jelinek <jakub@redhat.com> Backported from mainline 2017-04-11 Jakub Jelinek <jakub@redhat.com> PR rtl-optimization/80385 * simplify-rtx.c (simplify_unary_operation_1): Don't transform (not (neg X)) into (plus X -1) for complex or non-integral modes. * g++.dg/opt/pr80385.C: New test. --- gcc/simplify-rtx.c (revision 247700) +++ gcc/simplify-rtx.c (revision 247701) @@ -900,8 +900,10 @@ simplify_unary_operation_1 (enum rtx_cod && XEXP (op, 1) == constm1_rtx) return simplify_gen_unary (NEG, mode, XEXP (op, 0), mode); - /* Similarly, (not (neg X)) is (plus X -1). */ - if (GET_CODE (op) == NEG) + /* Similarly, (not (neg X)) is (plus X -1). Only do this for + modes that have CONSTM1_RTX, i.e. MODE_INT, MODE_PARTIAL_INT + and MODE_VECTOR_INT. */ + if (GET_CODE (op) == NEG && CONSTM1_RTX (mode)) return simplify_gen_binary (PLUS, mode, XEXP (op, 0), CONSTM1_RTX (mode)); --- gcc/testsuite/g++.dg/opt/pr80385.C (nonexistent) +++ gcc/testsuite/g++.dg/opt/pr80385.C (revision 247701) @@ -0,0 +1,14 @@ +// PR rtl-optimization/80385 +// { dg-do compile { target { i?86-*-* x86_64-*-* } } } +// { dg-options "-Ofast -msse2" } + +#include <x86intrin.h> + +__m128 a, e; +struct A { __m128 b; A (); A (__m128 x) : b(x) {} }; +A operator+ (A, A); +A operator- (A) { __m128 c = -a; return c; } +A foo (A x) { __m128 d = x.b; return _mm_andnot_ps (d, e); } +struct B { A n[1]; }; +void bar (B x) { A f = foo (x.n[0]); A g = f + A (); } +void baz () { B h; B i; A j; i.n[0] = -j; h = i; B k = h; bar (k); } 2017-05-30 Jakub Jelinek <jakub@redhat.com> Backported from mainline 2017-04-25 Jakub Jelinek <jakub@redhat.com> * Makefile.in (s-options): Invoke opt-gather.awk with LC_ALL=C in the environment. --- gcc/Makefile.in (revision 247703) +++ gcc/Makefile.in (revision 247704) @@ -2048,6 +2048,7 @@ s-specs : Makefile optionlist: s-options ; @true s-options: $(ALL_OPT_FILES) Makefile $(srcdir)/opt-gather.awk + LC_ALL=C ; export LC_ALL ; \ $(AWK) -f $(srcdir)/opt-gather.awk $(ALL_OPT_FILES) > tmp-optionlist $(SHELL) $(srcdir)/../move-if-change tmp-optionlist optionlist $(STAMP) s-options