[clang] 7348bb3 - [clang][Interp] Support inc/dec operators for pointers
Timm Bäder via cfe-commits
cfe-commits at lists.llvm.org
Wed Jan 25 03:17:42 PST 2023
Author: Timm Bäder
Date: 2023-01-25T11:57:05+01:00
New Revision: 7348bb36c5570e718469f043504e80491bb7f12b
URL: https://github.com/llvm/llvm-project/commit/7348bb36c5570e718469f043504e80491bb7f12b
DIFF: https://github.com/llvm/llvm-project/commit/7348bb36c5570e718469f043504e80491bb7f12b.diff
LOG: [clang][Interp] Support inc/dec operators for pointers
Differential Revision: https://reviews.llvm.org/D137232
Added:
Modified:
clang/lib/AST/Interp/ByteCodeExprGen.cpp
clang/lib/AST/Interp/Interp.h
clang/lib/AST/Interp/Opcodes.td
clang/test/AST/Interp/arrays.cpp
Removed:
################################################################################
diff --git a/clang/lib/AST/Interp/ByteCodeExprGen.cpp b/clang/lib/AST/Interp/ByteCodeExprGen.cpp
index fa2c74c4e1a5..dd7d88ae715d 100644
--- a/clang/lib/AST/Interp/ByteCodeExprGen.cpp
+++ b/clang/lib/AST/Interp/ByteCodeExprGen.cpp
@@ -1333,24 +1333,44 @@ bool ByteCodeExprGen<Emitter>::VisitUnaryOperator(const UnaryOperator *E) {
const Expr *SubExpr = E->getSubExpr();
std::optional<PrimType> T = classify(SubExpr->getType());
- // TODO: Support pointers for inc/dec operators.
switch (E->getOpcode()) {
case UO_PostInc: { // x++
if (!this->visit(SubExpr))
return false;
+ if (T == PT_Ptr) {
+ if (!this->emitIncPtr(E))
+ return false;
+
+ return DiscardResult ? this->emitPopPtr(E) : true;
+ }
+
return DiscardResult ? this->emitIncPop(*T, E) : this->emitInc(*T, E);
}
case UO_PostDec: { // x--
if (!this->visit(SubExpr))
return false;
+ if (T == PT_Ptr) {
+ if (!this->emitDecPtr(E))
+ return false;
+
+ return DiscardResult ? this->emitPopPtr(E) : true;
+ }
+
return DiscardResult ? this->emitDecPop(*T, E) : this->emitDec(*T, E);
}
case UO_PreInc: { // ++x
if (!this->visit(SubExpr))
return false;
+ if (T == PT_Ptr) {
+ this->emitLoadPtr(E);
+ this->emitConstUint8(1, E);
+ this->emitAddOffsetUint8(E);
+ return DiscardResult ? this->emitStorePopPtr(E) : this->emitStorePtr(E);
+ }
+
// Post-inc and pre-inc are the same if the value is to be discarded.
if (DiscardResult)
return this->emitIncPop(*T, E);
@@ -1364,6 +1384,13 @@ bool ByteCodeExprGen<Emitter>::VisitUnaryOperator(const UnaryOperator *E) {
if (!this->visit(SubExpr))
return false;
+ if (T == PT_Ptr) {
+ this->emitLoadPtr(E);
+ this->emitConstUint8(1, E);
+ this->emitSubOffsetUint8(E);
+ return DiscardResult ? this->emitStorePopPtr(E) : this->emitStorePtr(E);
+ }
+
// Post-dec and pre-dec are the same if the value is to be discarded.
if (DiscardResult)
return this->emitDecPop(*T, E);
diff --git a/clang/lib/AST/Interp/Interp.h b/clang/lib/AST/Interp/Interp.h
index ed3accd98a90..9433652f1526 100644
--- a/clang/lib/AST/Interp/Interp.h
+++ b/clang/lib/AST/Interp/Interp.h
@@ -140,6 +140,8 @@ bool CheckDivRem(InterpState &S, CodePtr OpPC, const T &LHS, const T &RHS) {
/// Interpreter entry point.
bool Interpret(InterpState &S, APValue &Result);
+enum class ArithOp { Add, Sub };
+
//===----------------------------------------------------------------------===//
// Add, Sub, Mul
//===----------------------------------------------------------------------===//
@@ -1112,6 +1114,34 @@ bool SubOffset(InterpState &S, CodePtr OpPC) {
return OffsetHelper<T, false>(S, OpPC);
}
+template <ArithOp Op>
+static inline bool IncDecPtrHelper(InterpState &S, CodePtr OpPC) {
+ using OneT = Integral<8, false>;
+ const Pointer &Ptr = S.Stk.pop<Pointer>();
+
+ // Get the current value on the stack.
+ S.Stk.push<Pointer>(Ptr.deref<Pointer>());
+
+ // Now the current Ptr again and a constant 1.
+ // FIXME: We shouldn't have to push these two on the stack.
+ S.Stk.push<Pointer>(Ptr.deref<Pointer>());
+ S.Stk.push<OneT>(OneT::from(1));
+ if (!OffsetHelper<OneT, Op == ArithOp::Add>(S, OpPC))
+ return false;
+
+ // Store the new value.
+ Ptr.deref<Pointer>() = S.Stk.pop<Pointer>();
+ return true;
+}
+
+static inline bool IncPtr(InterpState &S, CodePtr OpPC) {
+ return IncDecPtrHelper<ArithOp::Add>(S, OpPC);
+}
+
+static inline bool DecPtr(InterpState &S, CodePtr OpPC) {
+ return IncDecPtrHelper<ArithOp::Sub>(S, OpPC);
+}
+
/// 1) Pops a Pointer from the stack.
/// 2) Pops another Pointer from the stack.
/// 3) Pushes the
diff erent of the indices of the two pointers on the stack.
diff --git a/clang/lib/AST/Interp/Opcodes.td b/clang/lib/AST/Interp/Opcodes.td
index 058475b2d399..07facb6a6024 100644
--- a/clang/lib/AST/Interp/Opcodes.td
+++ b/clang/lib/AST/Interp/Opcodes.td
@@ -393,12 +393,21 @@ def AddOffset : AluOpcode;
// [Pointer, Integral] -> [Pointer]
def SubOffset : AluOpcode;
-// Pointer, Pointer] - [Integral]
+// [Pointer, Pointer] -> [Integral]
def SubPtr : Opcode {
let Types = [IntegerTypeClass];
let HasGroup = 1;
}
+// [Pointer] -> [Pointer]
+def IncPtr : Opcode {
+ let HasGroup = 0;
+}
+// [Pointer] -> [Pointer]
+def DecPtr : Opcode {
+ let HasGroup = 0;
+}
+
//===----------------------------------------------------------------------===//
// Binary operators.
//===----------------------------------------------------------------------===//
diff --git a/clang/test/AST/Interp/arrays.cpp b/clang/test/AST/Interp/arrays.cpp
index 3c0eaefeb796..accef60e38d6 100644
--- a/clang/test/AST/Interp/arrays.cpp
+++ b/clang/test/AST/Interp/arrays.cpp
@@ -235,9 +235,6 @@ constexpr BU bu; // expected-error {{must be initialized by a constant expressio
// ref-note {{in call to 'BU()'}}
namespace IncDec {
- // FIXME: Pointer arithmethic needs to be supported in inc/dec
- // unary operators
-#if 0
constexpr int getNextElem(const int *A, int I) {
const int *B = (A + I);
++B;
@@ -245,6 +242,91 @@ namespace IncDec {
}
constexpr int E[] = {1,2,3,4};
- static_assert(getNextElem(E, 1) == 3);
-#endif
+ static_assert(getNextElem(E, 1) == 3, "");
+
+ constexpr int getFirst() {
+ const int *e = E;
+ return *(e++);
+ }
+ static_assert(getFirst() == 1, "");
+
+ constexpr int getFirst2() {
+ const int *e = E;
+ e++;
+ return *e;
+ }
+ static_assert(getFirst2() == 2, "");
+
+ constexpr int getSecond() {
+ const int *e = E;
+ return *(++e);
+ }
+ static_assert(getSecond() == 2, "");
+
+ constexpr int getSecond2() {
+ const int *e = E;
+ ++e;
+ return *e;
+ }
+ static_assert(getSecond2() == 2, "");
+
+ constexpr int getLast() {
+ const int *e = E + 3;
+ return *(e--);
+ }
+ static_assert(getLast() == 4, "");
+
+ constexpr int getLast2() {
+ const int *e = E + 3;
+ e--;
+ return *e;
+ }
+ static_assert(getLast2() == 3, "");
+
+ constexpr int getSecondToLast() {
+ const int *e = E + 3;
+ return *(--e);
+ }
+ static_assert(getSecondToLast() == 3, "");
+
+ constexpr int getSecondToLast2() {
+ const int *e = E + 3;
+ --e;
+ return *e;
+ }
+ static_assert(getSecondToLast2() == 3, "");
+
+ constexpr int bad1() { // ref-error {{never produces a constant expression}}
+ const int *e = E + 3;
+ e++; // This is fine because it's a one-past-the-end pointer
+ return *e; // expected-note {{read of dereferenced one-past-the-end pointer}} \
+ // ref-note 2{{read of dereferenced one-past-the-end pointer}}
+ }
+ static_assert(bad1() == 0, ""); // expected-error {{not an integral constant expression}} \
+ // expected-note {{in call to}} \
+ // ref-error {{not an integral constant expression}} \
+ // ref-note {{in call to}}
+
+ constexpr int bad2() { // ref-error {{never produces a constant expression}}
+ const int *e = E + 4;
+ e++; // expected-note {{cannot refer to element 5 of array of 4 elements}} \
+ // ref-note 2{{cannot refer to element 5 of array of 4 elements}}
+ return *e; // This is UB as well
+ }
+ static_assert(bad2() == 0, ""); // expected-error {{not an integral constant expression}} \
+ // expected-note {{in call to}} \
+ // ref-error {{not an integral constant expression}} \
+ // ref-note {{in call to}}
+
+
+ constexpr int bad3() { // ref-error {{never produces a constant expression}}
+ const int *e = E;
+ e--; // expected-note {{cannot refer to element -1 of array of 4 elements}} \
+ // ref-note 2{{cannot refer to element -1 of array of 4 elements}}
+ return *e; // This is UB as well
+ }
+ static_assert(bad3() == 0, ""); // expected-error {{not an integral constant expression}} \
+ // expected-note {{in call to}} \
+ // ref-error {{not an integral constant expression}} \
+ // ref-note {{in call to}}
};
More information about the cfe-commits
mailing list