92 lines
3.5 KiB
C++
92 lines
3.5 KiB
C++
//===- CmpPredicate.h - CmpInst Predicate with samesign information -------===//
|
|
//
|
|
// 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
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// A CmpInst::Predicate with any samesign information (applicable to ICmpInst).
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef LLVM_IR_CMPPREDICATE_H
|
|
#define LLVM_IR_CMPPREDICATE_H
|
|
|
|
#include "llvm/IR/InstrTypes.h"
|
|
#include "llvm/Support/Compiler.h"
|
|
|
|
namespace llvm {
|
|
/// An abstraction over a floating-point predicate, and a pack of an integer
|
|
/// predicate with samesign information. Some functions in ICmpInst construct
|
|
/// and return this type in place of a Predicate.
|
|
class CmpPredicate {
|
|
CmpInst::Predicate Pred;
|
|
bool HasSameSign;
|
|
|
|
public:
|
|
/// Default constructor.
|
|
CmpPredicate() : Pred(CmpInst::BAD_ICMP_PREDICATE), HasSameSign(false) {}
|
|
|
|
/// Constructed implictly with a either Predicate and samesign information, or
|
|
/// just a Predicate, dropping samesign information.
|
|
CmpPredicate(CmpInst::Predicate Pred, bool HasSameSign = false)
|
|
: Pred(Pred), HasSameSign(HasSameSign) {
|
|
assert(!HasSameSign || CmpInst::isIntPredicate(Pred));
|
|
}
|
|
|
|
/// Implictly converts to the underlying Predicate, dropping samesign
|
|
/// information.
|
|
operator CmpInst::Predicate() const { return Pred; }
|
|
|
|
/// Query samesign information, for optimizations.
|
|
bool hasSameSign() const { return HasSameSign; }
|
|
|
|
/// Drops samesign information. This is used when the samesign information
|
|
/// should be dropped explicitly.
|
|
CmpInst::Predicate dropSameSign() const { return Pred; }
|
|
|
|
/// Compares two CmpPredicates taking samesign into account and returns the
|
|
/// canonicalized CmpPredicate if they match. An alternative to operator==.
|
|
///
|
|
/// For example,
|
|
/// samesign ult + samesign ult -> samesign ult
|
|
/// samesign ult + ult -> ult
|
|
/// samesign ult + slt -> slt
|
|
/// ult + ult -> ult
|
|
/// ult + slt -> std::nullopt
|
|
LLVM_ABI static std::optional<CmpPredicate> getMatching(CmpPredicate A,
|
|
CmpPredicate B);
|
|
|
|
/// Attempts to return a signed CmpInst::Predicate from the CmpPredicate. If
|
|
/// the CmpPredicate has samesign, return ICmpInst::getSignedPredicate,
|
|
/// dropping samesign information. Otherwise, return the predicate, dropping
|
|
/// samesign information.
|
|
LLVM_ABI CmpInst::Predicate getPreferredSignedPredicate() const;
|
|
|
|
/// An operator== on the underlying Predicate.
|
|
bool operator==(CmpInst::Predicate P) const { return Pred == P; }
|
|
bool operator!=(CmpInst::Predicate P) const { return Pred != P; }
|
|
|
|
/// There is no operator== defined on CmpPredicate. Use getMatching instead to
|
|
/// get the canonicalized matching CmpPredicate.
|
|
bool operator==(CmpPredicate) const = delete;
|
|
bool operator!=(CmpPredicate) const = delete;
|
|
|
|
/// Do a ICmpInst::getCmpPredicate() or CmpInst::getPredicate(), as
|
|
/// appropriate.
|
|
LLVM_ABI static CmpPredicate get(const CmpInst *Cmp);
|
|
|
|
/// Get the inverse predicate of a CmpPredicate.
|
|
LLVM_ABI static CmpPredicate getInverse(CmpPredicate P);
|
|
|
|
/// Get the swapped predicate of a CmpPredicate.
|
|
LLVM_ABI static CmpPredicate getSwapped(CmpPredicate P);
|
|
|
|
/// Get the swapped predicate of a CmpInst.
|
|
LLVM_ABI static CmpPredicate getSwapped(const CmpInst *Cmp);
|
|
};
|
|
} // namespace llvm
|
|
|
|
#endif
|