KnownBits.cpp | Explore in Territory

//===-- KnownBits.cpp - Stores known zeros/ones ---------------------------===//
//
// 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
//
//===----------------------------------------------------------------------===//
//
// This file contains a class for representing known zeros and ones used by
// computeKnownBits.
//
//===----------------------------------------------------------------------===//

#include "llvm/Support/KnownBits.h"
#include "llvm/Support/Debug.h"
#include "llvm/Support/raw_ostream.h"
#include <cassert>

usingnamespacellvm;

KnownBits KnownBits::flipSignBit(const KnownBits &Val) { … }

static KnownBits computeForAddCarry(const KnownBits &LHS, const KnownBits &RHS,
                                    bool CarryZero, bool CarryOne) { … }

KnownBits KnownBits::computeForAddCarry(
    const KnownBits &LHS, const KnownBits &RHS, const KnownBits &Carry) { … }

KnownBits KnownBits::computeForAddSub(bool Add, bool NSW, bool NUW,
                                      const KnownBits &LHS,
                                      const KnownBits &RHS) { … }

KnownBits KnownBits::computeForSubBorrow(const KnownBits &LHS, KnownBits RHS,
                                         const KnownBits &Borrow) { … }

KnownBits KnownBits::sextInReg(unsigned SrcBitWidth) const { … }

KnownBits KnownBits::makeGE(const APInt &Val) const { … }

KnownBits KnownBits::umax(const KnownBits &LHS, const KnownBits &RHS) { … }

KnownBits KnownBits::umin(const KnownBits &LHS, const KnownBits &RHS) { … }

KnownBits KnownBits::smax(const KnownBits &LHS, const KnownBits &RHS) { … }

KnownBits KnownBits::smin(const KnownBits &LHS, const KnownBits &RHS) { … }

KnownBits KnownBits::abdu(const KnownBits &LHS, const KnownBits &RHS) { … }

KnownBits KnownBits::abds(KnownBits LHS, KnownBits RHS) { … }

static unsigned getMaxShiftAmount(const APInt &MaxValue, unsigned BitWidth) { … }

KnownBits KnownBits::shl(const KnownBits &LHS, const KnownBits &RHS, bool NUW,
                         bool NSW, bool ShAmtNonZero) { … }

KnownBits KnownBits::lshr(const KnownBits &LHS, const KnownBits &RHS,
                          bool ShAmtNonZero, bool Exact) { … }

KnownBits KnownBits::ashr(const KnownBits &LHS, const KnownBits &RHS,
                          bool ShAmtNonZero, bool Exact) { … }

std::optional<bool> KnownBits::eq(const KnownBits &LHS, const KnownBits &RHS) { … }

std::optional<bool> KnownBits::ne(const KnownBits &LHS, const KnownBits &RHS) { … }

std::optional<bool> KnownBits::ugt(const KnownBits &LHS, const KnownBits &RHS) { … }

std::optional<bool> KnownBits::uge(const KnownBits &LHS, const KnownBits &RHS) { … }

std::optional<bool> KnownBits::ult(const KnownBits &LHS, const KnownBits &RHS) { … }

std::optional<bool> KnownBits::ule(const KnownBits &LHS, const KnownBits &RHS) { … }

std::optional<bool> KnownBits::sgt(const KnownBits &LHS, const KnownBits &RHS) { … }

std::optional<bool> KnownBits::sge(const KnownBits &LHS, const KnownBits &RHS) { … }

std::optional<bool> KnownBits::slt(const KnownBits &LHS, const KnownBits &RHS) { … }

std::optional<bool> KnownBits::sle(const KnownBits &LHS, const KnownBits &RHS) { … }

KnownBits KnownBits::abs(bool IntMinIsPoison) const { … }

static KnownBits computeForSatAddSub(bool Add, bool Signed,
                                     const KnownBits &LHS,
                                     const KnownBits &RHS) { … }

KnownBits KnownBits::sadd_sat(const KnownBits &LHS, const KnownBits &RHS) { … }
KnownBits KnownBits::ssub_sat(const KnownBits &LHS, const KnownBits &RHS) { … }
KnownBits KnownBits::uadd_sat(const KnownBits &LHS, const KnownBits &RHS) { … }
KnownBits KnownBits::usub_sat(const KnownBits &LHS, const KnownBits &RHS) { … }

static KnownBits avgComputeU(KnownBits LHS, KnownBits RHS, bool IsCeil) { … }

KnownBits KnownBits::avgFloorS(const KnownBits &LHS, const KnownBits &RHS) { … }

KnownBits KnownBits::avgFloorU(const KnownBits &LHS, const KnownBits &RHS) { … }

KnownBits KnownBits::avgCeilS(const KnownBits &LHS, const KnownBits &RHS) { … }

KnownBits KnownBits::avgCeilU(const KnownBits &LHS, const KnownBits &RHS) { … }

KnownBits KnownBits::mul(const KnownBits &LHS, const KnownBits &RHS,
                         bool NoUndefSelfMultiply) { … }

KnownBits KnownBits::mulhs(const KnownBits &LHS, const KnownBits &RHS) { … }

KnownBits KnownBits::mulhu(const KnownBits &LHS, const KnownBits &RHS) { … }

static KnownBits divComputeLowBit(KnownBits Known, const KnownBits &LHS,
                                  const KnownBits &RHS, bool Exact) { … }

KnownBits KnownBits::sdiv(const KnownBits &LHS, const KnownBits &RHS,
                          bool Exact) { … }

KnownBits KnownBits::udiv(const KnownBits &LHS, const KnownBits &RHS,
                          bool Exact) { … }

KnownBits KnownBits::remGetLowBits(const KnownBits &LHS, const KnownBits &RHS) { … }

KnownBits KnownBits::urem(const KnownBits &LHS, const KnownBits &RHS) { … }

KnownBits KnownBits::srem(const KnownBits &LHS, const KnownBits &RHS) { … }

KnownBits &KnownBits::operator&=(const KnownBits &RHS) { … }

KnownBits &KnownBits::operator|=(const KnownBits &RHS) { … }

KnownBits &KnownBits::operator^=(const KnownBits &RHS) { … }

KnownBits KnownBits::blsi() const { … }

KnownBits KnownBits::blsmsk() const { … }

void KnownBits::print(raw_ostream &OS) const { … }
void KnownBits::dump() const { … }
llvm/llvm/lib/Support/KnownBits.cpp
