386 lines
12 KiB
C++
386 lines
12 KiB
C++
//===--- 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
|