IntegralAP.h

Go to the documentation of this file.

//===--- Integral.h - Wrapper for numeric types for the VM ------*- 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
//
//===----------------------------------------------------------------------===//
//
// Defines the VM types and helpers operating on types.
//
//===----------------------------------------------------------------------===//
 
#ifndef LLVM_CLANG_AST_INTERP_INTEGRAL_AP_H
#define LLVM_CLANG_AST_INTERP_INTEGRAL_AP_H
 
#include "clang/AST/APValue.h"
#include "clang/AST/ComparisonCategories.h"
#include "llvm/ADT/APSInt.h"
#include "llvm/Support/MathExtras.h"
#include "llvm/Support/raw_ostream.h"
#include <cstddef>
#include <cstdint>
 
#include "Primitives.h"
 
namespace clang {
namespace interp {
 
using APInt = llvm::APInt;
using APSInt = llvm::APSInt;
 
/// If an IntegralAP is constructed from Memory, it DOES NOT OWN THAT MEMORY.
/// It will NOT copy the memory (unless, of course, copy() is called) and it
/// won't alllocate anything. The allocation should happen via InterpState or
/// Program.
template <bool Signed> class IntegralAP final {
public:
  union {
    uint64_t *Memory = nullptr;
    uint64_t Val;
  };
  uint32_t BitWidth = 0;
  friend IntegralAP<!Signed>;
 
  template <typename T, bool InputSigned>
  static T truncateCast(const APInt &V) {
    constexpr unsigned BitSize = sizeof(T) * 8;
    if (BitSize >= V.getBitWidth()) {
      APInt Extended;
      if constexpr (InputSigned)
        Extended = V.sext(BitSize);
      else
        Extended = V.zext(BitSize);
      return std::is_signed_v<T> ? Extended.getSExtValue()
                                 : Extended.getZExtValue();
    }
 
    return std::is_signed_v<T> ? V.trunc(BitSize).getSExtValue()
                               : V.trunc(BitSize).getZExtValue();
  }
 
  APInt getValue() const {
    if (singleWord())
      return APInt(BitWidth, Val, Signed);
    unsigned NumWords = llvm::APInt::getNumWords(BitWidth);
    return llvm::APInt(BitWidth, llvm::ArrayRef(Memory, NumWords));
  }
 
public:
  using AsUnsigned = IntegralAP<false>;
 
  void take(uint64_t *NewMemory) {
    assert(!singleWord());
    std::memcpy(NewMemory, Memory, numWords() * sizeof(uint64_t));
    Memory = NewMemory;
  }
 
  void copy(const APInt &V) {
    assert(BitWidth == V.getBitWidth());
    assert(numWords() == V.getNumWords());
 
    if (V.isSingleWord()) {
      if constexpr (Signed)
        Val = V.getSExtValue();
      else
        Val = V.getZExtValue();
      return;
    }
    assert(Memory);
    std::memcpy(Memory, V.getRawData(), V.getNumWords() * sizeof(uint64_t));
  }
 
  IntegralAP() = default;
  /// Zeroed, single-word IntegralAP of the given bitwidth.
  IntegralAP(unsigned BitWidth) : Val(0), BitWidth(BitWidth) {
    assert(singleWord());
  }
  IntegralAP(uint64_t *Memory, unsigned BitWidth)
      : Memory(Memory), BitWidth(BitWidth) {}
  IntegralAP(const APInt &V) : BitWidth(V.getBitWidth()) {
    if (V.isSingleWord()) {
      Val = Signed ? V.getSExtValue() : V.getZExtValue();
    } else {
      Memory = const_cast<uint64_t *>(V.getRawData());
    }
  }
 
  IntegralAP operator-() const { return IntegralAP(-getValue()); }
  bool operator>(const IntegralAP &RHS) const {
    if constexpr (Signed)
      return getValue().sgt(RHS.getValue());
    return getValue().ugt(RHS.getValue());
  }
  bool operator>=(unsigned RHS) const {
    if constexpr (Signed)
      return getValue().sge(RHS);
    return getValue().uge(RHS);
  }
  bool operator<(IntegralAP RHS) const {
    if constexpr (Signed)
      return getValue().slt(RHS.getValue());
    return getValue().ult(RHS.getValue());
  }
 
  template <typename Ty, typename = std::enable_if_t<std::is_integral_v<Ty>>>
  explicit operator Ty() const {
    return truncateCast<Ty, Signed>(getValue());
  }
 
  template <typename T> static IntegralAP from(T Value, unsigned NumBits = 0) {
    if (NumBits == 0)
      NumBits = sizeof(T) * 8;
    assert(NumBits > 0);
    assert(APInt::getNumWords(NumBits) == 1);
    APInt Copy = APInt(NumBits, static_cast<uint64_t>(Value), Signed);
    return IntegralAP<Signed>(Copy);
  }
 
  constexpr uint32_t bitWidth() const { return BitWidth; }
  constexpr unsigned numWords() const { return APInt::getNumWords(BitWidth); }
  constexpr bool singleWord() const { return numWords() <= 1; }
  constexpr static bool isNumber() { return true; }
 
  APSInt toAPSInt(unsigned Bits = 0) const {
    if (Bits == 0)
      Bits = bitWidth();
 
    APInt V = getValue();
    if constexpr (Signed)
      return APSInt(getValue().sext(Bits), !Signed);
    else
      return APSInt(getValue().zext(Bits), !Signed);
  }
  APValue toAPValue(const ASTContext &) const { return APValue(toAPSInt()); }
 
  bool isZero() const { return getValue().isZero(); }
  bool isPositive() const {
    if constexpr (Signed)
      return getValue().isNonNegative();
    return true;
  }
  bool isNegative() const {
    if constexpr (Signed)
      return !getValue().isNonNegative();
    return false;
  }
  bool isMin() const {
    if constexpr (Signed)
      return getValue().isMinSignedValue();
    return getValue().isMinValue();
  }
  bool isMax() const {
    if constexpr (Signed)
      return getValue().isMaxSignedValue();
    return getValue().isMaxValue();
  }
  static constexpr bool isSigned() { return Signed; }
  bool isMinusOne() const { return Signed && getValue().isAllOnes(); }
 
  unsigned countLeadingZeros() const { return getValue().countl_zero(); }
 
  void print(llvm::raw_ostream &OS) const { getValue().print(OS, Signed); }
  std::string toDiagnosticString(const ASTContext &Ctx) const {
    std::string NameStr;
    llvm::raw_string_ostream OS(NameStr);
    print(OS);
    return NameStr;
  }
 
  IntegralAP truncate(unsigned BitWidth) const {
    if constexpr (Signed)
      return IntegralAP(
          getValue().trunc(BitWidth).sextOrTrunc(this->bitWidth()));
    else
      return IntegralAP(
          getValue().trunc(BitWidth).zextOrTrunc(this->bitWidth()));
  }
 
  IntegralAP<false> toUnsigned() const {
    return IntegralAP<false>(Memory, BitWidth);
  }
 
  void bitcastToMemory(std::byte *Dest) const {
    llvm::StoreIntToMemory(getValue(), (uint8_t *)Dest, bitWidth() / 8);
  }
 
  static void bitcastFromMemory(const std::byte *Src, unsigned BitWidth,
                                IntegralAP *Result) {
    APInt V(BitWidth, static_cast<uint64_t>(0), Signed);
    llvm::LoadIntFromMemory(V, (const uint8_t *)Src, BitWidth / 8);
    Result->copy(V);
  }
 
  ComparisonCategoryResult compare(const IntegralAP &RHS) const {
    assert(Signed == RHS.isSigned());
    assert(bitWidth() == RHS.bitWidth());
    APInt V1 = getValue();
    APInt V2 = RHS.getValue();
    if constexpr (Signed) {
      if (V1.slt(V2))
        return ComparisonCategoryResult::Less;
      if (V1.sgt(V2))
        return ComparisonCategoryResult::Greater;
      return ComparisonCategoryResult::Equal;
    }
 
    assert(!Signed);
    if (V1.ult(V2))
      return ComparisonCategoryResult::Less;
    if (V1.ugt(V2))
      return ComparisonCategoryResult::Greater;
    return ComparisonCategoryResult::Equal;
  }
 
  static bool increment(IntegralAP A, IntegralAP *R) {
    APSInt One(APInt(A.bitWidth(), 1ull, Signed), !Signed);
    return add(A, IntegralAP<Signed>(One), A.bitWidth() + 1, R);
  }
 
  static bool decrement(IntegralAP A, IntegralAP *R) {
    APSInt One(APInt(A.bitWidth(), 1ull, Signed), !Signed);
    return sub(A, IntegralAP<Signed>(One), A.bitWidth() + 1, R);
  }
 
  static bool add(IntegralAP A, IntegralAP B, unsigned OpBits, IntegralAP *R) {
    return CheckAddSubMulUB<std::plus>(A, B, OpBits, R);
  }
 
  static bool sub(IntegralAP A, IntegralAP B, unsigned OpBits, IntegralAP *R) {
    return CheckAddSubMulUB<std::minus>(A, B, OpBits, R);
  }
 
  static bool mul(IntegralAP A, IntegralAP B, unsigned OpBits, IntegralAP *R) {
    return CheckAddSubMulUB<std::multiplies>(A, B, OpBits, R);
  }
 
  static bool rem(IntegralAP A, IntegralAP B, unsigned OpBits, IntegralAP *R) {
    if constexpr (Signed)
      R->copy(A.getValue().srem(B.getValue()));
    else
      R->copy(A.getValue().urem(B.getValue()));
    return false;
  }
 
  static bool div(IntegralAP A, IntegralAP B, unsigned OpBits, IntegralAP *R) {
    if constexpr (Signed)
      R->copy(A.getValue().sdiv(B.getValue()));
    else
      R->copy(A.getValue().udiv(B.getValue()));
    return false;
  }
 
  static bool bitAnd(IntegralAP A, IntegralAP B, unsigned OpBits,
                     IntegralAP *R) {
    R->copy(A.getValue() & B.getValue());
    return false;
  }
 
  static bool bitOr(IntegralAP A, IntegralAP B, unsigned OpBits,
                    IntegralAP *R) {
    R->copy(A.getValue() | B.getValue());
    return false;
  }
 
  static bool bitXor(IntegralAP A, IntegralAP B, unsigned OpBits,
                     IntegralAP *R) {
    R->copy(A.getValue() ^ B.getValue());
    return false;
  }
 
  static bool neg(const IntegralAP &A, IntegralAP *R) {
    APInt AI = A.getValue();
    AI.negate();
    R->copy(AI);
    return false;
  }
 
  static bool comp(IntegralAP A, IntegralAP *R) {
    R->copy(~A.getValue());
    return false;
  }
 
  static void shiftLeft(const IntegralAP A, const IntegralAP B, unsigned OpBits,
                        IntegralAP *R) {
    *R = IntegralAP(A.getValue().shl(B.getValue().getZExtValue()));
  }
 
  static void shiftRight(const IntegralAP A, const IntegralAP B,
                         unsigned OpBits, IntegralAP *R) {
    unsigned ShiftAmount = B.getValue().getZExtValue();
    if constexpr (Signed)
      R->copy(A.getValue().ashr(ShiftAmount));
    else
      R->copy(A.getValue().lshr(ShiftAmount));
  }
 
  // === Serialization support ===
  size_t bytesToSerialize() const {
    assert(BitWidth != 0);
    return sizeof(uint32_t) + (numWords() * sizeof(uint64_t));
  }
 
  void serialize(std::byte *Buff) const {
    std::memcpy(Buff, &BitWidth, sizeof(uint32_t));
    if (singleWord())
      std::memcpy(Buff + sizeof(uint32_t), &Val, sizeof(uint64_t));
    else {
      std::memcpy(Buff + sizeof(uint32_t), Memory,
                  numWords() * sizeof(uint64_t));
    }
  }
 
  static uint32_t deserializeSize(const std::byte *Buff) {
    return *reinterpret_cast<const uint32_t *>(Buff);
  }
 
  static void deserialize(const std::byte *Buff, IntegralAP<Signed> *Result) {
    uint32_t BitWidth = Result->BitWidth;
    assert(BitWidth != 0);
    unsigned NumWords = llvm::APInt::getNumWords(BitWidth);
 
    if (NumWords == 1)
      std::memcpy(&Result->Val, Buff + sizeof(uint32_t), sizeof(uint64_t));
    else {
      assert(Result->Memory);
      std::memcpy(Result->Memory, Buff + sizeof(uint32_t),
                  NumWords * sizeof(uint64_t));
    }
  }
 
private:
  template <template <typename T> class Op>
  static bool CheckAddSubMulUB(const IntegralAP &A, const IntegralAP &B,
                               unsigned BitWidth, IntegralAP *R) {
    if constexpr (!Signed) {
      R->copy(Op<APInt>{}(A.getValue(), B.getValue()));
      return false;
    }
 
    const APSInt &LHS = A.toAPSInt();
    const APSInt &RHS = B.toAPSInt();
    APSInt Value = Op<APSInt>{}(LHS.extend(BitWidth), RHS.extend(BitWidth));
    APSInt Result = Value.trunc(LHS.getBitWidth());
    R->copy(Result);
 
    return Result.extend(BitWidth) != Value;
  }
};
 
template <bool Signed>
inline llvm::raw_ostream &operator<<(llvm::raw_ostream &OS,
                                     IntegralAP<Signed> I) {
  I.print(OS);
  return OS;
}
 
template <bool Signed>
IntegralAP<Signed> getSwappedBytes(IntegralAP<Signed> F) {
  return F;
}
 
} // namespace interp
} // namespace clang
 
#endif