llvm/llvm/lib/Support/SlowDynamicAPInt.cpp

//===- SlowDynamicAPInt.cpp - SlowDynamicAPInt 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/ADT/SlowDynamicAPInt.h"
#include "llvm/ADT/Hashing.h"
#include "llvm/Support/Debug.h"
#include "llvm/Support/raw_ostream.h"

usingnamespacellvm;
usingnamespacedetail;

SlowDynamicAPInt::SlowDynamicAPInt(int64_t Val)
    : … { … }
SlowDynamicAPInt::SlowDynamicAPInt() : … { … }
SlowDynamicAPInt::SlowDynamicAPInt(const APInt &Val) : … { … }
SlowDynamicAPInt &SlowDynamicAPInt::operator=(int64_t Val) { … }
operator long()

hash_code detail::hash_value(const SlowDynamicAPInt &X) { … }

/// ---------------------------------------------------------------------------
/// Convenience operator overloads for int64_t.
/// ---------------------------------------------------------------------------
SlowDynamicAPInt &detail::operator+=(SlowDynamicAPInt &A, int64_t B) { … }
SlowDynamicAPInt &detail::operator-=(SlowDynamicAPInt &A, int64_t B) { … }
SlowDynamicAPInt &detail::operator*=(SlowDynamicAPInt &A, int64_t B) { … }
SlowDynamicAPInt &detail::operator/=(SlowDynamicAPInt &A, int64_t B) { … }
SlowDynamicAPInt &detail::operator%=(SlowDynamicAPInt &A, int64_t B) { … }

bool detail::operator==(const SlowDynamicAPInt &A, int64_t B) { … }
bool detail::operator!=(const SlowDynamicAPInt &A, int64_t B) { … }
bool detail::operator>(const SlowDynamicAPInt &A, int64_t B) { … }
bool detail::operator<(const SlowDynamicAPInt &A, int64_t B) { … }
bool detail::operator<=(const SlowDynamicAPInt &A, int64_t B) { … }
bool detail::operator>=(const SlowDynamicAPInt &A, int64_t B) { … }
SlowDynamicAPInt detail::operator+(const SlowDynamicAPInt &A, int64_t B) { … }
SlowDynamicAPInt detail::operator-(const SlowDynamicAPInt &A, int64_t B) { … }
SlowDynamicAPInt detail::operator*(const SlowDynamicAPInt &A, int64_t B) { … }
SlowDynamicAPInt detail::operator/(const SlowDynamicAPInt &A, int64_t B) { … }
SlowDynamicAPInt detail::operator%(const SlowDynamicAPInt &A, int64_t B) { … }

bool detail::operator==(int64_t A, const SlowDynamicAPInt &B) { … }
bool detail::operator!=(int64_t A, const SlowDynamicAPInt &B) { … }
bool detail::operator>(int64_t A, const SlowDynamicAPInt &B) { … }
bool detail::operator<(int64_t A, const SlowDynamicAPInt &B) { … }
bool detail::operator<=(int64_t A, const SlowDynamicAPInt &B) { … }
bool detail::operator>=(int64_t A, const SlowDynamicAPInt &B) { … }
SlowDynamicAPInt detail::operator+(int64_t A, const SlowDynamicAPInt &B) { … }
SlowDynamicAPInt detail::operator-(int64_t A, const SlowDynamicAPInt &B) { … }
SlowDynamicAPInt detail::operator*(int64_t A, const SlowDynamicAPInt &B) { … }
SlowDynamicAPInt detail::operator/(int64_t A, const SlowDynamicAPInt &B) { … }
SlowDynamicAPInt detail::operator%(int64_t A, const SlowDynamicAPInt &B) { … }

static unsigned getMaxWidth(const APInt &A, const APInt &B) { … }

/// ---------------------------------------------------------------------------
/// Comparison operators.
/// ---------------------------------------------------------------------------

// TODO: consider instead making APInt::compare available and using that.
bool SlowDynamicAPInt::operator==(const SlowDynamicAPInt &O) const { … }
bool SlowDynamicAPInt::operator!=(const SlowDynamicAPInt &O) const { … }
bool SlowDynamicAPInt::operator>(const SlowDynamicAPInt &O) const { … }
bool SlowDynamicAPInt::operator<(const SlowDynamicAPInt &O) const { … }
bool SlowDynamicAPInt::operator<=(const SlowDynamicAPInt &O) const { … }
bool SlowDynamicAPInt::operator>=(const SlowDynamicAPInt &O) const { … }

/// ---------------------------------------------------------------------------
/// Arithmetic operators.
/// ---------------------------------------------------------------------------

/// Bring a and b to have the same width and then call op(a, b, overflow).
/// If the overflow bit becomes set, resize a and b to double the width and
/// call op(a, b, overflow), returning its result. The operation with double
/// widths should not also overflow.
APInt runOpWithExpandOnOverflow(
    const APInt &A, const APInt &B,
    function_ref<APInt(const APInt &, const APInt &, bool &Overflow)> Op) { … }

SlowDynamicAPInt SlowDynamicAPInt::operator+(const SlowDynamicAPInt &O) const { … }
SlowDynamicAPInt SlowDynamicAPInt::operator-(const SlowDynamicAPInt &O) const { … }
SlowDynamicAPInt SlowDynamicAPInt::operator*(const SlowDynamicAPInt &O) const { … }
SlowDynamicAPInt SlowDynamicAPInt::operator/(const SlowDynamicAPInt &O) const { … }
SlowDynamicAPInt detail::abs(const SlowDynamicAPInt &X) { … }
SlowDynamicAPInt detail::ceilDiv(const SlowDynamicAPInt &LHS,
                                 const SlowDynamicAPInt &RHS) { … }
SlowDynamicAPInt detail::floorDiv(const SlowDynamicAPInt &LHS,
                                  const SlowDynamicAPInt &RHS) { … }
// The RHS is always expected to be positive, and the result
/// is always non-negative.
SlowDynamicAPInt detail::mod(const SlowDynamicAPInt &LHS,
                             const SlowDynamicAPInt &RHS) { … }

SlowDynamicAPInt detail::gcd(const SlowDynamicAPInt &A,
                             const SlowDynamicAPInt &B) { … }

/// Returns the least common multiple of A and B.
SlowDynamicAPInt detail::lcm(const SlowDynamicAPInt &A,
                             const SlowDynamicAPInt &B) { … }

/// This operation cannot overflow.
SlowDynamicAPInt SlowDynamicAPInt::operator%(const SlowDynamicAPInt &O) const { … }

SlowDynamicAPInt SlowDynamicAPInt::operator-() const { … }

/// ---------------------------------------------------------------------------
/// Assignment operators, preincrement, predecrement.
/// ---------------------------------------------------------------------------
SlowDynamicAPInt &SlowDynamicAPInt::operator+=(const SlowDynamicAPInt &O) { … }
SlowDynamicAPInt &SlowDynamicAPInt::operator-=(const SlowDynamicAPInt &O) { … }
SlowDynamicAPInt &SlowDynamicAPInt::operator*=(const SlowDynamicAPInt &O) { … }
SlowDynamicAPInt &SlowDynamicAPInt::operator/=(const SlowDynamicAPInt &O) { … }
SlowDynamicAPInt &SlowDynamicAPInt::operator%=(const SlowDynamicAPInt &O) { … }
SlowDynamicAPInt &SlowDynamicAPInt::operator++() { … }

SlowDynamicAPInt &SlowDynamicAPInt::operator--() { … }

/// ---------------------------------------------------------------------------
/// Printing.
/// ---------------------------------------------------------------------------
void SlowDynamicAPInt::print(raw_ostream &OS) const { … }

void SlowDynamicAPInt::dump() const { … }