This is an archive of the discontinued LLVM Phabricator instance.

Differential D58297

[Sema] SequenceChecker: C++17 sequencing rules for built-in operators <<, >>, .*, ->*, =, op=
ClosedPublic

Authored by riccibruno on Feb 15 2019, 11:41 AM.

Details

Reviewers
rsmith
rjmccall
aaron.ballman
Commits
rG7394c15178ed: [Sema] SequenceChecker: C++17 sequencing rules for built-in operators <<, >>, .
Summary

Implement the C++17 sequencing rules for the built-in operators <<, >>, .*, ->*, = and op=.

Diff Detail

Event Timeline

riccibruno created this revision.Feb 15 2019, 11:41 AM
Herald added subscribers: cfe-commits, jdoerfert. · View Herald TranscriptFeb 15 2019, 11:41 AM
riccibruno added a parent revision: D57747: [Sema] SequenceChecker: Fix handling of operator ||, && and ?:.Feb 15 2019, 11:42 AM
riccibruno updated this revision to Diff 187089.Feb 15 2019, 2:21 PM
  1. Only call note{Pre,Post}{Use, Mod} if we have a valid memory location.
  2. Fixed 2 tests in CXX/drs which I initially missed.
rsmith accepted this revision.Feb 15 2019, 2:55 PM
This revision is now accepted and ready to land.Feb 15 2019, 2:55 PM
riccibruno updated this revision to Diff 188046.Feb 23 2019, 6:36 AM

Rebased on D57660. No need to look at it.

riccibruno added a child revision: D58579: [Sema] SequenceChecker: C++17 sequencing rule for call expressions..Feb 23 2019, 9:45 AM
riccibruno updated this revision to Diff 216157.Aug 20 2019, 8:22 AM

Rebased

riccibruno updated this revision to Diff 234322.Dec 17 2019, 9:17 AM

Rebased on top of current master and D57747. No need to look at it.

riccibruno mentioned this in D58579: [Sema] SequenceChecker: C++17 sequencing rule for call expressions..Dec 17 2019, 9:20 AM
Closed by commit rG7394c15178ed: [Sema] SequenceChecker: C++17 sequencing rules for built-in operators <<, >>, . (authored by riccibruno). · Explain WhyDec 22 2019, 4:56 AM
This revision was automatically updated to reflect the committed changes.

Revision Contents

PathSize
clang/
lib/
Sema/
108 lines
test/
CXX/
drs/
10 lines
5 lines
SemaCXX/
89 lines

Diff 235045

clang/lib/Sema/SemaChecking.cpp

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 12,826 Lines • ▼ Show 20 Linespublic:
} }
void VisitArraySubscriptExpr(const ArraySubscriptExpr *ASE) { void VisitArraySubscriptExpr(const ArraySubscriptExpr *ASE) {
// C++17 [expr.sub]p1: // C++17 [expr.sub]p1:
// The expression E1[E2] is identical (by definition) to *((E1)+(E2)). The // The expression E1[E2] is identical (by definition) to *((E1)+(E2)). The
// expression E1 is sequenced before the expression E2. // expression E1 is sequenced before the expression E2.
if (SemaRef.getLangOpts().CPlusPlus17) if (SemaRef.getLangOpts().CPlusPlus17)
VisitSequencedExpressions(ASE->getLHS(), ASE->getRHS()); VisitSequencedExpressions(ASE->getLHS(), ASE->getRHS());
else else {
Base::VisitStmt(ASE); Visit(ASE->getLHS());
Visit(ASE->getRHS());
}
}
void VisitBinPtrMemD(const BinaryOperator *BO) { VisitBinPtrMem(BO); }
void VisitBinPtrMemI(const BinaryOperator *BO) { VisitBinPtrMem(BO); }
void VisitBinPtrMem(const BinaryOperator *BO) {
// C++17 [expr.mptr.oper]p4:
// Abbreviating pm-expression.*cast-expression as E1.*E2, [...]
// the expression E1 is sequenced before the expression E2.
if (SemaRef.getLangOpts().CPlusPlus17)
VisitSequencedExpressions(BO->getLHS(), BO->getRHS());
else {
Visit(BO->getLHS());
Visit(BO->getRHS());
}
}
void VisitBinShl(const BinaryOperator *BO) { VisitBinShlShr(BO); }
void VisitBinShr(const BinaryOperator *BO) { VisitBinShlShr(BO); }
void VisitBinShlShr(const BinaryOperator *BO) {
// C++17 [expr.shift]p4:
// The expression E1 is sequenced before the expression E2.
if (SemaRef.getLangOpts().CPlusPlus17)
VisitSequencedExpressions(BO->getLHS(), BO->getRHS());
else {
Visit(BO->getLHS());
Visit(BO->getRHS());
}
} }
void VisitBinComma(const BinaryOperator *BO) { void VisitBinComma(const BinaryOperator *BO) {
// C++11 [expr.comma]p1: // C++11 [expr.comma]p1:
// Every value computation and side effect associated with the left // Every value computation and side effect associated with the left
// expression is sequenced before every value computation and side // expression is sequenced before every value computation and side
// effect associated with the right expression. // effect associated with the right expression.
VisitSequencedExpressions(BO->getLHS(), BO->getRHS()); VisitSequencedExpressions(BO->getLHS(), BO->getRHS());
} }
void VisitBinAssign(const BinaryOperator *BO) { void VisitBinAssign(const BinaryOperator *BO) {
// The modification is sequenced after the value computation of the LHS SequenceTree::Seq RHSRegion;
// and RHS, so check it before inspecting the operands and update the SequenceTree::Seq LHSRegion;
// map afterwards. if (SemaRef.getLangOpts().CPlusPlus17) {
Object O = getObject(BO->getLHS(), true); RHSRegion = Tree.allocate(Region);
if (!O) LHSRegion = Tree.allocate(Region);
return VisitExpr(BO); } else {
RHSRegion = Region;
LHSRegion = Region;
}
SequenceTree::Seq OldRegion = Region;
// C++11 [expr.ass]p1:
// [...] the assignment is sequenced after the value computation
// of the right and left operands, [...]
//
// so check it before inspecting the operands and update the
// map afterwards.
Object O = getObject(BO->getLHS(), /*Mod=*/true);
if (O)
notePreMod(O, BO); notePreMod(O, BO);
// C++11 [expr.ass]p7: if (SemaRef.getLangOpts().CPlusPlus17) {
// E1 op= E2 is equivalent to E1 = E1 op E2, except that E1 is evaluated // C++17 [expr.ass]p1:
// only once. // [...] The right operand is sequenced before the left operand. [...]
// {
// Therefore, for a compound assignment operator, O is considered used SequencedSubexpression SeqBefore(*this);
// everywhere except within the evaluation of E1 itself. Region = RHSRegion;
if (isa<CompoundAssignOperator>(BO)) Visit(BO->getRHS());
notePreUse(O, BO); }
Region = LHSRegion;
Visit(BO->getLHS());
if (O && isa<CompoundAssignOperator>(BO))
notePostUse(O, BO);
} else {
// C++11 does not specify any sequencing between the LHS and RHS.
Region = LHSRegion;
Visit(BO->getLHS()); Visit(BO->getLHS());
if (isa<CompoundAssignOperator>(BO)) if (O && isa<CompoundAssignOperator>(BO))
notePostUse(O, BO); notePostUse(O, BO);
Region = RHSRegion;
Visit(BO->getRHS()); Visit(BO->getRHS());
}
// C++11 [expr.ass]p1: // C++11 [expr.ass]p1:
// the assignment is sequenced [...] before the value computation of the // the assignment is sequenced [...] before the value computation of the
// assignment expression. // assignment expression.
// C11 6.5.16/3 has no such rule. // C11 6.5.16/3 has no such rule.
Region = OldRegion;
if (O)
notePostMod(O, BO, notePostMod(O, BO,
SemaRef.getLangOpts().CPlusPlus ? UK_ModAsValue SemaRef.getLangOpts().CPlusPlus ? UK_ModAsValue
: UK_ModAsSideEffect); : UK_ModAsSideEffect);
if (SemaRef.getLangOpts().CPlusPlus17) {
Tree.merge(RHSRegion);
Tree.merge(LHSRegion);
}
} }
void VisitCompoundAssignOperator(const CompoundAssignOperator *CAO) { void VisitCompoundAssignOperator(const CompoundAssignOperator *CAO) {
VisitBinAssign(CAO); VisitBinAssign(CAO);
} }
void VisitUnaryPreInc(const UnaryOperator *UO) { VisitUnaryPreIncDec(UO); } void VisitUnaryPreInc(const UnaryOperator *UO) { VisitUnaryPreIncDec(UO); }
void VisitUnaryPreDec(const UnaryOperator *UO) { VisitUnaryPreIncDec(UO); } void VisitUnaryPreDec(const UnaryOperator *UO) { VisitUnaryPreIncDec(UO); }
▲ Show 20 Lines • Show All 2,012 Lines • Show Last 20 Lines

clang/test/CXX/drs/dr2xx.cpp

Show First 20 Lines • Show All 219 Lines • ▼ Show 20 Lines
namespace dr222 { // dr222: dup 637 namespace dr222 { // dr222: dup 637
void f(int a, int b, int c, int *x) { void f(int a, int b, int c, int *x) {
#pragma clang diagnostic push #pragma clang diagnostic push
#pragma clang diagnostic warning "-Wunsequenced" #pragma clang diagnostic warning "-Wunsequenced"
void((a += b) += c); void((a += b) += c);
void((a += b) + (a += c)); // expected-warning {{multiple unsequenced modifications to 'a'}} void((a += b) + (a += c)); // expected-warning {{multiple unsequenced modifications to 'a'}}
x[a++] = a; // expected-warning {{unsequenced modification and access to 'a'}} x[a++] = a;
#if __cplusplus < 201703L
// expected-warning@-2 {{unsequenced modification and access to 'a'}}
#endif
a = b = 0; // ok, read and write of 'b' are sequenced a = b = 0; // ok, read and write of 'b' are sequenced
a = (b = a++); // expected-warning {{multiple unsequenced modifications to 'a'}} a = (b = a++);
#if __cplusplus < 201703L
// expected-warning@-2 {{multiple unsequenced modifications to 'a'}}
#endif
a = (b = ++a); a = (b = ++a);
#pragma clang diagnostic pop #pragma clang diagnostic pop
} }
} }
// dr223: na // dr223: na
namespace dr224 { // dr224: no namespace dr224 { // dr224: no
▲ Show 20 Lines • Show All 843 Lines • Show Last 20 Lines

clang/test/CXX/drs/dr6xx.cpp

Show First 20 Lines • Show All 311 Lines • ▼ Show 20 Linesnamespace dr635 { // dr635: yes
template<typename T> D<T>::D() {} // expected-note {{previous}} template<typename T> D<T>::D() {} // expected-note {{previous}}
template<typename T> template<typename U> D<T>::D() {} template<typename T> template<typename U> D<T>::D() {}
template<typename T> D<T>::D<T>() {} // expected-error {{redefinition}} expected-error {{cannot have template arg}} template<typename T> D<T>::D<T>() {} // expected-error {{redefinition}} expected-error {{cannot have template arg}}
} }
namespace dr637 { // dr637: yes namespace dr637 { // dr637: yes
void f(int i) { void f(int i) {
i = ++i + 1; i = ++i + 1;
i = i++ + 1; // expected-warning {{unsequenced}} i = i++ + 1;
#if __cplusplus < 201703L
// expected-warning@-2 {{unsequenced}}
#endif
} }
} }
namespace dr638 { // dr638: no namespace dr638 { // dr638: no
template<typename T> struct A { template<typename T> struct A {
struct B; struct B;
void f(); void f();
void g(); void g();
▲ Show 20 Lines • Show All 828 Lines • Show Last 20 Lines

clang/test/SemaCXX/warn-unsequenced.cpp

Show All 20 Linesvoid test() {
int xs[10]; int xs[10];
++a = 0; // ok ++a = 0; // ok
a + ++a; // cxx11-warning {{unsequenced modification and access to 'a'}} a + ++a; // cxx11-warning {{unsequenced modification and access to 'a'}}
// cxx17-warning@-1 {{unsequenced modification and access to 'a'}} // cxx17-warning@-1 {{unsequenced modification and access to 'a'}}
a = ++a; // ok a = ++a; // ok
a + a++; // cxx11-warning {{unsequenced modification and access to 'a'}} a + a++; // cxx11-warning {{unsequenced modification and access to 'a'}}
// cxx17-warning@-1 {{unsequenced modification and access to 'a'}} // cxx17-warning@-1 {{unsequenced modification and access to 'a'}}
a = a++; // cxx11-warning {{multiple unsequenced modifications to 'a'}} a = a++; // cxx11-warning {{multiple unsequenced modifications to 'a'}}
// TODO cxx17-warning@-1 {{multiple unsequenced modifications to 'a'}}
++ ++a; // ok ++ ++a; // ok
(a++, a++); // ok (a++, a++); // ok
++a + ++a; // cxx11-warning {{multiple unsequenced modifications to 'a'}} ++a + ++a; // cxx11-warning {{multiple unsequenced modifications to 'a'}}
// cxx17-warning@-1 {{multiple unsequenced modifications to 'a'}} // cxx17-warning@-1 {{multiple unsequenced modifications to 'a'}}
a++ + a++; // cxx11-warning {{multiple unsequenced modifications to 'a'}} a++ + a++; // cxx11-warning {{multiple unsequenced modifications to 'a'}}
// cxx17-warning@-1 {{multiple unsequenced modifications to 'a'}} // cxx17-warning@-1 {{multiple unsequenced modifications to 'a'}}
(a++, a) = 0; // ok, increment is sequenced before value computation of LHS (a++, a) = 0; // ok, increment is sequenced before value computation of LHS
a = xs[++a]; // ok a = xs[++a]; // ok
a = xs[a++]; // cxx11-warning {{multiple unsequenced modifications to 'a'}} a = xs[a++]; // cxx11-warning {{multiple unsequenced modifications to 'a'}}
// TODO cxx17-warning@-1 {{multiple unsequenced modifications to 'a'}}
(a ? xs[0] : xs[1]) = ++a; // cxx11-warning {{unsequenced modification and access to 'a'}} (a ? xs[0] : xs[1]) = ++a; // cxx11-warning {{unsequenced modification and access to 'a'}}
// TODO cxx17-warning@-1 {{unsequenced modification and access to 'a'}}
a = (++a, ++a); // ok a = (++a, ++a); // ok
a = (a++, ++a); // ok a = (a++, ++a); // ok
a = (a++, a++); // cxx11-warning {{multiple unsequenced modifications to 'a'}} a = (a++, a++); // cxx11-warning {{multiple unsequenced modifications to 'a'}}
// TODO cxx17-warning@-1 {{multiple unsequenced modifications to 'a'}}
f(a, a); // ok f(a, a); // ok
f(a = 0, a); // cxx11-warning {{unsequenced modification and access to 'a'}} f(a = 0, a); // cxx11-warning {{unsequenced modification and access to 'a'}}
// cxx17-warning@-1 {{unsequenced modification and access to 'a'}} // cxx17-warning@-1 {{unsequenced modification and access to 'a'}}
f(a, a += 0); // cxx11-warning {{unsequenced modification and access to 'a'}} f(a, a += 0); // cxx11-warning {{unsequenced modification and access to 'a'}}
// cxx17-warning@-1 {{unsequenced modification and access to 'a'}} // cxx17-warning@-1 {{unsequenced modification and access to 'a'}}
f(a = 0, a = 0); // cxx11-warning {{multiple unsequenced modifications to 'a'}} f(a = 0, a = 0); // cxx11-warning {{multiple unsequenced modifications to 'a'}}
// cxx17-warning@-1 {{multiple unsequenced modifications to 'a'}} // cxx17-warning@-1 {{multiple unsequenced modifications to 'a'}}
a = f(++a); // ok a = f(++a); // ok
a = f(a++); // ok a = f(a++); // ok
a = f(++a, a++); // cxx11-warning {{multiple unsequenced modifications to 'a'}} a = f(++a, a++); // cxx11-warning {{multiple unsequenced modifications to 'a'}}
// cxx17-warning@-1 {{multiple unsequenced modifications to 'a'}} // cxx17-warning@-1 {{multiple unsequenced modifications to 'a'}}
// Compound assignment "A OP= B" is equivalent to "A = A OP B" except that A // Compound assignment "A OP= B" is equivalent to "A = A OP B" except that A
// is evaluated only once. // is evaluated only once.
(++a, a) = 1; // ok (++a, a) = 1; // ok
(++a, a) += 1; // ok (++a, a) += 1; // ok
a = ++a; // ok a = ++a; // ok
a += ++a; // cxx11-warning {{unsequenced modification and access to 'a'}} a += ++a; // cxx11-warning {{unsequenced modification and access to 'a'}}
// TODO cxx17-warning@-1 {{unsequenced modification and access to 'a'}}
A agg1 = { a++, a++ }; // ok A agg1 = { a++, a++ }; // ok
A agg2 = { a++ + a, a++ }; // cxx11-warning {{unsequenced modification and access to 'a'}} A agg2 = { a++ + a, a++ }; // cxx11-warning {{unsequenced modification and access to 'a'}}
// cxx17-warning@-1 {{unsequenced modification and access to 'a'}} // cxx17-warning@-1 {{unsequenced modification and access to 'a'}}
S str1(a++, a++); // cxx11-warning {{multiple unsequenced modifications to 'a'}} S str1(a++, a++); // cxx11-warning {{multiple unsequenced modifications to 'a'}}
// cxx17-warning@-1 {{multiple unsequenced modifications to 'a'}} // cxx17-warning@-1 {{multiple unsequenced modifications to 'a'}}
S str2 = { a++, a++ }; // ok S str2 = { a++, a++ }; // ok
S str3 = { a++ + a, a++ }; // cxx11-warning {{unsequenced modification and access to 'a'}} S str3 = { a++ + a, a++ }; // cxx11-warning {{unsequenced modification and access to 'a'}}
// cxx17-warning@-1 {{unsequenced modification and access to 'a'}} // cxx17-warning@-1 {{unsequenced modification and access to 'a'}}
struct Z { A a; S s; } z = { { ++a, ++a }, { ++a, ++a } }; // ok struct Z { A a; S s; } z = { { ++a, ++a }, { ++a, ++a } }; // ok
a = S { ++a, a++ }.n; // ok a = S { ++a, a++ }.n; // ok
A { ++a, a++ }.x; // ok A { ++a, a++ }.x; // ok
a = A { ++a, a++ }.x; // cxx11-warning {{multiple unsequenced modifications to 'a'}} a = A { ++a, a++ }.x; // cxx11-warning {{multiple unsequenced modifications to 'a'}}
// TODO cxx17-warning@-1 {{multiple unsequenced modifications to 'a'}}
A { ++a, a++ }.x + A { ++a, a++ }.y; // cxx11-warning {{multiple unsequenced modifications to 'a'}} A { ++a, a++ }.x + A { ++a, a++ }.y; // cxx11-warning {{multiple unsequenced modifications to 'a'}}
// cxx17-warning@-1 {{multiple unsequenced modifications to 'a'}} // cxx17-warning@-1 {{multiple unsequenced modifications to 'a'}}
(xs[2] && (a = 0)) + a; // cxx11-warning {{unsequenced modification and access to 'a'}} (xs[2] && (a = 0)) + a; // cxx11-warning {{unsequenced modification and access to 'a'}}
// cxx17-warning@-1 {{unsequenced modification and access to 'a'}} // cxx17-warning@-1 {{unsequenced modification and access to 'a'}}
(0 && (a = 0)) + a; // ok (0 && (a = 0)) + a; // ok
(1 && (a = 0)) + a; // cxx11-warning {{unsequenced modification and access to 'a'}} (1 && (a = 0)) + a; // cxx11-warning {{unsequenced modification and access to 'a'}}
// cxx17-warning@-1 {{unsequenced modification and access to 'a'}} // cxx17-warning@-1 {{unsequenced modification and access to 'a'}}
Show All 18 Linesvoid test() {
(++a, xs[6] ? ++a : 0) + a; // cxx11-warning {{unsequenced modification and access to 'a'}} (++a, xs[6] ? ++a : 0) + a; // cxx11-warning {{unsequenced modification and access to 'a'}}
// cxx17-warning@-1 {{unsequenced modification and access to 'a'}} // cxx17-warning@-1 {{unsequenced modification and access to 'a'}}
// Here, the read of the fourth 'a' might happen before or after the write to // Here, the read of the fourth 'a' might happen before or after the write to
// the second 'a'. // the second 'a'.
a += (a++, a) + a; // cxx11-warning {{unsequenced modification and access to 'a'}} a += (a++, a) + a; // cxx11-warning {{unsequenced modification and access to 'a'}}
// cxx17-warning@-1 {{unsequenced modification and access to 'a'}} // cxx17-warning@-1 {{unsequenced modification and access to 'a'}}
int *p = xs;
a = *(a++, p); // ok
a = a++ && a; // ok a = a++ && a; // ok
p[(long long unsigned)(p = 0)]; // cxx11-warning {{unsequenced modification and access to 'p'}}
A *q = &agg1; A *q = &agg1;
(q = &agg2)->y = q->x; // cxx11-warning {{unsequenced modification and access to 'q'}} (q = &agg2)->y = q->x; // cxx11-warning {{unsequenced modification and access to 'q'}}
// TODO cxx17-warning@-1 {{unsequenced modification and access to 'q'}}
// This has undefined behavior if a == 0; otherwise, the side-effect of the // This has undefined behavior if a == 0; otherwise, the side-effect of the
// increment is sequenced before the value computation of 'f(a, a)', which is // increment is sequenced before the value computation of 'f(a, a)', which is
// sequenced before the value computation of the '&&', which is sequenced // sequenced before the value computation of the '&&', which is sequenced
// before the assignment. We treat the sequencing in '&&' as being // before the assignment. We treat the sequencing in '&&' as being
// unconditional. // unconditional.
a = a++ && f(a, a); a = a++ && f(a, a);
Show All 11 Linesvoid test() {
xs[8] ? ++a + a++ : 0; // cxx11-warning {{multiple unsequenced modifications to 'a'}} xs[8] ? ++a + a++ : 0; // cxx11-warning {{multiple unsequenced modifications to 'a'}}
// cxx17-warning@-1 {{multiple unsequenced modifications to 'a'}} // cxx17-warning@-1 {{multiple unsequenced modifications to 'a'}}
xs[8] ? 0 : ++a + a++; // cxx11-warning {{multiple unsequenced modifications to 'a'}} xs[8] ? 0 : ++a + a++; // cxx11-warning {{multiple unsequenced modifications to 'a'}}
// cxx17-warning@-1 {{multiple unsequenced modifications to 'a'}} // cxx17-warning@-1 {{multiple unsequenced modifications to 'a'}}
xs[8] ? ++a : a++; // no-warning xs[8] ? ++a : a++; // no-warning
xs[8] ? a+=1 : a+= 2; // no-warning xs[8] ? a+=1 : a+= 2; // no-warning
(xs[8] ? a+=1 : a+= 2) = a; // cxx11-warning {{unsequenced modification and access to 'a'}} (xs[8] ? a+=1 : a+= 2) = a; // cxx11-warning {{unsequenced modification and access to 'a'}}
// TODO cxx17-warning@-1 {{unsequenced modification and access to 'a'}}
(xs[8] ? a+=1 : a) = a; // cxx11-warning {{unsequenced modification and access to 'a'}} (xs[8] ? a+=1 : a) = a; // cxx11-warning {{unsequenced modification and access to 'a'}}
// TODO cxx17-warning@-1 {{unsequenced modification and access to 'a'}}
(xs[8] ? a : a+= 2) = a; // cxx11-warning {{unsequenced modification and access to 'a'}} (xs[8] ? a : a+= 2) = a; // cxx11-warning {{unsequenced modification and access to 'a'}}
// TODO cxx17-warning@-1 {{unsequenced modification and access to 'a'}}
a = (xs[8] ? a+=1 : a+= 2); // no-warning a = (xs[8] ? a+=1 : a+= 2); // no-warning
a += (xs[8] ? a+=1 : a+= 2); // cxx11-warning {{unsequenced modification and access to 'a'}} a += (xs[8] ? a+=1 : a+= 2); // cxx11-warning {{unsequenced modification and access to 'a'}}
// TODO cxx17-warning@-1 {{unsequenced modification and access to 'a'}}
(false ? a+=1 : a) = a; // no-warning (false ? a+=1 : a) = a; // no-warning
(true ? a+=1 : a) = a; // cxx11-warning {{unsequenced modification and access to 'a'}} (true ? a+=1 : a) = a; // cxx11-warning {{unsequenced modification and access to 'a'}}
// TODO cxx17-warning@-1 {{unsequenced modification and access to 'a'}}
(false ? a : a+=2) = a; // cxx11-warning {{unsequenced modification and access to 'a'}} (false ? a : a+=2) = a; // cxx11-warning {{unsequenced modification and access to 'a'}}
// TODO cxx17-warning@-1 {{unsequenced modification and access to 'a'}}
(true ? a : a+=2) = a; // no-warning (true ? a : a+=2) = a; // no-warning
xs[8] && (++a + a++); // cxx11-warning {{multiple unsequenced modifications to 'a'}} xs[8] && (++a + a++); // cxx11-warning {{multiple unsequenced modifications to 'a'}}
// cxx17-warning@-1 {{multiple unsequenced modifications to 'a'}} // cxx17-warning@-1 {{multiple unsequenced modifications to 'a'}}
xs[8] || (++a + a++); // cxx11-warning {{multiple unsequenced modifications to 'a'}} xs[8] || (++a + a++); // cxx11-warning {{multiple unsequenced modifications to 'a'}}
// cxx17-warning@-1 {{multiple unsequenced modifications to 'a'}} // cxx17-warning@-1 {{multiple unsequenced modifications to 'a'}}
((a++, false) || (a++, false)); // no-warning PR39779 ((a++, false) || (a++, false)); // no-warning PR39779
((a++, true) && (a++, true)); // no-warning PR39779 ((a++, true) && (a++, true)); // no-warning PR39779
int i,j; int i,j;
(i = g1(), false) || (j = g2(i)); // no-warning PR22197 (i = g1(), false) || (j = g2(i)); // no-warning PR22197
(i = g1(), true) && (j = g2(i)); // no-warning PR22197 (i = g1(), true) && (j = g2(i)); // no-warning PR22197
(a++, false) || (a++, false) || (a++, false) || (a++, false); // no-warning (a++, false) || (a++, false) || (a++, false) || (a++, false); // no-warning
(a++, true) || (a++, true) || (a++, true) || (a++, true); // no-warning (a++, true) || (a++, true) || (a++, true) || (a++, true); // no-warning
a = ((a++, false) || (a++, false) || (a++, false) || (a++, false)); // no-warning a = ((a++, false) || (a++, false) || (a++, false) || (a++, false)); // no-warning
a = ((a++, true) && (a++, true) && (a++, true) && (a++, true)); // no-warning a = ((a++, true) && (a++, true) && (a++, true) && (a++, true)); // no-warning
a = ((a++, false) || (a++, false) || (a++, false) || a++); // cxx11-warning {{multiple unsequenced modifications to 'a'}} a = ((a++, false) || (a++, false) || (a++, false) || a++); // cxx11-warning {{multiple unsequenced modifications to 'a'}}
// TODO cxx17-warning@-1 {{multiple unsequenced modifications to 'a'}}
a = ((a++, true) && (a++, true) && (a++, true) && a++); // cxx11-warning {{multiple unsequenced modifications to 'a'}} a = ((a++, true) && (a++, true) && (a++, true) && a++); // cxx11-warning {{multiple unsequenced modifications to 'a'}}
// TODO cxx17-warning@-1 {{multiple unsequenced modifications to 'a'}}
a = ((a++, false) || (a++, false) || (a++, false) || (a + a, false)); // no-warning a = ((a++, false) || (a++, false) || (a++, false) || (a + a, false)); // no-warning
a = ((a++, true) && (a++, true) && (a++, true) && (a + a, true)); // no-warning a = ((a++, true) && (a++, true) && (a++, true) && (a + a, true)); // no-warning
a = (false && a++); // no-warning a = (false && a++); // no-warning
a = (true && a++); // cxx11-warning {{multiple unsequenced modifications to 'a'}} a = (true && a++); // cxx11-warning {{multiple unsequenced modifications to 'a'}}
// TODO cxx17-warning@-1 {{multiple unsequenced modifications to 'a'}}
a = (true && ++a); // no-warning a = (true && ++a); // no-warning
a = (true || a++); // no-warning a = (true || a++); // no-warning
a = (false || a++); // cxx11-warning {{multiple unsequenced modifications to 'a'}} a = (false || a++); // cxx11-warning {{multiple unsequenced modifications to 'a'}}
// TODO cxx17-warning@-1 {{multiple unsequenced modifications to 'a'}}
a = (false || ++a); // no-warning a = (false || ++a); // no-warning
(a++) | (a++); // cxx11-warning {{multiple unsequenced modifications to 'a'}} (a++) | (a++); // cxx11-warning {{multiple unsequenced modifications to 'a'}}
// cxx17-warning@-1 {{multiple unsequenced modifications to 'a'}} // cxx17-warning@-1 {{multiple unsequenced modifications to 'a'}}
(a++) & (a++); // cxx11-warning {{multiple unsequenced modifications to 'a'}} (a++) & (a++); // cxx11-warning {{multiple unsequenced modifications to 'a'}}
// cxx17-warning@-1 {{multiple unsequenced modifications to 'a'}} // cxx17-warning@-1 {{multiple unsequenced modifications to 'a'}}
(a++) ^ (a++); // cxx11-warning {{multiple unsequenced modifications to 'a'}} (a++) ^ (a++); // cxx11-warning {{multiple unsequenced modifications to 'a'}}
// cxx17-warning@-1 {{multiple unsequenced modifications to 'a'}} // cxx17-warning@-1 {{multiple unsequenced modifications to 'a'}}
(__builtin_classify_type(++a) ? 1 : 0) + ++a; // ok (__builtin_classify_type(++a) ? 1 : 0) + ++a; // ok
(__builtin_constant_p(++a) ? 1 : 0) + ++a; // ok (__builtin_constant_p(++a) ? 1 : 0) + ++a; // ok
(__builtin_object_size(&(++a, a), 0) ? 1 : 0) + ++a; // ok (__builtin_object_size(&(++a, a), 0) ? 1 : 0) + ++a; // ok
(__builtin_expect(++a, 0) ? 1 : 0) + ++a; // cxx11-warning {{multiple unsequenced modifications to 'a'}} (__builtin_expect(++a, 0) ? 1 : 0) + ++a; // cxx11-warning {{multiple unsequenced modifications to 'a'}}
// cxx17-warning@-1 {{multiple unsequenced modifications to 'a'}} // cxx17-warning@-1 {{multiple unsequenced modifications to 'a'}}
int *p = xs;
a = *(a++, p); // no-warning
p[(long long unsigned)(p = 0)]; // cxx11-warning {{unsequenced modification and access to 'p'}}
(i++, xs)[i++]; // cxx11-warning {{multiple unsequenced modifications to 'i'}}
(++i, xs)[++i]; // cxx11-warning {{multiple unsequenced modifications to 'i'}}
(i, xs)[++i + ++i]; // cxx11-warning {{multiple unsequenced modifications to 'i'}}
// cxx17-warning@-1 {{multiple unsequenced modifications to 'i'}}
p++[p == xs]; // cxx11-warning {{unsequenced modification and access to 'p'}}
++p[p++ == xs]; // cxx11-warning {{unsequenced modification and access to 'p'}}
struct S { int x; } s, *ps = &s;
int (S::*PtrMem);
(PtrMem = &S::x ,s).*(PtrMem); // cxx11-warning {{unsequenced modification and access to 'PtrMem'}}
(PtrMem = &S::x ,s).*(PtrMem = &S::x); // cxx11-warning {{multiple unsequenced modifications to 'PtrMem'}}
(PtrMem = &S::x ,ps)->*(PtrMem); // cxx11-warning {{unsequenced modification and access to 'PtrMem'}}
(PtrMem = &S::x ,ps)->*(PtrMem = &S::x); // cxx11-warning {{multiple unsequenced modifications to 'PtrMem'}}
(PtrMem = nullptr) == (PtrMem = nullptr); // cxx11-warning {{multiple unsequenced modifications to 'PtrMem'}}
// cxx17-warning@-1 {{multiple unsequenced modifications to 'PtrMem'}}
(PtrMem = nullptr) == PtrMem; // cxx11-warning {{unsequenced modification and access to 'PtrMem'}}
// cxx17-warning@-1 {{unsequenced modification and access to 'PtrMem'}}
i++ << i++; // cxx11-warning {{multiple unsequenced modifications to 'i'}}
++i << ++i; // cxx11-warning {{multiple unsequenced modifications to 'i'}}
i++ << i; // cxx11-warning {{unsequenced modification and access to 'i'}}
i << i++; // cxx11-warning {{unsequenced modification and access to 'i'}}
i++ >> i++; // cxx11-warning {{multiple unsequenced modifications to 'i'}}
++i >> ++i; // cxx11-warning {{multiple unsequenced modifications to 'i'}}
i++ >> i; // cxx11-warning {{unsequenced modification and access to 'i'}}
i >> i++; // cxx11-warning {{unsequenced modification and access to 'i'}}
(i++ << i) + i; // cxx11-warning {{unsequenced modification and access to 'i'}}
// cxx17-warning@-1 {{unsequenced modification and access to 'i'}}
(i++ << i) << i++; // cxx11-warning {{unsequenced modification and access to 'i'}}
++i = i++; // cxx11-warning {{multiple unsequenced modifications to 'i'}}
i = i+= 1; // no-warning
i = i++ + ++i; // cxx11-warning {{multiple unsequenced modifications to 'i'}}
// cxx17-warning@-1 {{multiple unsequenced modifications to 'i'}}
++i += ++i; // cxx11-warning {{multiple unsequenced modifications to 'i'}}
++i += i++; // cxx11-warning {{multiple unsequenced modifications to 'i'}}
(i++, i) += ++i; // cxx11-warning {{multiple unsequenced modifications to 'i'}}
(i++, i) += i++; // cxx11-warning {{multiple unsequenced modifications to 'i'}}
i += i+= 1; // cxx11-warning {{unsequenced modification and access to 'i'}}
i += i++; // cxx11-warning {{unsequenced modification and access to 'i'}}
i += ++i; // cxx11-warning {{unsequenced modification and access to 'i'}}
i -= i++; // cxx11-warning {{unsequenced modification and access to 'i'}}
i -= ++i; // cxx11-warning {{unsequenced modification and access to 'i'}}
i *= i++; // cxx11-warning {{unsequenced modification and access to 'i'}}
i *= ++i; // cxx11-warning {{unsequenced modification and access to 'i'}}
i /= i++; // cxx11-warning {{unsequenced modification and access to 'i'}}
i /= ++i; // cxx11-warning {{unsequenced modification and access to 'i'}}
i %= i++; // cxx11-warning {{unsequenced modification and access to 'i'}}
i %= ++i; // cxx11-warning {{unsequenced modification and access to 'i'}}
i ^= i++; // cxx11-warning {{unsequenced modification and access to 'i'}}
i ^= ++i; // cxx11-warning {{unsequenced modification and access to 'i'}}
i |= i++; // cxx11-warning {{unsequenced modification and access to 'i'}}
i |= ++i; // cxx11-warning {{unsequenced modification and access to 'i'}}
i &= i++; // cxx11-warning {{unsequenced modification and access to 'i'}}
i &= ++i; // cxx11-warning {{unsequenced modification and access to 'i'}}
i <<= i++; // cxx11-warning {{unsequenced modification and access to 'i'}}
i <<= ++i; // cxx11-warning {{unsequenced modification and access to 'i'}}
i >>= i++; // cxx11-warning {{unsequenced modification and access to 'i'}}
i >>= ++i; // cxx11-warning {{unsequenced modification and access to 'i'}}
p[i++] = i; // cxx11-warning {{unsequenced modification and access to 'i'}}
p[i++] = (i = 42); // cxx11-warning {{multiple unsequenced modifications to 'i'}}
p++[i++] = (i = p ? i++ : i++); // cxx11-warning {{unsequenced modification and access to 'p'}}
// cxx11-warning@-1 {{multiple unsequenced modifications to 'i'}}
} }
namespace members { namespace members {
struct S1 { struct S1 {
unsigned bf1 : 2; unsigned bf1 : 2;
unsigned bf2 : 2; unsigned bf2 : 2;
unsigned a; unsigned a;
▲ Show 20 Lines • Show All 366 Lines • Show Last 20 Lines