[llvm] [clang] [clang][Interp] Support arbitrary precision constants (PR #79747)
Timm Baeder via cfe-commits
cfe-commits at lists.llvm.org
Tue Jan 30 07:49:16 PST 2024
Timm =?utf-8?q?Bäder?= <tbaeder at redhat.com>
Message-ID:
In-Reply-To: <llvm.org/llvm/llvm-project/pull/79747 at github.com>
https://github.com/tbaederr updated https://github.com/llvm/llvm-project/pull/79747
>From c9f1518241b27978c40b7a5fc52f2c5ad9d32604 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Timm=20B=C3=A4der?= <tbaeder at redhat.com>
Date: Tue, 30 Jan 2024 15:57:07 +0100
Subject: [PATCH 1/2] [llvm][Support] Support bright colors in raw_ostream
---
llvm/include/llvm/Support/raw_ostream.h | 16 ++++++++++
llvm/lib/Support/Process.cpp | 39 +++++++++++++++++--------
llvm/lib/Support/Unix/Process.inc | 2 +-
llvm/lib/Support/Windows/Process.inc | 2 +-
4 files changed, 45 insertions(+), 14 deletions(-)
diff --git a/llvm/include/llvm/Support/raw_ostream.h b/llvm/include/llvm/Support/raw_ostream.h
index 42663a9adf2e5..696290a5d99cf 100644
--- a/llvm/include/llvm/Support/raw_ostream.h
+++ b/llvm/include/llvm/Support/raw_ostream.h
@@ -102,6 +102,14 @@ class raw_ostream {
MAGENTA,
CYAN,
WHITE,
+ BRIGHT_BLACK,
+ BRIGHT_RED,
+ BRIGHT_GREEN,
+ BRIGHT_YELLOW,
+ BRIGHT_BLUE,
+ BRIGHT_MAGENTA,
+ BRIGHT_CYAN,
+ BRIGHT_WHITE,
SAVEDCOLOR,
RESET,
};
@@ -114,6 +122,14 @@ class raw_ostream {
static constexpr Colors MAGENTA = Colors::MAGENTA;
static constexpr Colors CYAN = Colors::CYAN;
static constexpr Colors WHITE = Colors::WHITE;
+ static constexpr Colors BRIGHT_BLACK = Colors::BRIGHT_BLACK;
+ static constexpr Colors BRIGHT_RED = Colors::BRIGHT_RED;
+ static constexpr Colors BRIGHT_GREEN = Colors::BRIGHT_GREEN;
+ static constexpr Colors BRIGHT_YELLOW = Colors::BRIGHT_YELLOW;
+ static constexpr Colors BRIGHT_BLUE = Colors::BRIGHT_BLUE;
+ static constexpr Colors BRIGHT_MAGENTA = Colors::BRIGHT_MAGENTA;
+ static constexpr Colors BRIGHT_CYAN = Colors::BRIGHT_CYAN;
+ static constexpr Colors BRIGHT_WHITE = Colors::BRIGHT_WHITE;
static constexpr Colors SAVEDCOLOR = Colors::SAVEDCOLOR;
static constexpr Colors RESET = Colors::RESET;
diff --git a/llvm/lib/Support/Process.cpp b/llvm/lib/Support/Process.cpp
index f81c13970d521..f1ab8c7b9ebd8 100644
--- a/llvm/lib/Support/Process.cpp
+++ b/llvm/lib/Support/Process.cpp
@@ -70,20 +70,35 @@ Process::FindInEnvPath(StringRef EnvName, StringRef FileName,
#define COLOR(FGBG, CODE, BOLD) "\033[0;" BOLD FGBG CODE "m"
-#define ALLCOLORS(FGBG,BOLD) {\
- COLOR(FGBG, "0", BOLD),\
- COLOR(FGBG, "1", BOLD),\
- COLOR(FGBG, "2", BOLD),\
- COLOR(FGBG, "3", BOLD),\
- COLOR(FGBG, "4", BOLD),\
- COLOR(FGBG, "5", BOLD),\
- COLOR(FGBG, "6", BOLD),\
- COLOR(FGBG, "7", BOLD)\
+#define ALLCOLORS(FGBG, BRIGHT, BOLD) \
+ { \
+ COLOR(FGBG, "0", BOLD), \
+ COLOR(FGBG, "1", BOLD), \
+ COLOR(FGBG, "2", BOLD), \
+ COLOR(FGBG, "3", BOLD), \
+ COLOR(FGBG, "4", BOLD), \
+ COLOR(FGBG, "5", BOLD), \
+ COLOR(FGBG, "6", BOLD), \
+ COLOR(FGBG, "7", BOLD), \
+ COLOR(BRIGHT, "0", BOLD), \
+ COLOR(BRIGHT, "1", BOLD), \
+ COLOR(BRIGHT, "2", BOLD), \
+ COLOR(BRIGHT, "3", BOLD), \
+ COLOR(BRIGHT, "4", BOLD), \
+ COLOR(BRIGHT, "5", BOLD), \
+ COLOR(BRIGHT, "6", BOLD), \
+ COLOR(BRIGHT, "7", BOLD), \
}
-static const char colorcodes[2][2][8][10] = {
- { ALLCOLORS("3",""), ALLCOLORS("3","1;") },
- { ALLCOLORS("4",""), ALLCOLORS("4","1;") }
+// bg
+// | bold
+// | |
+// | | codes
+// | | |
+// | | |
+static const char colorcodes[2][2][16][11] = {
+ { ALLCOLORS("3", "9", ""), ALLCOLORS("3", "9", "1;"),},
+ { ALLCOLORS("4", "10", ""), ALLCOLORS("4", "10", "1;")}
};
// A CMake option controls wheter we emit core dumps by default. An application
diff --git a/llvm/lib/Support/Unix/Process.inc b/llvm/lib/Support/Unix/Process.inc
index 551f0d7f0f029..f94eec6963c18 100644
--- a/llvm/lib/Support/Unix/Process.inc
+++ b/llvm/lib/Support/Unix/Process.inc
@@ -417,7 +417,7 @@ bool Process::ColorNeedsFlush() {
}
const char *Process::OutputColor(char code, bool bold, bool bg) {
- return colorcodes[bg ? 1 : 0][bold ? 1 : 0][code & 7];
+ return colorcodes[bg ? 1 : 0][bold ? 1 : 0][code & 15];
}
const char *Process::OutputBold(bool bg) { return "\033[1m"; }
diff --git a/llvm/lib/Support/Windows/Process.inc b/llvm/lib/Support/Windows/Process.inc
index a54c06d46870b..6b4b723d4744a 100644
--- a/llvm/lib/Support/Windows/Process.inc
+++ b/llvm/lib/Support/Windows/Process.inc
@@ -376,7 +376,7 @@ const char *Process::OutputBold(bool bg) {
const char *Process::OutputColor(char code, bool bold, bool bg) {
if (UseANSI)
- return colorcodes[bg ? 1 : 0][bold ? 1 : 0][code & 7];
+ return colorcodes[bg ? 1 : 0][bold ? 1 : 0][code & 15];
WORD current = DefaultColors::GetCurrentColor();
WORD colors;
>From b0ae1f285a05e7d137f697db317e566fe03cd9f2 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Timm=20B=C3=A4der?= <tbaeder at redhat.com>
Date: Sun, 28 Jan 2024 09:48:15 +0100
Subject: [PATCH 2/2] [clang][Interp] Support arbitrary precision constants
Add (de)serialization support for them, like we do for Floating values.
---
clang/lib/AST/Interp/ByteCodeEmitter.cpp | 37 ++++++++++++++++++++++++
clang/lib/AST/Interp/ByteCodeExprGen.cpp | 11 ++++---
clang/lib/AST/Interp/Disasm.cpp | 15 ++++++++++
clang/lib/AST/Interp/IntegralAP.h | 30 +++++++++++++++++++
clang/lib/AST/Interp/Interp.h | 16 ++++++++++
clang/lib/AST/Interp/Opcodes.td | 4 +++
clang/test/AST/Interp/intap.cpp | 14 +++++++++
7 files changed, 123 insertions(+), 4 deletions(-)
diff --git a/clang/lib/AST/Interp/ByteCodeEmitter.cpp b/clang/lib/AST/Interp/ByteCodeEmitter.cpp
index fd2a92d9d3f91..4f7ad51773a65 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"
@@ -228,6 +229,42 @@ 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 IntegralAP<false> &Val, bool &Success) {
+ size_t Size = Val.bytesToSerialize();
+
+ if (Code.size() + Size > std::numeric_limits<unsigned>::max()) {
+ Success = false;
+ return;
+ }
+
+ // Access must be aligned!
+ size_t ValPos = align(Code.size());
+ Size = align(Size);
+ assert(aligned(ValPos + Size));
+ Code.resize(ValPos + Size);
+ Val.serialize(Code.data() + ValPos);
+}
+
+template <>
+void emit(Program &P, std::vector<std::byte> &Code, const IntegralAP<true> &Val,
+ bool &Success) {
+ size_t Size = Val.bytesToSerialize();
+
+ if (Code.size() + Size > std::numeric_limits<unsigned>::max()) {
+ Success = false;
+ return;
+ }
+
+ // Access must be aligned!
+ size_t ValPos = align(Code.size());
+ Size = align(Size);
+ assert(aligned(ValPos + Size));
+ Code.resize(ValPos + Size);
+ Val.serialize(Code.data() + ValPos);
+}
+
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 d4501cefb2131..c2110834f64c0 100644
--- a/clang/lib/AST/Interp/ByteCodeExprGen.cpp
+++ b/clang/lib/AST/Interp/ByteCodeExprGen.cpp
@@ -2191,15 +2191,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;
}
@@ -2215,6 +2213,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);
+ else 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 65c54ed9c89b6..ec43481ebe6cf 100644
--- a/clang/lib/AST/Interp/Interp.h
+++ b/clang/lib/AST/Interp/Interp.h
@@ -2041,6 +2041,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 24747b6b98c16..b0fafb973dff4 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) {
More information about the cfe-commits
mailing list