llvm/llvm/lib/IR/ConstantFPRange.cpp

//===- ConstantFPRange.cpp - ConstantFPRange implementation ---------------===//
//
// 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/IR/ConstantFPRange.h"
#include "llvm/ADT/APFloat.h"
#include "llvm/Support/Debug.h"
#include "llvm/Support/raw_ostream.h"
#include <cassert>

usingnamespacellvm;

void ConstantFPRange::makeEmpty() { … }

void ConstantFPRange::makeFull() { … }

bool ConstantFPRange::isNaNOnly() const { … }

ConstantFPRange::ConstantFPRange(const fltSemantics &Sem, bool IsFullSet)
    : … { … }

ConstantFPRange::ConstantFPRange(const APFloat &Value)
    : … { … }

// We treat that -0 is less than 0 here.
static APFloat::cmpResult strictCompare(const APFloat &LHS,
                                        const APFloat &RHS) { … }

static bool isNonCanonicalEmptySet(const APFloat &Lower, const APFloat &Upper) { … }

static void canonicalizeRange(APFloat &Lower, APFloat &Upper) { … }

ConstantFPRange::ConstantFPRange(APFloat LowerVal, APFloat UpperVal,
                                 bool MayBeQNaNVal, bool MayBeSNaNVal)
    : … { … }

ConstantFPRange ConstantFPRange::getFinite(const fltSemantics &Sem) { … }

ConstantFPRange ConstantFPRange::getNaNOnly(const fltSemantics &Sem,
                                            bool MayBeQNaN, bool MayBeSNaN) { … }

ConstantFPRange ConstantFPRange::getNonNaN(const fltSemantics &Sem) { … }

/// Return true for ULT/UGT/OLT/OGT
static bool fcmpPredExcludesEqual(FCmpInst::Predicate Pred) { … }

/// Return [-inf, V) or [-inf, V]
static ConstantFPRange makeLessThan(APFloat V, FCmpInst::Predicate Pred) { … }

/// Return (V, +inf] or [V, +inf]
static ConstantFPRange makeGreaterThan(APFloat V, FCmpInst::Predicate Pred) { … }

/// Make sure that +0/-0 are both included in the range.
static ConstantFPRange extendZeroIfEqual(const ConstantFPRange &CR,
                                         FCmpInst::Predicate Pred) { … }

static ConstantFPRange setNaNField(const ConstantFPRange &CR,
                                   FCmpInst::Predicate Pred) { … }

ConstantFPRange
ConstantFPRange::makeAllowedFCmpRegion(FCmpInst::Predicate Pred,
                                       const ConstantFPRange &Other) { … }

ConstantFPRange
ConstantFPRange::makeSatisfyingFCmpRegion(FCmpInst::Predicate Pred,
                                          const ConstantFPRange &Other) { … }

std::optional<ConstantFPRange>
ConstantFPRange::makeExactFCmpRegion(FCmpInst::Predicate Pred,
                                     const APFloat &Other) { … }

bool ConstantFPRange::fcmp(FCmpInst::Predicate Pred,
                           const ConstantFPRange &Other) const { … }

bool ConstantFPRange::isFullSet() const { … }

bool ConstantFPRange::isEmptySet() const { … }

bool ConstantFPRange::contains(const APFloat &Val) const { … }

bool ConstantFPRange::contains(const ConstantFPRange &CR) const { … }

const APFloat *ConstantFPRange::getSingleElement(bool ExcludesNaN) const { … }

std::optional<bool> ConstantFPRange::getSignBit() const { … }

bool ConstantFPRange::operator==(const ConstantFPRange &CR) const { … }

FPClassTest ConstantFPRange::classify() const { … }

void ConstantFPRange::print(raw_ostream &OS) const { … }

#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
LLVM_DUMP_METHOD void ConstantFPRange::dump() const { print(dbgs()); }
#endif

ConstantFPRange
ConstantFPRange::intersectWith(const ConstantFPRange &CR) const { … }

ConstantFPRange ConstantFPRange::unionWith(const ConstantFPRange &CR) const { … }