mirror of
https://github.com/RPCS3/llvm-mirror.git
synced 2024-11-22 02:33:06 +01:00
aba875a2e8
This patch updates ValueLattice to distinguish between ranges that are
guaranteed to not include undef and ranges that may include undef.
A constant range guaranteed to not contain undef can be used to simplify
instructions to arbitrary values. A constant range that may contain
undef can only be used to simplify to a constant. If the value can be
undef, it might take a value outside the range. For example, consider
the snipped below
define i32 @f(i32 %a, i1 %c) {
br i1 %c, label %true, label %false
true:
%a.255 = and i32 %a, 255
br label %exit
false:
br label %exit
exit:
%p = phi i32 [ %a.255, %true ], [ undef, %false ]
%f.1 = icmp eq i32 %p, 300
call void @use(i1 %f.1)
%res = and i32 %p, 255
ret i32 %res
}
In the exit block, %p would be a constant range [0, 256) including undef as
%p could be undef. We can use the range information to replace %f.1 with
false because we remove the compare, effectively forcing the use of the
constant to be != 300. We cannot replace %res with %p however, because
if %a would be undef %cond may be true but the second use might not be
< 256.
Currently LazyValueInfo uses the new behavior just when simplifying AND
instructions and does not distinguish between constant ranges with and
without undef otherwise. I think we should address the remaining issues
in LVI incrementally.
Reviewers: efriedma, reames, aqjune, jdoerfert, sstefan1
Reviewed By: efriedma
Differential Revision: https://reviews.llvm.org/D76931
34 lines
1.2 KiB
C++
34 lines
1.2 KiB
C++
//===- ValueLattice.cpp - Value constraint analysis -------------*- C++ -*-===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "llvm/Analysis/ValueLattice.h"
|
|
|
|
namespace llvm {
|
|
raw_ostream &operator<<(raw_ostream &OS, const ValueLatticeElement &Val) {
|
|
if (Val.isUnknown())
|
|
return OS << "unknown";
|
|
if (Val.isUndef())
|
|
return OS << "undef";
|
|
if (Val.isOverdefined())
|
|
return OS << "overdefined";
|
|
|
|
if (Val.isNotConstant())
|
|
return OS << "notconstant<" << *Val.getNotConstant() << ">";
|
|
|
|
if (Val.isConstantRangeIncludingUndef())
|
|
return OS << "constantrange incl. undef <"
|
|
<< Val.getConstantRange(true).getLower() << ", "
|
|
<< Val.getConstantRange(true).getUpper() << ">";
|
|
|
|
if (Val.isConstantRange())
|
|
return OS << "constantrange<" << Val.getConstantRange().getLower() << ", "
|
|
<< Val.getConstantRange().getUpper() << ">";
|
|
return OS << "constant<" << *Val.getConstant() << ">";
|
|
}
|
|
} // end namespace llvm
|