Skip to content

Commit 3749914

Browse files
cor3ntincor3ntin
committed
slab allocate template candidates
1 parent e68093b commit 3749914

File tree

2 files changed

+130
-75
lines changed

2 files changed

+130
-75
lines changed

‎clang/include/clang/Sema/Overload.h

Lines changed: 54 additions & 40 deletions
Original file line numberDiff line numberDiff line change
@@ -38,7 +38,6 @@
3838
#include <cstddef>
3939
#include <cstdint>
4040
#include <utility>
41-
#include <variant>
4241

4342
namespace clang {
4443

@@ -1039,60 +1038,61 @@ class Sema;
10391038
RewriteKind(CRK_None) {}
10401039
};
10411040

1042-
struct DeferredConversionTemplateOverloadCandidate {
1043-
FunctionTemplateDecl *FunctionTemplate;
1044-
DeclAccessPair FoundDecl;
1045-
CXXRecordDecl *ActingContext;
1046-
Expr *From;
1047-
QualType ToType;
1041+
struct DeferredTemplateOverloadCandidate {
1042+
DeferredTemplateOverloadCandidate *Next = nullptr;
1043+
enum Kind { Function, Method, Conversion };
10481044

1045+
LLVM_PREFERRED_TYPE(Kind)
1046+
unsigned Kind : 2;
10491047
LLVM_PREFERRED_TYPE(bool)
10501048
unsigned AllowObjCConversionOnExplicit : 1;
10511049
LLVM_PREFERRED_TYPE(bool)
1050+
unsigned AllowResultConversion : 1;
1051+
LLVM_PREFERRED_TYPE(bool)
10521052
unsigned AllowExplicit : 1;
10531053
LLVM_PREFERRED_TYPE(bool)
1054-
unsigned AllowResultConversion : 1;
1054+
unsigned SuppressUserConversions : 1;
1055+
LLVM_PREFERRED_TYPE(bool)
1056+
unsigned PartialOverloading : 1;
1057+
LLVM_PREFERRED_TYPE(bool)
1058+
unsigned AggregateCandidateDeduction : 1;
10551059
};
10561060

1057-
struct DeferredMethodTemplateOverloadCandidate {
1061+
struct DeferredFunctionTemplateOverloadCandidate
1062+
: public DeferredTemplateOverloadCandidate {
10581063
FunctionTemplateDecl *FunctionTemplate;
10591064
DeclAccessPair FoundDecl;
10601065
ArrayRef<Expr *> Args;
1061-
CXXRecordDecl *ActingContext;
1062-
Expr::Classification ObjectClassification;
1063-
QualType ObjectType;
1064-
1066+
CallExpr::ADLCallKind IsADLCandidate;
10651067
OverloadCandidateParamOrder PO;
1066-
LLVM_PREFERRED_TYPE(bool)
1067-
unsigned SuppressUserConversions : 1;
1068-
LLVM_PREFERRED_TYPE(bool)
1069-
unsigned PartialOverloading : 1;
10701068
};
1069+
static_assert(std::is_trivially_destructible_v<
1070+
DeferredFunctionTemplateOverloadCandidate>);
10711071

1072-
struct DeferredFunctionTemplateOverloadCandidate {
1072+
struct DeferredMethodTemplateOverloadCandidate
1073+
: public DeferredTemplateOverloadCandidate {
10731074
FunctionTemplateDecl *FunctionTemplate;
10741075
DeclAccessPair FoundDecl;
10751076
ArrayRef<Expr *> Args;
1076-
1077-
CallExpr::ADLCallKind IsADLCandidate;
1077+
CXXRecordDecl *ActingContext;
1078+
Expr::Classification ObjectClassification;
1079+
QualType ObjectType;
10781080
OverloadCandidateParamOrder PO;
1079-
LLVM_PREFERRED_TYPE(bool)
1080-
unsigned SuppressUserConversions : 1;
1081-
LLVM_PREFERRED_TYPE(bool)
1082-
unsigned PartialOverloading : 1;
1083-
LLVM_PREFERRED_TYPE(bool)
1084-
unsigned AllowExplicit : 1;
1085-
LLVM_PREFERRED_TYPE(bool)
1086-
unsigned AggregateCandidateDeduction : 1;
10871081
};
1082+
static_assert(std::is_trivially_destructible_v<
1083+
DeferredMethodTemplateOverloadCandidate>);
10881084

1089-
using DeferredTemplateOverloadCandidate =
1090-
std::variant<DeferredConversionTemplateOverloadCandidate,
1091-
DeferredMethodTemplateOverloadCandidate,
1092-
DeferredFunctionTemplateOverloadCandidate>;
1085+
struct DeferredConversionTemplateOverloadCandidate
1086+
: public DeferredTemplateOverloadCandidate {
1087+
FunctionTemplateDecl *FunctionTemplate;
1088+
DeclAccessPair FoundDecl;
1089+
CXXRecordDecl *ActingContext;
1090+
Expr *From;
1091+
QualType ToType;
1092+
};
10931093

1094-
static_assert(
1095-
std::is_trivially_destructible_v<DeferredTemplateOverloadCandidate>);
1094+
static_assert(std::is_trivially_destructible_v<
1095+
DeferredConversionTemplateOverloadCandidate>);
10961096

10971097
/// OverloadCandidateSet - A set of overload candidates, used in C++
10981098
/// overload resolution (C++ 13.3).
@@ -1197,8 +1197,9 @@ class Sema;
11971197
private:
11981198
SmallVector<OverloadCandidate, 16> Candidates;
11991199
llvm::SmallPtrSet<uintptr_t, 16> Functions;
1200-
SmallVector<DeferredTemplateOverloadCandidate, 8> DeferredCandidates;
12011200

1201+
DeferredTemplateOverloadCandidate *FirstDeferredCandidate;
1202+
unsigned DeferredCandidatesCount : 8 * sizeof(unsigned) - 1;
12021203
LLVM_PREFERRED_TYPE(bool)
12031204
unsigned HasDeferredTemplateConstructors : 1;
12041205

@@ -1246,12 +1247,27 @@ class Sema;
12461247
return reinterpret_cast<T *>(FreeSpaceStart);
12471248
}
12481249

1250+
template <typename T> T *allocateDeferredCandidate() {
1251+
T *C = slabAllocate<T>(1);
1252+
if (!FirstDeferredCandidate)
1253+
FirstDeferredCandidate = C;
1254+
else {
1255+
auto *F = FirstDeferredCandidate;
1256+
while (F->Next)
1257+
F = F->Next;
1258+
F->Next = C;
1259+
}
1260+
DeferredCandidatesCount++;
1261+
return C;
1262+
}
1263+
12491264
void destroyCandidates();
12501265

12511266
public:
12521267
OverloadCandidateSet(SourceLocation Loc, CandidateSetKind CSK,
12531268
OperatorRewriteInfo RewriteInfo = {})
1254-
: HasDeferredTemplateConstructors(false), Loc(Loc), Kind(CSK),
1269+
: FirstDeferredCandidate(nullptr), DeferredCandidatesCount(0),
1270+
HasDeferredTemplateConstructors(false), Loc(Loc), Kind(CSK),
12551271
RewriteInfo(RewriteInfo) {}
12561272
OverloadCandidateSet(const OverloadCandidateSet &) = delete;
12571273
OverloadCandidateSet &operator=(const OverloadCandidateSet &) = delete;
@@ -1290,11 +1306,9 @@ class Sema;
12901306
iterator begin() { return Candidates.begin(); }
12911307
iterator end() { return Candidates.end(); }
12921308

1293-
size_t size() const {
1294-
return Candidates.size() + DeferredCandidates.size();
1295-
}
1309+
size_t size() const { return Candidates.size() + DeferredCandidatesCount; }
12961310
bool empty() const {
1297-
return Candidates.empty() && DeferredCandidates.empty();
1311+
return Candidates.empty() && DeferredCandidatesCount == 0;
12981312
}
12991313

13001314
/// Allocate storage for conversion sequences for NumConversions

‎clang/lib/Sema/SemaOverload.cpp

Lines changed: 76 additions & 35 deletions
Original file line numberDiff line numberDiff line change
@@ -1124,6 +1124,8 @@ void OverloadCandidateSet::clear(CandidateSetKind CSK) {
11241124
Candidates.clear();
11251125
Functions.clear();
11261126
Kind = CSK;
1127+
FirstDeferredCandidate = nullptr;
1128+
DeferredCandidatesCount = 0;
11271129
HasDeferredTemplateConstructors = false;
11281130
}
11291131

@@ -11008,16 +11010,20 @@ void OverloadCandidateSet::AddDeferredTemplateCandidate(
1100811010
bool PartialOverloading, bool AllowExplicit,
1100911011
CallExpr::ADLCallKind IsADLCandidate, OverloadCandidateParamOrder PO,
1101011012
bool AggregateCandidateDeduction) {
11011-
DeferredFunctionTemplateOverloadCandidate C{FunctionTemplate,
11012-
FoundDecl,
11013-
Args,
11014-
IsADLCandidate,
11015-
PO,
11016-
SuppressUserConversions,
11017-
PartialOverloading,
11018-
AllowExplicit,
11019-
AggregateCandidateDeduction};
11020-
DeferredCandidates.emplace_back(std::move(C));
11013+
11014+
auto *C =
11015+
allocateDeferredCandidate<DeferredFunctionTemplateOverloadCandidate>();
11016+
11017+
C = new (C) DeferredFunctionTemplateOverloadCandidate{
11018+
{nullptr, DeferredFunctionTemplateOverloadCandidate::Function,
11019+
/*AllowObjCConversionOnExplicit=*/false,
11020+
/*AllowResultConversion=*/false, AllowExplicit, SuppressUserConversions,
11021+
PartialOverloading, AggregateCandidateDeduction},
11022+
FunctionTemplate,
11023+
FoundDecl,
11024+
Args,
11025+
IsADLCandidate,
11026+
PO};
1102111027
HasDeferredTemplateConstructors |=
1102211028
isa<CXXConstructorDecl>(FunctionTemplate->getTemplatedDecl());
1102311029
}
@@ -11028,11 +11034,23 @@ void OverloadCandidateSet::AddDeferredMethodTemplateCandidate(
1102811034
Expr::Classification ObjectClassification, ArrayRef<Expr *> Args,
1102911035
bool SuppressUserConversions, bool PartialOverloading,
1103011036
OverloadCandidateParamOrder PO) {
11031-
DeferredMethodTemplateOverloadCandidate C{
11032-
MethodTmpl, FoundDecl, Args, ActingContext,
11033-
ObjectClassification, ObjectType, PO, SuppressUserConversions,
11034-
PartialOverloading};
11035-
DeferredCandidates.emplace_back(std::move(C));
11037+
11038+
auto *C =
11039+
allocateDeferredCandidate<DeferredMethodTemplateOverloadCandidate>();
11040+
11041+
C = new (C) DeferredMethodTemplateOverloadCandidate{
11042+
{nullptr, DeferredFunctionTemplateOverloadCandidate::Method,
11043+
/*AllowObjCConversionOnExplicit=*/false,
11044+
/*AllowResultConversion=*/false,
11045+
/*AllowExplicit=*/false, SuppressUserConversions, PartialOverloading,
11046+
/*AggregateCandidateDeduction=*/false},
11047+
MethodTmpl,
11048+
FoundDecl,
11049+
Args,
11050+
ActingContext,
11051+
ObjectClassification,
11052+
ObjectType,
11053+
PO};
1103611054
}
1103711055

1103811056
void OverloadCandidateSet::AddDeferredConversionTemplateCandidate(
@@ -11041,18 +11059,26 @@ void OverloadCandidateSet::AddDeferredConversionTemplateCandidate(
1104111059
bool AllowObjCConversionOnExplicit, bool AllowExplicit,
1104211060
bool AllowResultConversion) {
1104311061

11044-
DeferredConversionTemplateOverloadCandidate C{
11045-
FunctionTemplate, FoundDecl,
11046-
ActingContext, From,
11047-
ToType, AllowObjCConversionOnExplicit,
11048-
AllowExplicit, AllowResultConversion};
11062+
auto *C =
11063+
allocateDeferredCandidate<DeferredConversionTemplateOverloadCandidate>();
1104911064

11050-
DeferredCandidates.emplace_back(std::move(C));
11065+
C = new (C) DeferredConversionTemplateOverloadCandidate{
11066+
{nullptr, DeferredFunctionTemplateOverloadCandidate::Conversion,
11067+
AllowObjCConversionOnExplicit, AllowResultConversion,
11068+
/*AllowExplicit=*/false,
11069+
/*SuppressUserConversions=*/false,
11070+
/*PartialOverloading*/ false,
11071+
/*AggregateCandidateDeduction=*/false},
11072+
FunctionTemplate,
11073+
FoundDecl,
11074+
ActingContext,
11075+
From,
11076+
ToType};
1105111077
}
1105211078

1105311079
static void
1105411080
AddTemplateOverloadCandidate(Sema &S, OverloadCandidateSet &CandidateSet,
11055-
DeferredMethodTemplateOverloadCandidate &&C) {
11081+
DeferredMethodTemplateOverloadCandidate &C) {
1105611082

1105711083
AddMethodTemplateCandidateImmediately(
1105811084
S, CandidateSet, C.FunctionTemplate, C.FoundDecl, C.ActingContext,
@@ -11062,7 +11088,7 @@ AddTemplateOverloadCandidate(Sema &S, OverloadCandidateSet &CandidateSet,
1106211088

1106311089
static void
1106411090
AddTemplateOverloadCandidate(Sema &S, OverloadCandidateSet &CandidateSet,
11065-
DeferredFunctionTemplateOverloadCandidate &&C) {
11091+
DeferredFunctionTemplateOverloadCandidate &C) {
1106611092
AddTemplateOverloadCandidateImmediately(
1106711093
S, CandidateSet, C.FunctionTemplate, C.FoundDecl,
1106811094
/*ExplicitTemplateArgs=*/nullptr, C.Args, C.SuppressUserConversions,
@@ -11072,23 +11098,38 @@ AddTemplateOverloadCandidate(Sema &S, OverloadCandidateSet &CandidateSet,
1107211098

1107311099
static void
1107411100
AddTemplateOverloadCandidate(Sema &S, OverloadCandidateSet &CandidateSet,
11075-
DeferredConversionTemplateOverloadCandidate &&C) {
11101+
DeferredConversionTemplateOverloadCandidate &C) {
1107611102
return AddTemplateConversionCandidateImmediately(
1107711103
S, CandidateSet, C.FunctionTemplate, C.FoundDecl, C.ActingContext, C.From,
1107811104
C.ToType, C.AllowObjCConversionOnExplicit, C.AllowExplicit,
1107911105
C.AllowResultConversion);
1108011106
}
1108111107

1108211108
void OverloadCandidateSet::InjectNonDeducedTemplateCandidates(Sema &S) {
11083-
Candidates.reserve(Candidates.size() + DeferredCandidates.size());
11084-
for (auto &&Elem : DeferredCandidates) {
11085-
std::visit(
11086-
[&](auto &&Cand) {
11087-
AddTemplateOverloadCandidate(S, *this, std::move(Cand));
11088-
},
11089-
Elem);
11109+
Candidates.reserve(Candidates.size() + DeferredCandidatesCount);
11110+
DeferredTemplateOverloadCandidate *Cand = FirstDeferredCandidate;
11111+
while (Cand) {
11112+
switch (Cand->Kind) {
11113+
case DeferredTemplateOverloadCandidate::Function:
11114+
AddTemplateOverloadCandidate(
11115+
S, *this,
11116+
*static_cast<DeferredFunctionTemplateOverloadCandidate *>(Cand));
11117+
break;
11118+
case DeferredTemplateOverloadCandidate::Method:
11119+
AddTemplateOverloadCandidate(
11120+
S, *this,
11121+
*static_cast<DeferredMethodTemplateOverloadCandidate *>(Cand));
11122+
break;
11123+
case DeferredTemplateOverloadCandidate::Conversion:
11124+
AddTemplateOverloadCandidate(
11125+
S, *this,
11126+
*static_cast<DeferredConversionTemplateOverloadCandidate *>(Cand));
11127+
break;
11128+
}
11129+
Cand = Cand->Next;
1109011130
}
11091-
DeferredCandidates.clear();
11131+
FirstDeferredCandidate = nullptr;
11132+
DeferredCandidatesCount = 0;
1109211133
}
1109311134

1109411135
OverloadingResult
@@ -11151,10 +11192,10 @@ OverloadingResult OverloadCandidateSet::BestViableFunction(Sema &S,
1115111192
iterator &Best) {
1115211193

1115311194
assert(shouldDeferTemplateArgumentDeduction(S.getLangOpts()) ||
11154-
DeferredCandidates.empty() &&
11195+
DeferredCandidatesCount == 0 &&
1115511196
"Unexpected deferred template candidate");
1115611197

11157-
bool TwoPhaseResolution = !DeferredCandidates.empty();
11198+
bool TwoPhaseResolution = DeferredCandidatesCount != 0;
1115811199

1115911200
if (TwoPhaseResolution) {
1116011201

@@ -11265,7 +11306,7 @@ OverloadingResult OverloadCandidateSet::BestViableFunctionImpl(
1126511306

1126611307
OverloadingResult R = ResultForBestCandidate(Best);
1126711308

11268-
if (DeferredCandidates.empty() && !EquivalentCands.empty())
11309+
if (!EquivalentCands.empty())
1126911310
S.diagnoseEquivalentInternalLinkageDeclarations(Loc, Best->Function,
1127011311
EquivalentCands);
1127111312
return R;

0 commit comments

Comments
 (0)