From patchwork Thu Dec 31 07:02:37 2020
Content-Type: text/plain; charset="utf-8"
MIME-Version: 1.0
Content-Transfer-Encoding: 7bit
X-Patchwork-Submitter: "Kewen.Lin" <linkw@linux.ibm.com>
X-Patchwork-Id: 1421510
Return-Path: <gcc-patches-bounces@gcc.gnu.org>
X-Original-To: incoming@patchwork.ozlabs.org
Delivered-To: patchwork-incoming@bilbo.ozlabs.org
Authentication-Results: ozlabs.org;
 spf=pass (sender SPF authorized) smtp.mailfrom=gcc.gnu.org
 (client-ip=8.43.85.97; helo=sourceware.org;
 envelope-from=gcc-patches-bounces@gcc.gnu.org; receiver=<UNKNOWN>)
Authentication-Results: ozlabs.org;
 dmarc=pass (p=none dis=none) header.from=gcc.gnu.org
Authentication-Results: ozlabs.org;
	dkim=pass (1024-bit key;
 unprotected) header.d=gcc.gnu.org header.i=@gcc.gnu.org header.a=rsa-sha256
 header.s=default header.b=SIUL95Ey;
	dkim-atps=neutral
Received: from sourceware.org (server2.sourceware.org [8.43.85.97])
	(using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits)
	 key-exchange X25519 server-signature RSA-PSS (4096 bits) server-digest
 SHA256)
	(No client certificate requested)
	by ozlabs.org (Postfix) with ESMTPS id 4D5zd30qscz9sRf
	for <incoming@patchwork.ozlabs.org>; Thu, 31 Dec 2020 18:03:00 +1100 (AEDT)
Received: from server2.sourceware.org (localhost [IPv6:::1])
	by sourceware.org (Postfix) with ESMTP id 0B20C3857808;
	Thu, 31 Dec 2020 07:02:57 +0000 (GMT)
DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org 0B20C3857808
DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gcc.gnu.org;
	s=default; t=1609398177;
	bh=Z07xovbsf5RvQYsTexTXMVX/DHq4rauNwhKQFMb08Ks=;
	h=To:Subject:Date:List-Id:List-Unsubscribe:List-Archive:List-Post:
	 List-Help:List-Subscribe:From:Reply-To:Cc:From;
	b=SIUL95EyfMw+qPdwxHdoL/dcgR2JlukVK0aPUzV0PbjSklT7vUC+1AyKYH20axRsH
	 yWBu7mxBEcEEwS/4b0a7HoNTay/RaXUpmpYdv+GraDs2egV+Vn9N5rTi/zdnVDOzSo
	 6i7CqRLfx79X6J8AI9xc0rFBr4ivFjrDpvN0I4wY=
X-Original-To: gcc-patches@gcc.gnu.org
Delivered-To: gcc-patches@gcc.gnu.org
Received: from mx0a-001b2d01.pphosted.com (mx0a-001b2d01.pphosted.com
 [148.163.156.1])
 by sourceware.org (Postfix) with ESMTPS id 422E8385802B
 for <gcc-patches@gcc.gnu.org>; Thu, 31 Dec 2020 07:02:54 +0000 (GMT)
DMARC-Filter: OpenDMARC Filter v1.3.2 sourceware.org 422E8385802B
Received: from pps.filterd (m0098410.ppops.net [127.0.0.1])
 by mx0a-001b2d01.pphosted.com (8.16.0.42/8.16.0.42) with SMTP id
 0BV72hQd093633; Thu, 31 Dec 2020 02:02:53 -0500
Received: from pps.reinject (localhost [127.0.0.1])
 by mx0a-001b2d01.pphosted.com with ESMTP id 35s9r106d3-1
 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT);
 Thu, 31 Dec 2020 02:02:52 -0500
Received: from m0098410.ppops.net (m0098410.ppops.net [127.0.0.1])
 by pps.reinject (8.16.0.36/8.16.0.36) with SMTP id 0BV72q20094235;
 Thu, 31 Dec 2020 02:02:52 -0500
Received: from ppma03fra.de.ibm.com (6b.4a.5195.ip4.static.sl-reverse.com
 [149.81.74.107])
 by mx0a-001b2d01.pphosted.com with ESMTP id 35s9r1069x-1
 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT);
 Thu, 31 Dec 2020 02:02:52 -0500
Received: from pps.filterd (ppma03fra.de.ibm.com [127.0.0.1])
 by ppma03fra.de.ibm.com (8.16.0.42/8.16.0.42) with SMTP id 0BV6rVtR017547;
 Thu, 31 Dec 2020 07:02:43 GMT
Received: from b06cxnps3074.portsmouth.uk.ibm.com
 (d06relay09.portsmouth.uk.ibm.com [9.149.109.194])
 by ppma03fra.de.ibm.com with ESMTP id 35nvt8ad91-1
 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT);
 Thu, 31 Dec 2020 07:02:43 +0000
Received: from d06av26.portsmouth.uk.ibm.com (d06av26.portsmouth.uk.ibm.com
 [9.149.105.62])
 by b06cxnps3074.portsmouth.uk.ibm.com (8.14.9/8.14.9/NCO v10.0) with ESMTP id
 0BV72ej723921016
 (version=TLSv1/SSLv3 cipher=DHE-RSA-AES256-GCM-SHA384 bits=256 verify=OK);
 Thu, 31 Dec 2020 07:02:40 GMT
Received: from d06av26.portsmouth.uk.ibm.com (unknown [127.0.0.1])
 by IMSVA (Postfix) with ESMTP id 9BFAAAE05A;
 Thu, 31 Dec 2020 07:02:40 +0000 (GMT)
Received: from d06av26.portsmouth.uk.ibm.com (unknown [127.0.0.1])
 by IMSVA (Postfix) with ESMTP id 1224CAE056;
 Thu, 31 Dec 2020 07:02:39 +0000 (GMT)
Received: from KewenLins-MacBook-Pro.local (unknown [9.200.37.107])
 by d06av26.portsmouth.uk.ibm.com (Postfix) with ESMTP;
 Thu, 31 Dec 2020 07:02:38 +0000 (GMT)
To: GCC Patches <gcc-patches@gcc.gnu.org>
Subject: [PATCH] sccvn: Consider def BB in rpo_vn_valueize [PR98464]
Message-ID: <1102d644-d81b-72d8-03e1-c21d38eb60e3@linux.ibm.com>
Date: Thu, 31 Dec 2020 15:02:37 +0800
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.16; rv:78.0)
 Gecko/20100101 Thunderbird/78.5.0
MIME-Version: 1.0
Content-Language: en-US
X-TM-AS-GCONF: 00
X-Proofpoint-Virus-Version: vendor=fsecure engine=2.50.10434:6.0.343, 18.0.737
 definitions=2020-12-31_02:2020-12-30,
 2020-12-31 signatures=0
X-Proofpoint-Spam-Details: rule=outbound_notspam policy=outbound score=0
 lowpriorityscore=0
 malwarescore=0 suspectscore=0 adultscore=0 phishscore=0 impostorscore=0
 priorityscore=1501 bulkscore=0 mlxscore=0 clxscore=1015 mlxlogscore=999
 spamscore=0 classifier=spam adjust=0 reason=mlx scancount=1
 engine=8.12.0-2009150000 definitions=main-2012310036
X-Spam-Status: No, score=-12.0 required=5.0 tests=BAYES_00, DKIM_SIGNED,
 DKIM_VALID, DKIM_VALID_EF, GIT_PATCH_0, RCVD_IN_DNSWL_LOW, RCVD_IN_MSPIKE_H2,
 SPF_HELO_NONE, SPF_PASS, TXREP autolearn=ham autolearn_force=no version=3.4.2
X-Spam-Checker-Version: SpamAssassin 3.4.2 (2018-09-13) on
 server2.sourceware.org
X-BeenThere: gcc-patches@gcc.gnu.org
X-Mailman-Version: 2.1.29
Precedence: list
List-Id: Gcc-patches mailing list <gcc-patches.gcc.gnu.org>
List-Unsubscribe: <https://gcc.gnu.org/mailman/options/gcc-patches>,
 <mailto:gcc-patches-request@gcc.gnu.org?subject=unsubscribe>
List-Archive: <https://gcc.gnu.org/pipermail/gcc-patches/>
List-Post: <mailto:gcc-patches@gcc.gnu.org>
List-Help: <mailto:gcc-patches-request@gcc.gnu.org?subject=help>
List-Subscribe: <https://gcc.gnu.org/mailman/listinfo/gcc-patches>,
 <mailto:gcc-patches-request@gcc.gnu.org?subject=subscribe>
X-Patchwork-Original-From: "Kewen.Lin via Gcc-patches"
 <gcc-patches@gcc.gnu.org>
From: "Kewen.Lin" <linkw@linux.ibm.com>
Reply-To: "Kewen.Lin" <linkw@linux.ibm.com>
Cc: Bill Schmidt <wschmidt@linux.ibm.com>,
 Segher Boessenkool <segher@kernel.crashing.org>
Errors-To: gcc-patches-bounces@gcc.gnu.org
Sender: "Gcc-patches" <gcc-patches-bounces@gcc.gnu.org>

Hi,

As PR98464 shows, this patch is to make rpo_vn_valueize
consider the definition basic block of name, to sync
with what we do in function eliminate_stmt.

Bootstrapped/regtested on powerpc64le-linux-gnu P9.

Full SPEC2017 build/run passed on P9.

BR,
Kewen

gcc/ChangeLog:

	PR tree-optimization/98464
	* tree-ssa-sccvn.c (rpo_vn_valueize): Use the def basic block
	to keep consistent with eliminate_stmt.

gcc/testsuite/ChangeLog:

	PR tree-optimization/98464
	* g++.dg/tree-ssa/pr98464.C: New test.

diff --git a/gcc/testsuite/g++.dg/tree-ssa/pr98464.C b/gcc/testsuite/g++.dg/tree-ssa/pr98464.C
new file mode 100644
index 00000000000..1cbc4a8ef8d
--- /dev/null
+++ b/gcc/testsuite/g++.dg/tree-ssa/pr98464.C
@@ -0,0 +1,186 @@
+/* { dg-do compile { target c++11 } } */
+/* { dg-options "-O3 -fno-tree-dce" } */
+
+/* This case is to check there is no ICE.  */
+
+template <typename, typename, template <typename> class _Op, typename... _Args>
+struct __detector {
+  using type = _Op<_Args...>;
+};
+
+template <typename _Default, template <typename> class _Op, typename... _Args>
+using __detected_or = __detector<_Default, void, _Op, _Args...>;
+template <typename _Default, template <typename> class _Op, typename... _Args>
+using __detected_or_t = typename __detected_or<_Default, _Op, _Args...>::type;
+template <typename, typename> struct __replace_first_arg;
+template <template <typename> class _Template, typename _Up, typename _Tp,
+          typename... _Types>
+struct __replace_first_arg<_Template<_Tp, _Types...>, _Up> {
+  using type = _Template<_Up>;
+};
+
+template <class> class min_pointer;
+class MoveOnly;
+struct pointer_traits {
+  template <typename _Up>
+  using rebind = typename __replace_first_arg<min_pointer<int>, _Up>::type;
+};
+
+template <typename _Iterator> class __normal_iterator {
+public:
+  __normal_iterator(_Iterator);
+};
+
+struct __allocator_traits_base {
+  template <typename _Tp> using __pointer = typename _Tp::pointer;
+};
+
+template <typename _Alloc> struct allocator_traits : __allocator_traits_base {
+  typedef typename _Alloc::value_type value_type;
+  using pointer = __detected_or_t<value_type, __pointer, _Alloc>;
+  template <typename _Tp> struct _Ptr {
+    using type = pointer_traits::rebind<_Tp>;
+  };
+  using const_pointer = typename _Ptr<value_type>::type;
+  using size_type = int;
+  static pointer allocate(_Alloc __a, size_type __n) {
+    return __a.allocate(__n);
+  }
+};
+
+template <typename _ForwardIterator, typename _Allocator>
+void _Destroy(_ForwardIterator __first, _ForwardIterator __last, _Allocator) {
+  for (; __first != __last; ++__first)
+    ;
+}
+
+template <typename _InputIterator, typename _ForwardIterator,
+          typename _Allocator>
+_ForwardIterator __uninitialized_copy_a(_InputIterator, _ForwardIterator,
+                                        _Allocator);
+
+template <typename _InputIterator, typename _ForwardIterator,
+          typename _Allocator>
+_ForwardIterator __uninitialized_move_if_noexcept_a(_InputIterator __last,
+                                                    _ForwardIterator __result,
+                                                    _Allocator __alloc) {
+  return __uninitialized_copy_a(__last, __result, __alloc);
+}
+
+template <typename _ForwardIterator, typename _Size, typename _Allocator>
+_ForwardIterator __uninitialized_default_n_a(_ForwardIterator __first,
+                                             _Size __n, _Allocator) {
+  for (; __n; --__n, ++__first)
+    ;
+  return __first;
+}
+
+template <typename _Alloc> struct _Vector_base {
+  typedef _Alloc _Tp_alloc_type;
+  typedef typename _Tp_alloc_type ::pointer pointer;
+  struct _Vector_impl_data {
+    pointer _M_start;
+    pointer _M_finish;
+    pointer _M_end_of_storage;
+  };
+  struct _Vector_impl : _Tp_alloc_type, _Vector_impl_data {
+    _Vector_impl(_Tp_alloc_type) {}
+  };
+  _Vector_base(long __n, _Alloc __a) : _M_impl(__a) {
+    _M_impl._M_end_of_storage = _M_impl._M_start + __n;
+  }
+  _Vector_impl _M_impl;
+  pointer _M_allocate(long __n) {
+    return __n ? allocator_traits<_Tp_alloc_type>::allocate(_M_impl, __n)
+               : pointer();
+  }
+};
+
+template <typename, typename _Alloc> class vector : _Vector_base<_Alloc> {
+public:
+  typedef typename _Alloc::pointer pointer;
+  typedef __normal_iterator<typename allocator_traits<_Alloc>::const_pointer>
+      const_iterator;
+  typedef _Alloc allocator_type;
+  vector(long __n, allocator_type __a = allocator_type())
+      : _Vector_base<_Alloc>(__n, __a) {
+    this->_M_impl._M_finish =
+        __uninitialized_default_n_a(this->_M_impl._M_start, __n, 0);
+  }
+  ~vector() { _Destroy(this->_M_impl._M_start, this->_M_impl._M_finish, 0); }
+  const_iterator cbegin() { return this->_M_impl._M_start; }
+  typename _Alloc::value_type operator[](long) {
+    return *this->_M_impl._M_start;
+  }
+  void insert(const_iterator, MoveOnly &&) {
+    if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage)
+      ;
+    else
+      _M_realloc_insert();
+  }
+  template <typename...> void _M_realloc_insert();
+};
+
+template <typename _Tp, typename _Alloc>
+template <typename...>
+void vector<_Tp, _Alloc>::_M_realloc_insert() {
+  long __trans_tmp_6 = this->_M_impl._M_finish - this->_M_impl._M_start;
+  pointer __old_start = this->_M_impl._M_start;
+  pointer __old_finish = this->_M_impl._M_finish;
+  pointer __new_start(this->_M_allocate(__trans_tmp_6));
+  pointer __new_finish =
+      __uninitialized_move_if_noexcept_a(__old_finish, __new_finish, 0);
+  _Destroy(__old_start, __old_finish, 0);
+  this->_M_impl._M_start = __new_start;
+  this->_M_impl._M_finish = __new_finish;
+}
+
+class MoveOnly {
+  int data_;
+
+public:
+  bool operator==(MoveOnly) { return data_; }
+};
+
+void __assert_fail();
+
+template <class T> class min_pointer {
+  T *ptr_;
+  min_pointer(T *p) : ptr_(p) {}
+
+public:
+  min_pointer() = default;
+  T operator*() { return *ptr_; }
+  void operator++() { ++ptr_; }
+  void operator+=(long n) { ptr_ += n; }
+  min_pointer operator+(long n) {
+    min_pointer tmp(*this);
+    tmp += n;
+    return tmp;
+  }
+  friend long operator-(min_pointer x, min_pointer y) {
+    return x.ptr_ - y.ptr_;
+  }
+  friend bool operator==(min_pointer x, min_pointer y) {
+    return x.ptr_ == y.ptr_;
+  }
+  friend bool operator!=(min_pointer x, min_pointer y) { return !(x == y); }
+  friend class min_allocator;
+};
+
+class min_allocator {
+public:
+  typedef MoveOnly value_type;
+  typedef min_pointer<MoveOnly> pointer;
+  pointer allocate(long) {
+    return static_cast<MoveOnly *>(operator new(sizeof(MoveOnly)));
+  }
+};
+
+int main() {
+  vector<int, min_allocator> v(100);
+  v.insert(v.cbegin(), MoveOnly());
+  int j = 0;
+  for (; j < 10; ++j)
+    v[j] == MoveOnly() ? void() : __assert_fail();
+}
diff --git a/gcc/tree-ssa-sccvn.c b/gcc/tree-ssa-sccvn.c
index 81990fcbd34..eb900642dde 100644
--- a/gcc/tree-ssa-sccvn.c
+++ b/gcc/tree-ssa-sccvn.c
@@ -6901,9 +6901,16 @@ rpo_vn_valueize (tree name)
 	    {
 	      if (TREE_CODE (tem) != SSA_NAME)
 		return tem;
+	      basic_block bb = vn_context_bb;
+	      if (!SSA_NAME_IS_DEFAULT_DEF (name))
+		{
+		  basic_block def_bb = gimple_bb (SSA_NAME_DEF_STMT (name));
+		  if (def_bb)
+		    bb = def_bb;
+		}
 	      /* For all values we only valueize to an available leader
 		 which means we can use SSA name info without restriction.  */
-	      tem = rpo_avail->eliminate_avail (vn_context_bb, tem);
+	      tem = rpo_avail->eliminate_avail (bb, tem);
 	      if (tem)
 		return tem;
 	    }