justinstitt updated this revision to Diff 450964.
justinstitt added a comment.
update commit message
Repository:
rG LLVM Github Monorepo
CHANGES SINCE LAST ACTION
https://reviews.llvm.org/D131416/new/
https://reviews.llvm.org/D131416
Files:
clang/include/clang/AST/Expr.h
clang/lib/AST/ExprConstant.cpp
Index: clang/lib/AST/ExprConstant.cpp
===================================================================
--- clang/lib/AST/ExprConstant.cpp
+++ clang/lib/AST/ExprConstant.cpp
@@ -15285,17 +15285,6 @@
namespace {
-enum ICEKind {
- /// This expression is an ICE.
- IK_ICE,
- /// This expression is not an ICE, but if it isn't evaluated, it's
- /// a legal subexpression for an ICE. This return value is used to handle
- /// the comma operator in C99 mode, and non-constant subexpressions.
- IK_ICEIfUnevaluated,
- /// This expression is not an ICE, and is not a legal subexpression for one.
- IK_NotICE
-};
-
struct ICEDiag {
ICEKind Kind;
SourceLocation Loc;
@@ -15533,7 +15522,10 @@
return NoDiag();
}
case Expr::BinaryOperatorClass: {
- const BinaryOperator *Exp = cast<BinaryOperator>(E);
+ BinaryOperator *Exp = const_cast<BinaryOperator*>(cast<BinaryOperator>(E));
+ if (auto Result = Exp->getICEKind())
+ return ICEDiag(*Result, E->getBeginLoc());
+
switch (Exp->getOpcode()) {
case BO_PtrMemD:
case BO_PtrMemI:
@@ -15551,6 +15543,7 @@
// C99 6.6/3 allows assignments within unevaluated subexpressions of
// constant expressions, but they can never be ICEs because an ICE cannot
// contain an lvalue operand.
+ Exp->setICEKind(IK_NotICE);
return ICEDiag(IK_NotICE, E->getBeginLoc());
case BO_Mul:
@@ -15579,12 +15572,16 @@
// we don't evaluate one.
if (LHSResult.Kind == IK_ICE && RHSResult.Kind == IK_ICE) {
llvm::APSInt REval = Exp->getRHS()->EvaluateKnownConstInt(Ctx);
- if (REval == 0)
+ if (REval == 0) {
+ Exp->setICEKind(IK_ICEIfUnevaluated);
return ICEDiag(IK_ICEIfUnevaluated, E->getBeginLoc());
+ }
if (REval.isSigned() && REval.isAllOnes()) {
llvm::APSInt LEval = Exp->getLHS()->EvaluateKnownConstInt(Ctx);
- if (LEval.isMinSignedValue())
+ if (LEval.isMinSignedValue()) {
+ Exp->setICEKind(IK_ICEIfUnevaluated);
return ICEDiag(IK_ICEIfUnevaluated, E->getBeginLoc());
+ }
}
}
}
@@ -15592,14 +15589,19 @@
if (Ctx.getLangOpts().C99) {
// C99 6.6p3 introduces a strange edge case: comma can be in an ICE
// if it isn't evaluated.
- if (LHSResult.Kind == IK_ICE && RHSResult.Kind == IK_ICE)
+ if (LHSResult.Kind == IK_ICE && RHSResult.Kind == IK_ICE) {
+ Exp->setICEKind(IK_ICEIfUnevaluated);
return ICEDiag(IK_ICEIfUnevaluated, E->getBeginLoc());
+ }
} else {
// In both C89 and C++, commas in ICEs are illegal.
+ Exp->setICEKind(IK_NotICE);
return ICEDiag(IK_NotICE, E->getBeginLoc());
}
}
- return Worst(LHSResult, RHSResult);
+ ICEDiag D = Worst(LHSResult, RHSResult);
+ Exp->setICEKind(D.Kind);
+ return D;
}
case BO_LAnd:
case BO_LOr: {
@@ -15610,12 +15612,16 @@
// to actually check the condition to see whether the side
// with the comma is evaluated.
if ((Exp->getOpcode() == BO_LAnd) !=
- (Exp->getLHS()->EvaluateKnownConstInt(Ctx) == 0))
+ (Exp->getLHS()->EvaluateKnownConstInt(Ctx) == 0)) {
+ Exp->setICEKind(RHSResult.Kind);
return RHSResult;
+ }
+ Exp->setICEKind(RHSResult.Kind);
return NoDiag();
}
-
- return Worst(LHSResult, RHSResult);
+ ICEDiag WorstResult = Worst(LHSResult, RHSResult);
+ Exp->setICEKind(WorstResult.Kind);
+ return WorstResult;
}
}
llvm_unreachable("invalid binary operator kind");
Index: clang/include/clang/AST/Expr.h
===================================================================
--- clang/include/clang/AST/Expr.h
+++ clang/include/clang/AST/Expr.h
@@ -29,6 +29,8 @@
#include "clang/Basic/TypeTraits.h"
#include "llvm/ADT/APFloat.h"
#include "llvm/ADT/APSInt.h"
+#include "llvm/ADT/None.h"
+#include "llvm/ADT/Optional.h"
#include "llvm/ADT/SmallVector.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/ADT/iterator.h"
@@ -3786,6 +3788,21 @@
friend class CastExpr;
};
+namespace {
+
+enum ICEKind {
+ /// This expression is an ICE.
+ IK_ICE,
+ /// This expression is not an ICE, but if it isn't evaluated, it's
+ /// a legal subexpression for an ICE. This return value is used to handle
+ /// the comma operator in C99 mode, and non-constant subexpressions.
+ IK_ICEIfUnevaluated,
+ /// This expression is not an ICE, and is not a legal subexpression for one.
+ IK_NotICE,
+};
+
+}
+
/// A builtin binary operation expression such as "x + y" or "x <= y".
///
/// This expression node kind describes a builtin binary operation,
@@ -3807,10 +3824,18 @@
class BinaryOperator : public Expr {
enum { LHS, RHS, END_EXPR };
Stmt *SubExprs[END_EXPR];
+ llvm::Optional<ICEKind> IK = llvm::None;
public:
typedef BinaryOperatorKind Opcode;
+ llvm::Optional<ICEKind> getICEKind() const { return IK; }
+
+ void setICEKind(ICEKind ik) {
+ assert(!IK && "ICEKind is already set.");
+ IK = ik;
+ }
+
protected:
size_t offsetOfTrailingStorage() const;
_______________________________________________
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
