Author: Timm Baeder Date: 2024-01-31T10:00:42+01:00 New Revision: 64a849a52e08827e889be22ed3ceafe62cd03793
URL: https://github.com/llvm/llvm-project/commit/64a849a52e08827e889be22ed3ceafe62cd03793 DIFF: https://github.com/llvm/llvm-project/commit/64a849a52e08827e889be22ed3ceafe62cd03793.diff LOG: [clang][Interp] Support arbitrary precision constants (#79747) Add (de)serialization support for them, like we do for Floating values. Added: Modified: clang/lib/AST/Interp/ByteCodeEmitter.cpp clang/lib/AST/Interp/ByteCodeExprGen.cpp clang/lib/AST/Interp/Disasm.cpp clang/lib/AST/Interp/IntegralAP.h clang/lib/AST/Interp/Interp.h clang/lib/AST/Interp/Opcodes.td clang/test/AST/Interp/intap.cpp Removed: ################################################################################ diff --git a/clang/lib/AST/Interp/ByteCodeEmitter.cpp b/clang/lib/AST/Interp/ByteCodeEmitter.cpp index fd2a92d9d3f91..409ce21506caa 100644 --- a/clang/lib/AST/Interp/ByteCodeEmitter.cpp +++ b/clang/lib/AST/Interp/ByteCodeEmitter.cpp @@ -10,6 +10,7 @@ #include "ByteCodeGenError.h" #include "Context.h" #include "Floating.h" +#include "IntegralAP.h" #include "Opcode.h" #include "Program.h" #include "clang/AST/ASTLambda.h" @@ -209,9 +210,11 @@ static void emit(Program &P, std::vector<std::byte> &Code, const T &Val, } } -template <> -void emit(Program &P, std::vector<std::byte> &Code, const Floating &Val, - bool &Success) { +/// Emits a serializable value. These usually (potentially) contain +/// heap-allocated memory and aren't trivially copyable. +template <typename T> +static void emitSerialized(std::vector<std::byte> &Code, const T &Val, + bool &Success) { size_t Size = Val.bytesToSerialize(); if (Code.size() + Size > std::numeric_limits<unsigned>::max()) { @@ -228,6 +231,24 @@ void emit(Program &P, std::vector<std::byte> &Code, const Floating &Val, Val.serialize(Code.data() + ValPos); } +template <> +void emit(Program &P, std::vector<std::byte> &Code, const Floating &Val, + bool &Success) { + emitSerialized(Code, Val, Success); +} + +template <> +void emit(Program &P, std::vector<std::byte> &Code, + const IntegralAP<false> &Val, bool &Success) { + emitSerialized(Code, Val, Success); +} + +template <> +void emit(Program &P, std::vector<std::byte> &Code, const IntegralAP<true> &Val, + bool &Success) { + emitSerialized(Code, Val, Success); +} + template <typename... Tys> bool ByteCodeEmitter::emitOp(Opcode Op, const Tys &... Args, const SourceInfo &SI) { bool Success = true; diff --git a/clang/lib/AST/Interp/ByteCodeExprGen.cpp b/clang/lib/AST/Interp/ByteCodeExprGen.cpp index 8188d6f7f5c24..386abef598594 100644 --- a/clang/lib/AST/Interp/ByteCodeExprGen.cpp +++ b/clang/lib/AST/Interp/ByteCodeExprGen.cpp @@ -2204,15 +2204,13 @@ bool ByteCodeExprGen<Emitter>::emitConst(T Value, PrimType Ty, const Expr *E) { return this->emitConstSint64(Value, E); case PT_Uint64: return this->emitConstUint64(Value, E); - case PT_IntAP: - case PT_IntAPS: - assert(false); - return false; case PT_Bool: return this->emitConstBool(Value, E); case PT_Ptr: case PT_FnPtr: case PT_Float: + case PT_IntAP: + case PT_IntAPS: llvm_unreachable("Invalid integral type"); break; } @@ -2228,6 +2226,11 @@ bool ByteCodeExprGen<Emitter>::emitConst(T Value, const Expr *E) { template <class Emitter> bool ByteCodeExprGen<Emitter>::emitConst(const APSInt &Value, PrimType Ty, const Expr *E) { + if (Ty == PT_IntAPS) + return this->emitConstIntAPS(Value, E); + if (Ty == PT_IntAP) + return this->emitConstIntAP(Value, E); + if (Value.isSigned()) return this->emitConst(Value.getSExtValue(), Ty, E); return this->emitConst(Value.getZExtValue(), Ty, E); diff --git a/clang/lib/AST/Interp/Disasm.cpp b/clang/lib/AST/Interp/Disasm.cpp index d276df8f29262..eba437e05f59d 100644 --- a/clang/lib/AST/Interp/Disasm.cpp +++ b/clang/lib/AST/Interp/Disasm.cpp @@ -12,6 +12,7 @@ #include "Floating.h" #include "Function.h" +#include "IntegralAP.h" #include "Opcode.h" #include "PrimType.h" #include "Program.h" @@ -37,6 +38,20 @@ template <> inline Floating ReadArg<Floating>(Program &P, CodePtr &OpPC) { return F; } +template <> +inline IntegralAP<false> ReadArg<IntegralAP<false>>(Program &P, CodePtr &OpPC) { + IntegralAP<false> I = IntegralAP<false>::deserialize(*OpPC); + OpPC += align(I.bytesToSerialize()); + return I; +} + +template <> +inline IntegralAP<true> ReadArg<IntegralAP<true>>(Program &P, CodePtr &OpPC) { + IntegralAP<true> I = IntegralAP<true>::deserialize(*OpPC); + OpPC += align(I.bytesToSerialize()); + return I; +} + LLVM_DUMP_METHOD void Function::dump() const { dump(llvm::errs()); } LLVM_DUMP_METHOD void Function::dump(llvm::raw_ostream &OS) const { diff --git a/clang/lib/AST/Interp/IntegralAP.h b/clang/lib/AST/Interp/IntegralAP.h index 55e29caa1cd74..bab9774288bfa 100644 --- a/clang/lib/AST/Interp/IntegralAP.h +++ b/clang/lib/AST/Interp/IntegralAP.h @@ -263,6 +263,31 @@ template <bool Signed> class IntegralAP final { *R = IntegralAP(A.V.lshr(ShiftAmount)); } + // === Serialization support === + size_t bytesToSerialize() const { + // 4 bytes for the BitWidth followed by N bytes for the actual APInt. + return sizeof(uint32_t) + (V.getBitWidth() / CHAR_BIT); + } + + void serialize(std::byte *Buff) const { + assert(V.getBitWidth() < std::numeric_limits<uint8_t>::max()); + uint32_t BitWidth = V.getBitWidth(); + + std::memcpy(Buff, &BitWidth, sizeof(uint32_t)); + llvm::StoreIntToMemory(V, (uint8_t *)(Buff + sizeof(uint32_t)), + BitWidth / CHAR_BIT); + } + + static IntegralAP<Signed> deserialize(const std::byte *Buff) { + uint32_t BitWidth; + std::memcpy(&BitWidth, Buff, sizeof(uint32_t)); + IntegralAP<Signed> Val(APInt(BitWidth, 0ull, !Signed)); + + llvm::LoadIntFromMemory(Val.V, (const uint8_t *)Buff + sizeof(uint32_t), + BitWidth / CHAR_BIT); + return Val; + } + private: template <template <typename T> class Op> static bool CheckAddSubMulUB(const IntegralAP &A, const IntegralAP &B, @@ -289,6 +314,11 @@ inline llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, return OS; } +template <bool Signed> +IntegralAP<Signed> getSwappedBytes(IntegralAP<Signed> F) { + return F; +} + } // namespace interp } // namespace clang diff --git a/clang/lib/AST/Interp/Interp.h b/clang/lib/AST/Interp/Interp.h index 875fe3f9870e5..b71469b2cba1f 100644 --- a/clang/lib/AST/Interp/Interp.h +++ b/clang/lib/AST/Interp/Interp.h @@ -2059,6 +2059,22 @@ template <> inline Floating ReadArg<Floating>(InterpState &S, CodePtr &OpPC) { return F; } +template <> +inline IntegralAP<false> ReadArg<IntegralAP<false>>(InterpState &S, + CodePtr &OpPC) { + IntegralAP<false> I = IntegralAP<false>::deserialize(*OpPC); + OpPC += align(I.bytesToSerialize()); + return I; +} + +template <> +inline IntegralAP<true> ReadArg<IntegralAP<true>>(InterpState &S, + CodePtr &OpPC) { + IntegralAP<true> I = IntegralAP<true>::deserialize(*OpPC); + OpPC += align(I.bytesToSerialize()); + return I; +} + } // namespace interp } // namespace clang diff --git a/clang/lib/AST/Interp/Opcodes.td b/clang/lib/AST/Interp/Opcodes.td index 1564457bb9984..e720b95498f17 100644 --- a/clang/lib/AST/Interp/Opcodes.td +++ b/clang/lib/AST/Interp/Opcodes.td @@ -45,6 +45,8 @@ def ArgUint32 : ArgType { let Name = "uint32_t"; } def ArgSint64 : ArgType { let Name = "int64_t"; } def ArgUint64 : ArgType { let Name = "uint64_t"; } def ArgFloat : ArgType { let Name = "Floating"; } +def ArgIntAP : ArgType { let Name = "IntegralAP<false>"; } +def ArgIntAPS : ArgType { let Name = "IntegralAP<true>"; } def ArgBool : ArgType { let Name = "bool"; } def ArgFunction : ArgType { let Name = "const Function *"; } @@ -244,6 +246,8 @@ def ConstUint32 : ConstOpcode<Uint32, ArgUint32>; def ConstSint64 : ConstOpcode<Sint64, ArgSint64>; def ConstUint64 : ConstOpcode<Uint64, ArgUint64>; def ConstFloat : ConstOpcode<Float, ArgFloat>; +def constIntAP : ConstOpcode<IntAP, ArgIntAP>; +def constIntAPS : ConstOpcode<IntAPS, ArgIntAPS>; def ConstBool : ConstOpcode<Bool, ArgBool>; // [] -> [Integer] diff --git a/clang/test/AST/Interp/intap.cpp b/clang/test/AST/Interp/intap.cpp index 118dc21b67e87..d444012485691 100644 --- a/clang/test/AST/Interp/intap.cpp +++ b/clang/test/AST/Interp/intap.cpp @@ -154,6 +154,20 @@ namespace i128 { constexpr uint128_t ui128Zero{}; static_assert(ui128Zero == 0, ""); + + enum LargeEnum : signed __int128 { + LV = (signed __int128)1 << 127, + }; + + constexpr LargeEnum F = LV; + static_assert(F == (signed __int128)1 << 127, ""); + constexpr LargeEnum getLargeEnum() { + return LV; + } + static_assert(getLargeEnum() == (signed __int128)1 << 127, ""); + + + #if __cplusplus >= 201402L template <typename T> constexpr T CastFrom(__int128_t A) { _______________________________________________ cfe-commits mailing list cfe-commits@lists.llvm.org https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
