mirror/gcc
2
0
Fork 0
mirror of git://gcc.gnu.org/git/gcc.git synced 2025-04-04 00:01:25 +08:00
Code Issues Packages Projects Releases Wiki Activity

tree-optimization/107919 - uninit diagnostic predicate simplification

Browse Source 
We fail to simplify

        ((_145 != 0B) AND (_531 == 2) AND (_109 == 0))
        OR ((NOT (_145 != 0B)) AND (_531 == 2) AND (_109 == 0))
        OR ((NOT (_531 == 2)) AND (_109 == 0))

because the existing simplification of !A && B || A && B is implemented
too simplistic.  The following re-implements that which fixes the
bogus uninit diagnostic when using -O1 but not yet at -O2.

	PR tree-optimization/107919
	* gimple-predicate-analysis.cc (predicate::simplify_2):
	Handle predicates of arbitrary length.

	* g++.dg/warn/Wuninitialized-pr107919-1.C: New testcase.
This commit is contained in:
Richard Biener 2022-11-30 10:55:03 +01:00
parent 7716ee1e90
commit 9500877d05
2 changed files with 43 additions and 43 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

71
gcc/gimple-predicate-analysis.cc
View File

@ -1257,64 +1257,49 @@ predicate::simplify_2 ()
/* (X AND Y) OR (!X AND Y) is equivalent to Y.
(X AND Y) OR (X AND !Y) is equivalent to X. */
unsigned n = m_preds.length ();
for (unsigned i = 0; i < n; i++)
for (unsigned i = 0; i < m_preds.length (); i++)
{
pred_chain &a_chain = m_preds[i];
if (a_chain.length () != 2)
continue;
/* Create copies since the chain may be released below before
the copy is added to the other chain. */
const pred_info x = a_chain[0];
const pred_info y = a_chain[1];
for (unsigned j = 0; j < n; j++)
for (unsigned j = i + 1; j < m_preds.length (); j++)
{
if (j == i)
continue;
pred_chain &b_chain = m_preds[j];
if (b_chain.length () != 2)
if (b_chain.length () != a_chain.length ())
continue;
const pred_info &x2 = b_chain[0];
const pred_info &y2 = b_chain[1];
if (pred_equal_p (x, x2) && pred_neg_p (y, y2))
unsigned neg_idx = -1U;
for (unsigned k = 0; k < a_chain.length (); ++k)
{
/* Kill a_chain. */
b_chain.release ();
a_chain.release ();
b_chain.safe_push (x);
simplified = true;
break;
if (pred_equal_p (a_chain[k], b_chain[k]))
continue;
if (neg_idx != -1U)
{
neg_idx = -1U;
break;
}
if (pred_neg_p (a_chain[k], b_chain[k]))
neg_idx = k;
else
break;
}
if (pred_neg_p (x, x2) && pred_equal_p (y, y2))
/* If we found equal chains with one negated predicate
simplify. */
if (neg_idx != -1U)
{
/* Kill a_chain. */
a_chain.release ();
b_chain.release ();
b_chain.safe_push (y);
a_chain.ordered_remove (neg_idx);
m_preds.ordered_remove (j);
simplified = true;
if (a_chain.is_empty ())
{
/* A && !A simplifies to true, wipe the whole predicate. */
for (unsigned k = 0; k < m_preds.length (); ++k)
m_preds[k].release ();
m_preds.truncate (0);
}
break;
}
}
}
/* Now clean up the chain. */
if (simplified)
{
pred_chain_union s_preds = vNULL;
for (unsigned i = 0; i < n; i++)
{
if (m_preds[i].is_empty ())
continue;
s_preds.safe_push (m_preds[i]);
}
m_preds.release ();
m_preds = s_preds;
s_preds = vNULL;
}
return simplified;
}

15
gcc/testsuite/g++.dg/warn/Wuninitialized-pr107919-1.C Normal file
View File

@ -0,0 +1,15 @@
// { dg-do compile }
// { dg-require-effective-target c++17 }
// { dg-options "-O -Wuninitialized" }
#include <memory>
#include <variant>
using Event = std::variant<std::variant<std::tuple<std::unique_ptr<int>>>, int, char>;
void do_something(void* storage)
{
Event event {};
auto& swappedValue = *reinterpret_cast<Event*>(storage);
std::swap(event, swappedValue);
}