replica
/
hanchenye-llvm-project
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Revert "[AST] Introduce GenericSelectionExpr::Association" 

This breaks GCC 4.8.4. Reported by email by Hans Wennborg.

llvm-svn: 352403
This commit is contained in:
Bruno Ricci 2019-01-28 18:40:26 +00:00
parent 7db82d7257
commit 586d949b9c
9 changed files with 49 additions and 167 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

134
clang/include/clang/AST/Expr.h
View File

@ -28,8 +28,6 @@
#include "clang/Basic/TypeTraits.h"
#include "llvm/ADT/APFloat.h"
#include "llvm/ADT/APSInt.h"
#include "llvm/ADT/iterator.h"
#include "llvm/ADT/iterator_range.h"
#include "llvm/ADT/SmallVector.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/Support/AtomicOrdering.h"
@ -5054,86 +5052,6 @@ class GenericSelectionExpr final
return getNumAssocs();
}
template <bool Const> class AssociationIteratorTy;
/// Bundle together an association expression and its TypeSourceInfo.
/// The Const template parameter is for the const and non-const versions
/// of AssociationTy.
template <bool Const> class AssociationTy {
friend class GenericSelectionExpr;
template <bool OtherConst> friend class AssociationIteratorTy;
using ExprPtrTy =
typename std::conditional<Const, const Expr *, Expr *>::type;
using TSIPtrTy = typename std::conditional<Const, const TypeSourceInfo *,
TypeSourceInfo *>::type;
ExprPtrTy E;
TSIPtrTy TSI;
bool Selected;
AssociationTy(ExprPtrTy E, TSIPtrTy TSI, bool Selected)
: E(E), TSI(TSI), Selected(Selected) {}
public:
ExprPtrTy getAssociationExpr() const { return E; }
TSIPtrTy getTypeSourceInfo() const { return TSI; }
QualType getType() const { return TSI ? TSI->getType() : QualType(); }
bool isSelected() const { return Selected; }
AssociationTy *operator->() { return this; }
const AssociationTy *operator->() const { return this; }
}; // class AssociationTy
/// Iterator over const and non-const Association objects. The Association
/// objects are created on the fly when the iterator is dereferenced.
/// This abstract over how exactly the association expressions and the
/// corresponding TypeSourceInfo * are stored.
template <bool Const>
class AssociationIteratorTy
: public llvm::iterator_facade_base<
AssociationIteratorTy<Const>, std::input_iterator_tag,
AssociationTy<Const>, std::ptrdiff_t, AssociationTy<Const>,
AssociationTy<Const>> {
friend class GenericSelectionExpr;
// FIXME: This iterator could conceptually be a random access iterator, and
// it would be nice if we could strengthen the iterator category someday.
// However this iterator does not satisfy two requirements of forward
// iterators:
// a) reference = T& or reference = const T&
// b) If It1 and It2 are both dereferenceable, then It1 == It2 if and only
// if *It1 and *It2 are bound to the same objects.
// An alternative design approach was discussed during review;
// store an Association object inside the iterator, and return a reference
// to it when dereferenced. This idea was discarded beacuse of nasty
// lifetime issues:
// AssociationIterator It = ...;
// const Association &Assoc = *It++; // Oops, Assoc is dangling.
using BaseTy = typename AssociationIteratorTy::iterator_facade_base;
using StmtPtrPtrTy =
typename std::conditional<Const, const Stmt *const *, Stmt **>::type;
using TSIPtrPtrTy =
typename std::conditional<Const, const TypeSourceInfo *const *,
TypeSourceInfo **>::type;
StmtPtrPtrTy E = nullptr;
TSIPtrPtrTy TSI = nullptr; // Kept in sync with E.
unsigned Offset = 0, SelectedOffset = 0;
AssociationIteratorTy(StmtPtrPtrTy E, TSIPtrPtrTy TSI, unsigned Offset,
unsigned SelectedOffset)
: E(E), TSI(TSI), Offset(Offset), SelectedOffset(SelectedOffset) {}
public:
AssociationIteratorTy() = default;
typename BaseTy::reference operator*() const {
return AssociationTy<Const>(cast<Expr>(*E), *TSI,
Offset == SelectedOffset);
}
typename BaseTy::pointer operator->() const { return **this; }
using BaseTy::operator++;
AssociationIteratorTy &operator++() {
++E;
++TSI;
++Offset;
return *this;
}
bool operator==(AssociationIteratorTy Other) const { return E == Other.E; }
}; // class AssociationIterator
/// Build a non-result-dependent generic selection expression.
GenericSelectionExpr(const ASTContext &Context, SourceLocation GenericLoc,
Expr *ControllingExpr,
@ -5174,14 +5092,6 @@ public:
static GenericSelectionExpr *CreateEmpty(const ASTContext &Context,
unsigned NumAssocs);
using Association = AssociationTy<false>;
using ConstAssociation = AssociationTy<true>;
using AssociationIterator = AssociationIteratorTy<false>;
using ConstAssociationIterator = AssociationIteratorTy<true>;
using association_range = llvm::iterator_range<AssociationIterator>;
using const_association_range =
llvm::iterator_range<ConstAssociationIterator>;
/// The number of association expressions.
unsigned getNumAssocs() const { return NumAssocs; }
@ -5225,43 +5135,23 @@ public:
return {getTrailingObjects<TypeSourceInfo *>(), NumAssocs};
}
/// Return the Ith association expression with its TypeSourceInfo,
/// bundled together in GenericSelectionExpr::(Const)Association.
Association getAssociation(unsigned I) {
assert(I < getNumAssocs() &&
"Out-of-range index in GenericSelectionExpr::getAssociation!");
return Association(
cast<Expr>(getTrailingObjects<Stmt *>()[AssocExprStartIndex + I]),
getTrailingObjects<TypeSourceInfo *>()[I],
!isResultDependent() && (getResultIndex() == I));
Expr *getAssocExpr(unsigned i) {
return cast<Expr>(getTrailingObjects<Stmt *>()[AssocExprStartIndex + i]);
}
ConstAssociation getAssociation(unsigned I) const {
assert(I < getNumAssocs() &&
"Out-of-range index in GenericSelectionExpr::getAssociation!");
return ConstAssociation(
cast<Expr>(getTrailingObjects<Stmt *>()[AssocExprStartIndex + I]),
getTrailingObjects<TypeSourceInfo *>()[I],
!isResultDependent() && (getResultIndex() == I));
const Expr *getAssocExpr(unsigned i) const {
return cast<Expr>(getTrailingObjects<Stmt *>()[AssocExprStartIndex + i]);
}
association_range associations() {
AssociationIterator Begin(getTrailingObjects<Stmt *>() +
AssocExprStartIndex,
getTrailingObjects<TypeSourceInfo *>(),
/*Offset=*/0, ResultIndex);
AssociationIterator End(Begin.E + NumAssocs, Begin.TSI + NumAssocs,
/*Offset=*/NumAssocs, ResultIndex);
return llvm::make_range(Begin, End);
TypeSourceInfo *getAssocTypeSourceInfo(unsigned i) {
return getTrailingObjects<TypeSourceInfo *>()[i];
}
const TypeSourceInfo *getAssocTypeSourceInfo(unsigned i) const {
return getTrailingObjects<TypeSourceInfo *>()[i];
}
const_association_range associations() const {
ConstAssociationIterator Begin(getTrailingObjects<Stmt *>() +
AssocExprStartIndex,
getTrailingObjects<TypeSourceInfo *>(),
/*Offset=*/0, ResultIndex);
ConstAssociationIterator End(Begin.E + NumAssocs, Begin.TSI + NumAssocs,
/*Offset=*/NumAssocs, ResultIndex);
return llvm::make_range(Begin, End);
QualType getAssocType(unsigned i) const {
const TypeSourceInfo *TSI = getAssocTypeSourceInfo(i);
return TSI ? TSI->getType() : QualType();
}
SourceLocation getGenericLoc() const {

8
clang/include/clang/AST/RecursiveASTVisitor.h
View File

@ -2301,10 +2301,10 @@ bool RecursiveASTVisitor<Derived>::TraverseInitListExpr(
// generic associations).
DEF_TRAVERSE_STMT(GenericSelectionExpr, {
TRY_TO(TraverseStmt(S->getControllingExpr()));
for (const GenericSelectionExpr::Association &Assoc : S->associations()) {
if (TypeSourceInfo *TSI = Assoc.getTypeSourceInfo())
TRY_TO(TraverseTypeLoc(TSI->getTypeLoc()));
TRY_TO_TRAVERSE_OR_ENQUEUE_STMT(Assoc.getAssociationExpr());
for (unsigned i = 0; i != S->getNumAssocs(); ++i) {
if (TypeSourceInfo *TS = S->getAssocTypeSourceInfo(i))
TRY_TO(TraverseTypeLoc(TS->getTypeLoc()));
TRY_TO_TRAVERSE_OR_ENQUEUE_STMT(S->getAssocExpr(i));
}
ShouldVisitChildren = false;
})

4
clang/include/clang/AST/StmtDataCollectors.td
View File

@ -189,8 +189,8 @@ class CXXFoldExpr {
}
class GenericSelectionExpr {
code Code = [{
for (const GenericSelectionExpr::ConstAssociation &Assoc : S->associations()) {
addData(Assoc.getType());
for (unsigned i = 0; i < S->getNumAssocs(); ++i) {
addData(S->getAssocType(i));
}
}];
}

10
clang/lib/AST/ASTDumper.cpp
View File

@ -1462,21 +1462,21 @@ void ASTDumper::VisitGenericSelectionExpr(const GenericSelectionExpr *E) {
dumpStmt(E->getControllingExpr());
dumpTypeAsChild(E->getControllingExpr()->getType()); // FIXME: remove
for (const auto &Assoc : E->associations()) {
for (unsigned I = 0, N = E->getNumAssocs(); I != N; ++I) {
dumpChild([=] {
if (const TypeSourceInfo *TSI = Assoc.getTypeSourceInfo()) {
if (const TypeSourceInfo *TSI = E->getAssocTypeSourceInfo(I)) {
OS << "case ";
NodeDumper.dumpType(TSI->getType());
} else {
OS << "default";
}
if (Assoc.isSelected())
if (!E->isResultDependent() && E->getResultIndex() == I)
OS << " selected";
if (const TypeSourceInfo *TSI = Assoc.getTypeSourceInfo())
if (const TypeSourceInfo *TSI = E->getAssocTypeSourceInfo(I))
dumpTypeAsChild(TSI->getType());
dumpStmt(Assoc.getAssociationExpr());
dumpStmt(E->getAssocExpr(I));
});
}
}

6
clang/lib/AST/StmtPrinter.cpp
View File

@ -1261,15 +1261,15 @@ void StmtPrinter::VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *Node){
void StmtPrinter::VisitGenericSelectionExpr(GenericSelectionExpr *Node) {
OS << "_Generic(";
PrintExpr(Node->getControllingExpr());
for (const GenericSelectionExpr::Association &Assoc : Node->associations()) {
for (unsigned i = 0; i != Node->getNumAssocs(); ++i) {
OS << ", ";
QualType T = Assoc.getType();
QualType T = Node->getAssocType(i);
if (T.isNull())
OS << "default";
else
T.print(OS, Policy);
OS << ": ";
PrintExpr(Assoc.getAssociationExpr());
PrintExpr(Node->getAssocExpr(i));
}
OS << ")";
}

7
clang/lib/AST/StmtProfile.cpp
View File

@ -1260,14 +1260,13 @@ void StmtProfiler::VisitBlockExpr(const BlockExpr *S) {
void StmtProfiler::VisitGenericSelectionExpr(const GenericSelectionExpr *S) {
VisitExpr(S);
for (const GenericSelectionExpr::ConstAssociation &Assoc :
S->associations()) {
QualType T = Assoc.getType();
for (unsigned i = 0; i != S->getNumAssocs(); ++i) {
QualType T = S->getAssocType(i);
if (T.isNull())
ID.AddPointer(nullptr);
else
VisitType(T);
VisitExpr(Assoc.getAssociationExpr());
VisitExpr(S->getAssocExpr(i));
}
}

16
clang/lib/Sema/SemaExprObjC.cpp
View File

@ -4332,16 +4332,14 @@ Expr *Sema::stripARCUnbridgedCast(Expr *e) {
assert(!gse->isResultDependent());
unsigned n = gse->getNumAssocs();
SmallVector<Expr *, 4> subExprs;
SmallVector<TypeSourceInfo *, 4> subTypes;
subExprs.reserve(n);
subTypes.reserve(n);
for (const GenericSelectionExpr::Association &assoc : gse->associations()) {
subTypes.push_back(assoc.getTypeSourceInfo());
Expr *sub = assoc.getAssociationExpr();
if (assoc.isSelected())
SmallVector<Expr*, 4> subExprs(n);
SmallVector<TypeSourceInfo*, 4> subTypes(n);
for (unsigned i = 0; i != n; ++i) {
subTypes[i] = gse->getAssocTypeSourceInfo(i);
Expr *sub = gse->getAssocExpr(i);
if (i == gse->getResultIndex())
sub = stripARCUnbridgedCast(sub);
subExprs.push_back(sub);
subExprs[i] = sub;
}
return GenericSelectionExpr::Create(

20
clang/lib/Sema/SemaPseudoObject.cpp
View File

@ -140,23 +140,19 @@ namespace {
unsigned resultIndex = gse->getResultIndex();
unsigned numAssocs = gse->getNumAssocs();
SmallVector<Expr *, 8> assocExprs;
SmallVector<TypeSourceInfo *, 8> assocTypes;
assocExprs.reserve(numAssocs);
assocTypes.reserve(numAssocs);
SmallVector<Expr*, 8> assocs(numAssocs);
SmallVector<TypeSourceInfo*, 8> assocTypes(numAssocs);
for (const GenericSelectionExpr::Association &assoc :
gse->associations()) {
Expr *assocExpr = assoc.getAssociationExpr();
if (assoc.isSelected())
assocExpr = rebuild(assocExpr);
assocExprs.push_back(assocExpr);
assocTypes.push_back(assoc.getTypeSourceInfo());
for (unsigned i = 0; i != numAssocs; ++i) {
Expr *assoc = gse->getAssocExpr(i);
if (i == resultIndex) assoc = rebuild(assoc);
assocs[i] = assoc;
assocTypes[i] = gse->getAssocTypeSourceInfo(i);
}
return GenericSelectionExpr::Create(
S.Context, gse->getGenericLoc(), gse->getControllingExpr(),
assocTypes, assocExprs, gse->getDefaultLoc(), gse->getRParenLoc(),
assocTypes, assocs, gse->getDefaultLoc(), gse->getRParenLoc(),
gse->containsUnexpandedParameterPack(), resultIndex);
}

11
clang/lib/Sema/TreeTransform.h
View File

@ -9073,10 +9073,10 @@ TreeTransform<Derived>::TransformGenericSelectionExpr(GenericSelectionExpr *E) {
SmallVector<Expr *, 4> AssocExprs;
SmallVector<TypeSourceInfo *, 4> AssocTypes;
for (const GenericSelectionExpr::Association &Assoc : E->associations()) {
TypeSourceInfo *TSI = Assoc.getTypeSourceInfo();
if (TSI) {
TypeSourceInfo *AssocType = getDerived().TransformType(TSI);
for (unsigned i = 0; i != E->getNumAssocs(); ++i) {
TypeSourceInfo *TS = E->getAssocTypeSourceInfo(i);
if (TS) {
TypeSourceInfo *AssocType = getDerived().TransformType(TS);
if (!AssocType)
return ExprError();
AssocTypes.push_back(AssocType);
@ -9084,8 +9084,7 @@ TreeTransform<Derived>::TransformGenericSelectionExpr(GenericSelectionExpr *E) {
AssocTypes.push_back(nullptr);
}
ExprResult AssocExpr =
getDerived().TransformExpr(Assoc.getAssociationExpr());
ExprResult AssocExpr = getDerived().TransformExpr(E->getAssocExpr(i));
if (AssocExpr.isInvalid())
return ExprError();
AssocExprs.push_back(AssocExpr.get());