Magic-Mirror/llvm-capstone
1
0
Fork 0
mirror of https://github.com/capstone-engine/llvm-capstone.git synced 2025-04-01 12:43:47 +00:00
Code Issues Actions 5 Packages Projects Releases Wiki Activity

[AST] Pack GenericSelectionExpr

Browse Source 
Store the controlling expression, the association expressions and the
corresponding TypeSourceInfos as trailing objects.

Additionally use the bit-fields of Stmt to store one SourceLocation,
saving one additional pointer. This saves 3 pointers in total per
GenericSelectionExpr.

Differential Revision: https://reviews.llvm.org/D57104

Reviewed By: aaron.ballman

Reviewers: aaron.ballman, steveire
llvm-svn: 352276
This commit is contained in:
Bruno Ricci 2019-01-26 14:15:10 +00:00
parent 94498c70ae
commit db07683d86
9 changed files with 181 additions and 79 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -5013,9 +5013,13 @@ public:
/// which names a dependent type in its association list is result-dependent,
/// which means that the choice of result expression is dependent.
/// Result-dependent generic associations are both type- and value-dependent.
class GenericSelectionExpr : public Expr {
class GenericSelectionExpr final
: public Expr,
private llvm::TrailingObjects<GenericSelectionExpr, Stmt *,
TypeSourceInfo *> {
friend class ASTStmtReader;
friend class ASTStmtWriter;
friend TrailingObjects;
/// The number of association expressions and the index of the result
/// expression in the case where the generic selection expression is not
@ -5028,13 +5032,27 @@ class GenericSelectionExpr : public Expr {
AssocExprStartIndex = 1
};
/// The location of the "_Generic", "default" and of the right parenthesis.
SourceLocation GenericLoc, DefaultLoc, RParenLoc;
/// The location of the "default" and of the right parenthesis.
SourceLocation DefaultLoc, RParenLoc;
TypeSourceInfo **AssocTypes;
Stmt **SubExprs;
// GenericSelectionExpr is followed by several trailing objects.
// They are (in order):
//
// * A single Stmt * for the controlling expression.
// * An array of getNumAssocs() Stmt * for the association expressions.
// * An array of getNumAssocs() TypeSourceInfo *, one for each of the
// association expressions.
unsigned numTrailingObjects(OverloadToken<Stmt *>) const {
// Add one to account for the controlling expression; the remainder
// are the associated expressions.
return 1 + getNumAssocs();
}
public:
unsigned numTrailingObjects(OverloadToken<TypeSourceInfo *>) const {
return getNumAssocs();
}
/// Build a non-result-dependent generic selection expression.
GenericSelectionExpr(const ASTContext &Context, SourceLocation GenericLoc,
Expr *ControllingExpr,
ArrayRef<TypeSourceInfo *> AssocTypes,
@ -5043,7 +5061,7 @@ public:
bool ContainsUnexpandedParameterPack,
unsigned ResultIndex);
/// This constructor is used in the result-dependent case.
/// Build a result-dependent generic selection expression.
GenericSelectionExpr(const ASTContext &Context, SourceLocation GenericLoc,
Expr *ControllingExpr,
ArrayRef<TypeSourceInfo *> AssocTypes,
@ -5051,8 +5069,28 @@ public:
SourceLocation RParenLoc,
bool ContainsUnexpandedParameterPack);
explicit GenericSelectionExpr(EmptyShell Empty)
: Expr(GenericSelectionExprClass, Empty) {}
/// Build an empty generic selection expression for deserialization.
explicit GenericSelectionExpr(EmptyShell Empty, unsigned NumAssocs);
public:
/// Create a non-result-dependent generic selection expression.
static GenericSelectionExpr *
Create(const ASTContext &Context, SourceLocation GenericLoc,
Expr *ControllingExpr, ArrayRef<TypeSourceInfo *> AssocTypes,
ArrayRef<Expr *> AssocExprs, SourceLocation DefaultLoc,
SourceLocation RParenLoc, bool ContainsUnexpandedParameterPack,
unsigned ResultIndex);
/// Create a result-dependent generic selection expression.
static GenericSelectionExpr *
Create(const ASTContext &Context, SourceLocation GenericLoc,
Expr *ControllingExpr, ArrayRef<TypeSourceInfo *> AssocTypes,
ArrayRef<Expr *> AssocExprs, SourceLocation DefaultLoc,
SourceLocation RParenLoc, bool ContainsUnexpandedParameterPack);
/// Create an empty generic selection expression for deserialization.
static GenericSelectionExpr *CreateEmpty(const ASTContext &Context,
unsigned NumAssocs);
/// The number of association expressions.
unsigned getNumAssocs() const { return NumAssocs; }
@ -5070,38 +5108,45 @@ public:
bool isResultDependent() const { return ResultIndex == ResultDependentIndex; }
/// Return the controlling expression of this generic selection expression.
Expr *getControllingExpr() { return cast<Expr>(SubExprs[ControllingIndex]); }
Expr *getControllingExpr() {
return cast<Expr>(getTrailingObjects<Stmt *>()[ControllingIndex]);
}
const Expr *getControllingExpr() const {
return cast<Expr>(SubExprs[ControllingIndex]);
return cast<Expr>(getTrailingObjects<Stmt *>()[ControllingIndex]);
}
/// Return the result expression of this controlling expression. Defined if
/// and only if the generic selection expression is not result-dependent.
Expr *getResultExpr() {
return cast<Expr>(SubExprs[AssocExprStartIndex + getResultIndex()]);
return cast<Expr>(
getTrailingObjects<Stmt *>()[AssocExprStartIndex + getResultIndex()]);
}
const Expr *getResultExpr() const {
return cast<Expr>(SubExprs[AssocExprStartIndex + getResultIndex()]);
return cast<Expr>(
getTrailingObjects<Stmt *>()[AssocExprStartIndex + getResultIndex()]);
}
ArrayRef<Expr *> getAssocExprs() const {
return {reinterpret_cast<Expr *const *>(SubExprs + AssocExprStartIndex),
return {reinterpret_cast<Expr *const *>(getTrailingObjects<Stmt *>() +
AssocExprStartIndex),
NumAssocs};
}
ArrayRef<TypeSourceInfo *> getAssocTypeSourceInfos() const {
return {AssocTypes, NumAssocs};
return {getTrailingObjects<TypeSourceInfo *>(), NumAssocs};
}
Expr *getAssocExpr(unsigned i) {
return cast<Expr>(SubExprs[AssocExprStartIndex + i]);
return cast<Expr>(getTrailingObjects<Stmt *>()[AssocExprStartIndex + i]);
}
const Expr *getAssocExpr(unsigned i) const {
return cast<Expr>(SubExprs[AssocExprStartIndex + i]);
return cast<Expr>(getTrailingObjects<Stmt *>()[AssocExprStartIndex + i]);
}
TypeSourceInfo *getAssocTypeSourceInfo(unsigned i) { return AssocTypes[i]; }
TypeSourceInfo *getAssocTypeSourceInfo(unsigned i) {
return getTrailingObjects<TypeSourceInfo *>()[i];
}
const TypeSourceInfo *getAssocTypeSourceInfo(unsigned i) const {
return AssocTypes[i];
return getTrailingObjects<TypeSourceInfo *>()[i];
}
QualType getAssocType(unsigned i) const {
@ -5109,7 +5154,9 @@ public:
return TSI ? TSI->getType() : QualType();
}
SourceLocation getGenericLoc() const { return GenericLoc; }
SourceLocation getGenericLoc() const {
return GenericSelectionExprBits.GenericLoc;
}
SourceLocation getDefaultLoc() const { return DefaultLoc; }
SourceLocation getRParenLoc() const { return RParenLoc; }
SourceLocation getBeginLoc() const { return getGenericLoc(); }
@ -5120,11 +5167,14 @@ public:
}
child_range children() {
return child_range(SubExprs, SubExprs + AssocExprStartIndex + NumAssocs);
return child_range(getTrailingObjects<Stmt *>(),
getTrailingObjects<Stmt *>() +
numTrailingObjects(OverloadToken<Stmt *>()));
}
const_child_range children() const {
return const_child_range(SubExprs,
SubExprs + AssocExprStartIndex + NumAssocs);
return const_child_range(getTrailingObjects<Stmt *>(),
getTrailingObjects<Stmt *>() +
numTrailingObjects(OverloadToken<Stmt *>()));
}
};

11
clang/include/clang/AST/Stmt.h
View File

@ -520,6 +520,16 @@ protected:
unsigned NumExprs;
};
class GenericSelectionExprBitfields {
friend class ASTStmtReader;
friend class GenericSelectionExpr;
unsigned : NumExprBits;
/// The location of the "_Generic".
SourceLocation GenericLoc;
};
class PseudoObjectExprBitfields {
friend class ASTStmtReader; // deserialization
friend class PseudoObjectExpr;
@ -915,6 +925,7 @@ protected:
BinaryOperatorBitfields BinaryOperatorBits;
InitListExprBitfields InitListExprBits;
ParenListExprBitfields ParenListExprBits;
GenericSelectionExprBitfields GenericSelectionExprBits;
PseudoObjectExprBitfields PseudoObjectExprBits;
// C++ Expressions

66
clang/lib/AST/Expr.cpp
View File

@ -3775,7 +3775,7 @@ void ShuffleVectorExpr::setExprs(const ASTContext &C, ArrayRef<Expr *> Exprs) {
}
GenericSelectionExpr::GenericSelectionExpr(
const ASTContext &Context, SourceLocation GenericLoc, Expr *ControllingExpr,
const ASTContext &, SourceLocation GenericLoc, Expr *ControllingExpr,
ArrayRef<TypeSourceInfo *> AssocTypes, ArrayRef<Expr *> AssocExprs,
SourceLocation DefaultLoc, SourceLocation RParenLoc,
bool ContainsUnexpandedParameterPack, unsigned ResultIndex)
@ -3787,18 +3787,18 @@ GenericSelectionExpr::GenericSelectionExpr(
AssocExprs[ResultIndex]->isInstantiationDependent(),
ContainsUnexpandedParameterPack),
NumAssocs(AssocExprs.size()), ResultIndex(ResultIndex),
AssocTypes(new (Context) TypeSourceInfo *[AssocTypes.size()]),
SubExprs(new (Context) Stmt *[AssocExprStartIndex + AssocExprs.size()]),
GenericLoc(GenericLoc), DefaultLoc(DefaultLoc), RParenLoc(RParenLoc) {
DefaultLoc(DefaultLoc), RParenLoc(RParenLoc) {
assert(AssocTypes.size() == AssocExprs.size() &&
"Must have the same number of association expressions"
" and TypeSourceInfo!");
assert(ResultIndex < NumAssocs && "ResultIndex is out-of-bounds!");
SubExprs[ControllingIndex] = ControllingExpr;
std::copy(AssocTypes.begin(), AssocTypes.end(), this->AssocTypes);
GenericSelectionExprBits.GenericLoc = GenericLoc;
getTrailingObjects<Stmt *>()[ControllingIndex] = ControllingExpr;
std::copy(AssocExprs.begin(), AssocExprs.end(),
SubExprs + AssocExprStartIndex);
getTrailingObjects<Stmt *>() + AssocExprStartIndex);
std::copy(AssocTypes.begin(), AssocTypes.end(),
getTrailingObjects<TypeSourceInfo *>());
}
GenericSelectionExpr::GenericSelectionExpr(
@ -3812,17 +3812,57 @@ GenericSelectionExpr::GenericSelectionExpr(
/*isValueDependent=*/true,
/*isInstantiationDependent=*/true, ContainsUnexpandedParameterPack),
NumAssocs(AssocExprs.size()), ResultIndex(ResultDependentIndex),
AssocTypes(new (Context) TypeSourceInfo *[AssocTypes.size()]),
SubExprs(new (Context) Stmt *[AssocExprStartIndex + AssocExprs.size()]),
GenericLoc(GenericLoc), DefaultLoc(DefaultLoc), RParenLoc(RParenLoc) {
DefaultLoc(DefaultLoc), RParenLoc(RParenLoc) {
assert(AssocTypes.size() == AssocExprs.size() &&
"Must have the same number of association expressions"
" and TypeSourceInfo!");
SubExprs[ControllingIndex] = ControllingExpr;
std::copy(AssocTypes.begin(), AssocTypes.end(), this->AssocTypes);
GenericSelectionExprBits.GenericLoc = GenericLoc;
getTrailingObjects<Stmt *>()[ControllingIndex] = ControllingExpr;
std::copy(AssocExprs.begin(), AssocExprs.end(),
SubExprs + AssocExprStartIndex);
getTrailingObjects<Stmt *>() + AssocExprStartIndex);
std::copy(AssocTypes.begin(), AssocTypes.end(),
getTrailingObjects<TypeSourceInfo *>());
}
GenericSelectionExpr::GenericSelectionExpr(EmptyShell Empty, unsigned NumAssocs)
: Expr(GenericSelectionExprClass, Empty), NumAssocs(NumAssocs) {}
GenericSelectionExpr *GenericSelectionExpr::Create(
const ASTContext &Context, SourceLocation GenericLoc, Expr *ControllingExpr,
ArrayRef<TypeSourceInfo *> AssocTypes, ArrayRef<Expr *> AssocExprs,
SourceLocation DefaultLoc, SourceLocation RParenLoc,
bool ContainsUnexpandedParameterPack, unsigned ResultIndex) {
unsigned NumAssocs = AssocExprs.size();
void *Mem = Context.Allocate(
totalSizeToAlloc<Stmt *, TypeSourceInfo *>(1 + NumAssocs, NumAssocs),
alignof(GenericSelectionExpr));
return new (Mem) GenericSelectionExpr(
Context, GenericLoc, ControllingExpr, AssocTypes, AssocExprs, DefaultLoc,
RParenLoc, ContainsUnexpandedParameterPack, ResultIndex);
}
GenericSelectionExpr *GenericSelectionExpr::Create(
const ASTContext &Context, SourceLocation GenericLoc, Expr *ControllingExpr,
ArrayRef<TypeSourceInfo *> AssocTypes, ArrayRef<Expr *> AssocExprs,
SourceLocation DefaultLoc, SourceLocation RParenLoc,
bool ContainsUnexpandedParameterPack) {
unsigned NumAssocs = AssocExprs.size();
void *Mem = Context.Allocate(
totalSizeToAlloc<Stmt *, TypeSourceInfo *>(1 + NumAssocs, NumAssocs),
alignof(GenericSelectionExpr));
return new (Mem) GenericSelectionExpr(
Context, GenericLoc, ControllingExpr, AssocTypes, AssocExprs, DefaultLoc,
RParenLoc, ContainsUnexpandedParameterPack);
}
GenericSelectionExpr *
GenericSelectionExpr::CreateEmpty(const ASTContext &Context,
unsigned NumAssocs) {
void *Mem = Context.Allocate(
totalSizeToAlloc<Stmt *, TypeSourceInfo *>(1 + NumAssocs, NumAssocs),
alignof(GenericSelectionExpr));
return new (Mem) GenericSelectionExpr(EmptyShell(), NumAssocs);
}
//===----------------------------------------------------------------------===//

8
clang/lib/Sema/SemaExpr.cpp
View File

@ -1534,9 +1534,9 @@ Sema::CreateGenericSelectionExpr(SourceLocation KeyLoc,
// If we determined that the generic selection is result-dependent, don't
// try to compute the result expression.
if (IsResultDependent)
return new (Context) GenericSelectionExpr(
Context, KeyLoc, ControllingExpr, Types, Exprs, DefaultLoc, RParenLoc,
ContainsUnexpandedParameterPack);
return GenericSelectionExpr::Create(Context, KeyLoc, ControllingExpr, Types,
Exprs, DefaultLoc, RParenLoc,
ContainsUnexpandedParameterPack);
SmallVector<unsigned, 1> CompatIndices;
unsigned DefaultIndex = -1U;
@ -1587,7 +1587,7 @@ Sema::CreateGenericSelectionExpr(SourceLocation KeyLoc,
unsigned ResultIndex =
CompatIndices.size() ? CompatIndices[0] : DefaultIndex;
return new (Context) GenericSelectionExpr(
return GenericSelectionExpr::Create(
Context, KeyLoc, ControllingExpr, Types, Exprs, DefaultLoc, RParenLoc,
ContainsUnexpandedParameterPack, ResultIndex);
}

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

@ -4342,13 +4342,10 @@ Expr *Sema::stripARCUnbridgedCast(Expr *e) {
subExprs[i] = sub;
}
return new (Context) GenericSelectionExpr(Context, gse->getGenericLoc(),
gse->getControllingExpr(),
subTypes, subExprs,
gse->getDefaultLoc(),
gse->getRParenLoc(),
gse->containsUnexpandedParameterPack(),
gse->getResultIndex());
return GenericSelectionExpr::Create(
Context, gse->getGenericLoc(), gse->getControllingExpr(), subTypes,
subExprs, gse->getDefaultLoc(), gse->getRParenLoc(),
gse->containsUnexpandedParameterPack(), gse->getResultIndex());
} else {
assert(isa<ImplicitCastExpr>(e) && "bad form of unbridged cast!");
return cast<ImplicitCastExpr>(e)->getSubExpr();

2
clang/lib/Sema/SemaOverload.cpp
View File

@ -13711,7 +13711,7 @@ Expr *Sema::FixOverloadedFunctionReference(Expr *E, DeclAccessPair Found,
unsigned ResultIdx = GSE->getResultIndex();
AssocExprs[ResultIdx] = SubExpr;
return new (Context) GenericSelectionExpr(
return GenericSelectionExpr::Create(
Context, GSE->getGenericLoc(), GSE->getControllingExpr(),
GSE->getAssocTypeSourceInfos(), AssocExprs, GSE->getDefaultLoc(),
GSE->getRParenLoc(), GSE->containsUnexpandedParameterPack(),

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

@ -150,15 +150,10 @@ namespace {
assocTypes[i] = gse->getAssocTypeSourceInfo(i);
}
return new (S.Context) GenericSelectionExpr(S.Context,
gse->getGenericLoc(),
gse->getControllingExpr(),
assocTypes,
assocs,
gse->getDefaultLoc(),
gse->getRParenLoc(),
gse->containsUnexpandedParameterPack(),
resultIndex);
return GenericSelectionExpr::Create(
S.Context, gse->getGenericLoc(), gse->getControllingExpr(),
assocTypes, assocs, gse->getDefaultLoc(), gse->getRParenLoc(),
gse->containsUnexpandedParameterPack(), resultIndex);
}
if (ChooseExpr *ce = dyn_cast<ChooseExpr>(e)) {

33
clang/lib/Serialization/ASTReaderStmt.cpp
View File

@ -1022,23 +1022,24 @@ void ASTStmtReader::VisitBlockExpr(BlockExpr *E) {
void ASTStmtReader::VisitGenericSelectionExpr(GenericSelectionExpr *E) {
VisitExpr(E);
E->NumAssocs = Record.readInt();
unsigned NumAssocs = Record.readInt();
assert(NumAssocs == E->getNumAssocs() && "Wrong NumAssocs!");
E->ResultIndex = Record.readInt();
E->AssocTypes = new (Record.getContext()) TypeSourceInfo *[E->NumAssocs];
E->SubExprs = new (Record.getContext())
Stmt *[GenericSelectionExpr::AssocExprStartIndex + E->NumAssocs];
E->SubExprs[GenericSelectionExpr::ControllingIndex] = Record.readSubExpr();
for (unsigned I = 0, N = E->getNumAssocs(); I != N; ++I) {
E->AssocTypes[I] = GetTypeSourceInfo();
E->SubExprs[GenericSelectionExpr::AssocExprStartIndex + I] =
Record.readSubExpr();
}
E->GenericLoc = ReadSourceLocation();
E->GenericSelectionExprBits.GenericLoc = ReadSourceLocation();
E->DefaultLoc = ReadSourceLocation();
E->RParenLoc = ReadSourceLocation();
Stmt **Stmts = E->getTrailingObjects<Stmt *>();
// Add 1 to account for the controlling expression which is the first
// expression in the trailing array of Stmt *. This is not needed for
// the trailing array of TypeSourceInfo *.
for (unsigned I = 0, N = NumAssocs + 1; I < N; ++I)
Stmts[I] = Record.readSubExpr();
TypeSourceInfo **TSIs = E->getTrailingObjects<TypeSourceInfo *>();
for (unsigned I = 0, N = NumAssocs; I < N; ++I)
TSIs[I] = GetTypeSourceInfo();
}
void ASTStmtReader::VisitPseudoObjectExpr(PseudoObjectExpr *E) {
@ -2677,7 +2678,9 @@ Stmt *ASTReader::ReadStmtFromStream(ModuleFile &F) {
break;
case EXPR_GENERIC_SELECTION:
S = new (Context) GenericSelectionExpr(Empty);
S = GenericSelectionExpr::CreateEmpty(
Context,
/*NumAssocs=*/Record[ASTStmtReader::NumExprFields]);
break;
case EXPR_OBJC_STRING_LITERAL:

20
clang/lib/Serialization/ASTWriterStmt.cpp
View File

@ -968,18 +968,24 @@ void ASTStmtWriter::VisitBlockExpr(BlockExpr *E) {
void ASTStmtWriter::VisitGenericSelectionExpr(GenericSelectionExpr *E) {
VisitExpr(E);
Record.push_back(E->getNumAssocs());
Record.push_back(E->ResultIndex);
Record.AddStmt(E->getControllingExpr());
for (unsigned I = 0, N = E->getNumAssocs(); I != N; ++I) {
Record.AddTypeSourceInfo(E->getAssocTypeSourceInfo(I));
Record.AddStmt(E->getAssocExpr(I));
}
Record.AddSourceLocation(E->getGenericLoc());
Record.AddSourceLocation(E->getDefaultLoc());
Record.AddSourceLocation(E->getRParenLoc());
Stmt **Stmts = E->getTrailingObjects<Stmt *>();
// Add 1 to account for the controlling expression which is the first
// expression in the trailing array of Stmt *. This is not needed for
// the trailing array of TypeSourceInfo *.
for (unsigned I = 0, N = E->getNumAssocs() + 1; I < N; ++I)
Record.AddStmt(Stmts[I]);
TypeSourceInfo **TSIs = E->getTrailingObjects<TypeSourceInfo *>();
for (unsigned I = 0, N = E->getNumAssocs(); I < N; ++I)
Record.AddTypeSourceInfo(TSIs[I]);
Code = serialization::EXPR_GENERIC_SELECTION;
}