Index: include/clang/AST/Decl.h =================================================================== --- include/clang/AST/Decl.h +++ include/clang/AST/Decl.h @@ -26,6 +26,7 @@ #include "llvm/ADT/Optional.h" #include "llvm/Support/Compiler.h" #include "llvm/Support/raw_ostream.h" +#include "llvm/Support/TrailingObjects.h" namespace clang { struct ASTTemplateArgumentListInfo; @@ -3626,7 +3627,15 @@ /// \brief This represents the body of a CapturedStmt, and serves as its /// DeclContext. -class CapturedDecl : public Decl, public DeclContext { +class CapturedDecl final + : public Decl, + public DeclContext, + private llvm::TrailingObjects { +protected: + size_t numTrailingObjects(OverloadToken) { + return NumParams; + } + private: /// \brief The number of parameters to the outlined function. unsigned NumParams; @@ -3639,9 +3648,12 @@ : Decl(Captured, DC, SourceLocation()), DeclContext(Captured), NumParams(NumParams), ContextParam(0), BodyAndNothrow(nullptr, false) { } - ImplicitParamDecl **getParams() const { - return reinterpret_cast( - const_cast(this) + 1); + ImplicitParamDecl *const *getParams() const { + return getTrailingObjects(); + } + + ImplicitParamDecl **getParams() { + return getTrailingObjects(); } public: @@ -3679,7 +3691,7 @@ } unsigned getContextParamPosition() const { return ContextParam; } - typedef ImplicitParamDecl **param_iterator; + typedef ImplicitParamDecl *const *param_iterator; typedef llvm::iterator_range param_range; /// \brief Retrieve an iterator pointing to the first parameter decl. @@ -3702,6 +3714,7 @@ friend class ASTDeclReader; friend class ASTDeclWriter; + friend TrailingObjects; }; /// \brief Describes a module import declaration, which makes the contents @@ -3714,7 +3727,8 @@ /// /// Import declarations can also be implicitly generated from /// \#include/\#import directives. -class ImportDecl : public Decl { +class ImportDecl final : public Decl, + llvm::TrailingObjects { /// \brief The imported module, along with a bit that indicates whether /// we have source-location information for each identifier in the module /// name. @@ -3730,7 +3744,8 @@ friend class ASTReader; friend class ASTDeclReader; friend class ASTContext; - + friend TrailingObjects; + ImportDecl(DeclContext *DC, SourceLocation StartLoc, Module *Imported, ArrayRef IdentifierLocs); Index: include/clang/AST/DeclTemplate.h =================================================================== --- include/clang/AST/DeclTemplate.h +++ include/clang/AST/DeclTemplate.h @@ -20,6 +20,7 @@ #include "clang/AST/TemplateBase.h" #include "llvm/ADT/PointerUnion.h" #include "llvm/Support/Compiler.h" +#include "llvm/Support/TrailingObjects.h" #include namespace clang { @@ -43,7 +44,9 @@ /// \brief Stores a list of template parameters for a TemplateDecl and its /// derived classes. -class LLVM_ALIGNAS(/*alignof(void*)*/ LLVM_PTR_SIZE) TemplateParameterList { +class LLVM_ALIGNAS(/*alignof(void*)*/ LLVM_PTR_SIZE) TemplateParameterList final + : private llvm::TrailingObjects { + /// The location of the 'template' keyword. SourceLocation TemplateLoc; @@ -59,6 +62,10 @@ unsigned ContainsUnexpandedParameterPack : 1; protected: + size_t numTrailingObjects(OverloadToken) const { + return NumParams; + } + TemplateParameterList(SourceLocation TemplateLoc, SourceLocation LAngleLoc, NamedDecl **Params, unsigned NumParams, SourceLocation RAngleLoc); @@ -77,10 +84,8 @@ /// \brief Iterates through the template parameters in this list. typedef NamedDecl* const* const_iterator; - iterator begin() { return reinterpret_cast(this + 1); } - const_iterator begin() const { - return reinterpret_cast(this + 1); - } + iterator begin() { return getTrailingObjects(); } + const_iterator begin() const { return getTrailingObjects(); } iterator end() { return begin() + NumParams; } const_iterator end() const { return begin() + NumParams; } @@ -130,29 +135,45 @@ SourceRange getSourceRange() const LLVM_READONLY { return SourceRange(TemplateLoc, RAngleLoc); } + + friend TrailingObjects; + template friend class FixedSizeTemplateParameterListStorage; }; /// \brief Stores a list of template parameters for a TemplateDecl and its /// derived classes. Suitable for creating on the stack. -template -class FixedSizeTemplateParameterList : public TemplateParameterList { +template class FixedSizeTemplateParameterListStorage { + // This is kinda ugly: TemplateParameterList usually gets allocated + // in a block of memory with NamedDecls appended to it. Here, to get + // it stack allocated, we include the params as a separate + // variable. After allocation, the TemplateParameterList object + // treats them as part of itself. + TemplateParameterList List; NamedDecl *Params[N]; public: - FixedSizeTemplateParameterList(SourceLocation TemplateLoc, - SourceLocation LAngleLoc, - NamedDecl **Params, SourceLocation RAngleLoc) : - TemplateParameterList(TemplateLoc, LAngleLoc, Params, N, RAngleLoc) { - } + FixedSizeTemplateParameterListStorage(SourceLocation TemplateLoc, + SourceLocation LAngleLoc, + NamedDecl **Params, + SourceLocation RAngleLoc) + : List(TemplateLoc, LAngleLoc, Params, N, RAngleLoc) { + // Because we're doing an evil layout hack above, have some + // asserts, just to double-check everything is laid out like + // expected. + assert(sizeof(*this) == + TemplateParameterList::totalSizeToAlloc(N) && + "Object layout not as expected"); + assert(this->Params == List.getTrailingObjects() && + "Object layout not as expected"); + } + TemplateParameterList *get() { return &List; } }; /// \brief A template argument list. -class TemplateArgumentList { +class TemplateArgumentList final + : private llvm::TrailingObjects { /// \brief The template argument list. - /// - /// The integer value will be non-zero to indicate that this - /// template argument list does own the pointer. - llvm::PointerIntPair Arguments; + const TemplateArgument *Arguments; /// \brief The number of template arguments in this template /// argument list. @@ -161,9 +182,9 @@ TemplateArgumentList(const TemplateArgumentList &Other) = delete; void operator=(const TemplateArgumentList &Other) = delete; - TemplateArgumentList(const TemplateArgument *Args, unsigned NumArgs, - bool Owned) - : Arguments(Args, Owned), NumArguments(NumArgs) { } + // Constructs an instance with an internal Argument list, containing + // a copy of the Args array. (Called by CreateCopy) + TemplateArgumentList(const TemplateArgument *Args, unsigned NumArgs); public: /// \brief Type used to indicate that the template argument list itself is a @@ -180,9 +201,9 @@ /// /// The template argument list does not own the template arguments /// provided. - explicit TemplateArgumentList(OnStackType, - const TemplateArgument *Args, unsigned NumArgs) - : Arguments(Args, false), NumArguments(NumArgs) { } + explicit TemplateArgumentList(OnStackType, const TemplateArgument *Args, + unsigned NumArgs) + : Arguments(Args), NumArguments(NumArgs) {} /// \brief Produces a shallow copy of the given template argument list. /// @@ -191,7 +212,7 @@ /// constructor, since this really really isn't safe to use that /// way. explicit TemplateArgumentList(const TemplateArgumentList *Other) - : Arguments(Other->data(), false), NumArguments(Other->size()) { } + : Arguments(Other->data()), NumArguments(Other->size()) {} /// \brief Retrieve the template argument at a given index. const TemplateArgument &get(unsigned Idx) const { @@ -212,9 +233,9 @@ unsigned size() const { return NumArguments; } /// \brief Retrieve a pointer to the template argument list. - const TemplateArgument *data() const { - return Arguments.getPointer(); - } + const TemplateArgument *data() const { return Arguments; } + + friend TrailingObjects; }; void *allocateDefaultArgStorageChain(const ASTContext &C); @@ -543,7 +564,10 @@ /// }; /// \endcode class LLVM_ALIGNAS(/*alignof(uint64_t)*/ 8) - DependentFunctionTemplateSpecializationInfo { + DependentFunctionTemplateSpecializationInfo final + : private llvm::TrailingObjects { /// The number of potential template candidates. unsigned NumTemplates; @@ -553,16 +577,22 @@ /// The locations of the left and right angle brackets. SourceRange AngleLocs; - FunctionTemplateDecl * const *getTemplates() const { - return reinterpret_cast( - &getTemplateArgs()[NumArgs]); + size_t numTrailingObjects(OverloadToken) const { + return NumArgs; + } + size_t numTrailingObjects(OverloadToken) const { + return NumTemplates; } -public: DependentFunctionTemplateSpecializationInfo( const UnresolvedSetImpl &Templates, const TemplateArgumentListInfo &TemplateArgs); +public: + static DependentFunctionTemplateSpecializationInfo * + Create(ASTContext &Context, const UnresolvedSetImpl &Templates, + const TemplateArgumentListInfo &TemplateArgs); + /// \brief Returns the number of function templates that this might /// be a specialization of. unsigned getNumTemplates() const { return NumTemplates; } @@ -570,12 +600,12 @@ /// \brief Returns the i'th template candidate. FunctionTemplateDecl *getTemplate(unsigned I) const { assert(I < getNumTemplates() && "template index out of range"); - return getTemplates()[I]; + return getTrailingObjects()[I]; } /// \brief Returns the explicit template arguments that were given. const TemplateArgumentLoc *getTemplateArgs() const { - return reinterpret_cast(this + 1); + return getTrailingObjects(); } /// \brief Returns the number of explicit template arguments that were given. @@ -594,6 +624,8 @@ SourceLocation getRAngleLoc() const { return AngleLocs.getEnd(); } + + friend TrailingObjects; }; /// Declaration of a redeclarable template. @@ -1108,8 +1140,11 @@ /// @code /// template class array { }; /// @endcode -class NonTypeTemplateParmDecl - : public DeclaratorDecl, protected TemplateParmPosition { +class NonTypeTemplateParmDecl final + : public DeclaratorDecl, + protected TemplateParmPosition, + private llvm::TrailingObjects> { /// \brief The default template argument, if any, and whether or not /// it was inherited. typedef DefaultArgStorage DefArgStorage; @@ -1129,6 +1164,11 @@ /// \brief The number of types in an expanded parameter pack. unsigned NumExpandedTypes; + size_t numTrailingObjects( + OverloadToken>) const { + return NumExpandedTypes; + } + NonTypeTemplateParmDecl(DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, unsigned D, unsigned P, IdentifierInfo *Id, QualType T, @@ -1147,6 +1187,7 @@ TypeSourceInfo **ExpandedTInfos); friend class ASTDeclReader; + friend TrailingObjects; public: static NonTypeTemplateParmDecl * @@ -1262,16 +1303,18 @@ /// pack. QualType getExpansionType(unsigned I) const { assert(I < NumExpandedTypes && "Out-of-range expansion type index"); - void * const *TypesAndInfos = reinterpret_cast(this + 1); - return QualType::getFromOpaquePtr(TypesAndInfos[2*I]); + auto TypesAndInfos = + getTrailingObjects>(); + return TypesAndInfos[I].first; } /// \brief Retrieve a particular expansion type source info within an /// expanded parameter pack. TypeSourceInfo *getExpansionTypeSourceInfo(unsigned I) const { assert(I < NumExpandedTypes && "Out-of-range expansion type index"); - void * const *TypesAndInfos = reinterpret_cast(this + 1); - return static_cast(TypesAndInfos[2*I+1]); + auto TypesAndInfos = + getTrailingObjects>(); + return TypesAndInfos[I].second; } // Implement isa/cast/dyncast/etc. @@ -1286,9 +1329,11 @@ /// @endcode /// A template template parameter is a TemplateDecl because it defines the /// name of a template and the template parameters allowable for substitution. -class TemplateTemplateParmDecl : public TemplateDecl, - protected TemplateParmPosition -{ +class TemplateTemplateParmDecl final + : public TemplateDecl, + protected TemplateParmPosition, + private llvm::TrailingObjects { void anchor() override; /// \brief The default template argument, if any. @@ -1392,7 +1437,7 @@ /// pack. TemplateParameterList *getExpansionTemplateParameters(unsigned I) const { assert(I < NumExpandedParams && "Out-of-range expansion type index"); - return reinterpret_cast(this + 1)[I]; + return getTrailingObjects()[I]; } const DefArgStorage &getDefaultArgStorage() const { return DefaultArgument; } @@ -1442,6 +1487,7 @@ friend class ASTDeclReader; friend class ASTDeclWriter; + friend TrailingObjects; }; /// \brief Represents a class template specialization, which refers to Index: lib/AST/Decl.cpp =================================================================== --- lib/AST/Decl.cpp +++ lib/AST/Decl.cpp @@ -3108,33 +3108,35 @@ const UnresolvedSetImpl &Templates, const TemplateArgumentListInfo &TemplateArgs) { assert(TemplateOrSpecialization.isNull()); - size_t Size = sizeof(DependentFunctionTemplateSpecializationInfo); - Size += TemplateArgs.size() * sizeof(TemplateArgumentLoc); - Size += Templates.size() * sizeof(FunctionTemplateDecl *); - void *Buffer = Context.Allocate(Size); DependentFunctionTemplateSpecializationInfo *Info = - new (Buffer) DependentFunctionTemplateSpecializationInfo(Templates, - TemplateArgs); + DependentFunctionTemplateSpecializationInfo::Create(Context, Templates, + TemplateArgs); TemplateOrSpecialization = Info; } +DependentFunctionTemplateSpecializationInfo * +DependentFunctionTemplateSpecializationInfo::Create( + ASTContext &Context, const UnresolvedSetImpl &Ts, + const TemplateArgumentListInfo &TArgs) { + void *Buffer = Context.Allocate( + totalSizeToAlloc( + TArgs.size(), Ts.size())); + return new (Buffer) DependentFunctionTemplateSpecializationInfo(Ts, TArgs); +} + DependentFunctionTemplateSpecializationInfo:: DependentFunctionTemplateSpecializationInfo(const UnresolvedSetImpl &Ts, const TemplateArgumentListInfo &TArgs) : AngleLocs(TArgs.getLAngleLoc(), TArgs.getRAngleLoc()) { - static_assert(sizeof(*this) % llvm::AlignOf::Alignment == 0, - "Trailing data is unaligned!"); NumTemplates = Ts.size(); NumArgs = TArgs.size(); - FunctionTemplateDecl **TsArray = - const_cast(getTemplates()); + FunctionTemplateDecl **TsArray = getTrailingObjects(); for (unsigned I = 0, E = Ts.size(); I != E; ++I) TsArray[I] = cast(Ts[I]->getUnderlyingDecl()); - TemplateArgumentLoc *ArgsArray = - const_cast(getTemplateArgs()); + TemplateArgumentLoc *ArgsArray = getTrailingObjects(); for (unsigned I = 0, E = TArgs.size(); I != E; ++I) new (&ArgsArray[I]) TemplateArgumentLoc(TArgs[I]); } @@ -3874,13 +3876,13 @@ CapturedDecl *CapturedDecl::Create(ASTContext &C, DeclContext *DC, unsigned NumParams) { - return new (C, DC, NumParams * sizeof(ImplicitParamDecl *)) + return new (C, DC, additionalSizeToAlloc(NumParams)) CapturedDecl(DC, NumParams); } CapturedDecl *CapturedDecl::CreateDeserialized(ASTContext &C, unsigned ID, unsigned NumParams) { - return new (C, ID, NumParams * sizeof(ImplicitParamDecl *)) + return new (C, ID, additionalSizeToAlloc(NumParams)) CapturedDecl(nullptr, NumParams); } @@ -4025,9 +4027,9 @@ NextLocalImport() { assert(getNumModuleIdentifiers(Imported) == IdentifierLocs.size()); - SourceLocation *StoredLocs = reinterpret_cast(this + 1); - memcpy(StoredLocs, IdentifierLocs.data(), - IdentifierLocs.size() * sizeof(SourceLocation)); + SourceLocation *StoredLocs = getTrailingObjects(); + std::uninitialized_copy(IdentifierLocs.begin(), IdentifierLocs.end(), + StoredLocs); } ImportDecl::ImportDecl(DeclContext *DC, SourceLocation StartLoc, @@ -4035,13 +4037,14 @@ : Decl(Import, DC, StartLoc), ImportedAndComplete(Imported, false), NextLocalImport() { - *reinterpret_cast(this + 1) = EndLoc; + *getTrailingObjects() = EndLoc; } ImportDecl *ImportDecl::Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, Module *Imported, ArrayRef IdentifierLocs) { - return new (C, DC, IdentifierLocs.size() * sizeof(SourceLocation)) + return new (C, DC, + additionalSizeToAlloc(IdentifierLocs.size())) ImportDecl(DC, StartLoc, Imported, IdentifierLocs); } @@ -4049,16 +4052,15 @@ SourceLocation StartLoc, Module *Imported, SourceLocation EndLoc) { - ImportDecl *Import = - new (C, DC, sizeof(SourceLocation)) ImportDecl(DC, StartLoc, - Imported, EndLoc); + ImportDecl *Import = new (C, DC, additionalSizeToAlloc(1)) + ImportDecl(DC, StartLoc, Imported, EndLoc); Import->setImplicit(); return Import; } ImportDecl *ImportDecl::CreateDeserialized(ASTContext &C, unsigned ID, unsigned NumLocations) { - return new (C, ID, NumLocations * sizeof(SourceLocation)) + return new (C, ID, additionalSizeToAlloc(NumLocations)) ImportDecl(EmptyShell()); } @@ -4066,16 +4068,14 @@ if (!ImportedAndComplete.getInt()) return None; - const SourceLocation *StoredLocs - = reinterpret_cast(this + 1); + const SourceLocation *StoredLocs = getTrailingObjects(); return llvm::makeArrayRef(StoredLocs, getNumModuleIdentifiers(getImportedModule())); } SourceRange ImportDecl::getSourceRange() const { if (!ImportedAndComplete.getInt()) - return SourceRange(getLocation(), - *reinterpret_cast(this + 1)); - + return SourceRange(getLocation(), *getTrailingObjects()); + return SourceRange(getLocation(), getIdentifierLocs().back()); } Index: lib/AST/DeclTemplate.cpp =================================================================== --- lib/AST/DeclTemplate.cpp +++ lib/AST/DeclTemplate.cpp @@ -57,11 +57,8 @@ TemplateParameterList::Create(const ASTContext &C, SourceLocation TemplateLoc, SourceLocation LAngleLoc, NamedDecl **Params, unsigned NumParams, SourceLocation RAngleLoc) { - unsigned Size = sizeof(TemplateParameterList) - + sizeof(NamedDecl *) * NumParams; - unsigned Align = std::max(llvm::alignOf(), - llvm::alignOf()); - void *Mem = C.Allocate(Size, Align); + void *Mem = C.Allocate(totalSizeToAlloc(NumParams), + llvm::alignOf()); return new (Mem) TemplateParameterList(TemplateLoc, LAngleLoc, Params, NumParams, RAngleLoc); } @@ -552,10 +549,11 @@ TemplateParmPosition(D, P), ParameterPack(true), ExpandedParameterPack(true), NumExpandedTypes(NumExpandedTypes) { if (ExpandedTypes && ExpandedTInfos) { - void **TypesAndInfos = reinterpret_cast(this + 1); + auto TypesAndInfos = + getTrailingObjects>(); for (unsigned I = 0; I != NumExpandedTypes; ++I) { - TypesAndInfos[2*I] = ExpandedTypes[I].getAsOpaquePtr(); - TypesAndInfos[2*I + 1] = ExpandedTInfos[I]; + TypesAndInfos[I].first = ExpandedTypes[I]; + TypesAndInfos[I].second = ExpandedTInfos[I]; } } } @@ -579,10 +577,11 @@ const QualType *ExpandedTypes, unsigned NumExpandedTypes, TypeSourceInfo **ExpandedTInfos) { - unsigned Extra = NumExpandedTypes * 2 * sizeof(void*); - return new (C, DC, Extra) NonTypeTemplateParmDecl( - DC, StartLoc, IdLoc, D, P, Id, T, TInfo, - ExpandedTypes, NumExpandedTypes, ExpandedTInfos); + return new (C, DC, + additionalSizeToAlloc>( + NumExpandedTypes)) + NonTypeTemplateParmDecl(DC, StartLoc, IdLoc, D, P, Id, T, TInfo, + ExpandedTypes, NumExpandedTypes, ExpandedTInfos); } NonTypeTemplateParmDecl * @@ -595,10 +594,12 @@ NonTypeTemplateParmDecl * NonTypeTemplateParmDecl::CreateDeserialized(ASTContext &C, unsigned ID, unsigned NumExpandedTypes) { - unsigned Extra = NumExpandedTypes * 2 * sizeof(void*); - return new (C, ID, Extra) NonTypeTemplateParmDecl( - nullptr, SourceLocation(), SourceLocation(), 0, 0, nullptr, QualType(), - nullptr, nullptr, NumExpandedTypes, nullptr); + return new (C, ID, + additionalSizeToAlloc>( + NumExpandedTypes)) + NonTypeTemplateParmDecl(nullptr, SourceLocation(), SourceLocation(), 0, 0, + nullptr, QualType(), nullptr, nullptr, + NumExpandedTypes, nullptr); } SourceRange NonTypeTemplateParmDecl::getSourceRange() const { @@ -628,8 +629,8 @@ TemplateParmPosition(D, P), ParameterPack(true), ExpandedParameterPack(true), NumExpandedParams(NumExpansions) { if (Expansions) - std::memcpy(reinterpret_cast(this + 1), Expansions, - sizeof(TemplateParameterList*) * NumExpandedParams); + std::uninitialized_copy(Expansions, Expansions + NumExpandedParams, + getTrailingObjects()); } TemplateTemplateParmDecl * @@ -647,9 +648,10 @@ IdentifierInfo *Id, TemplateParameterList *Params, ArrayRef Expansions) { - return new (C, DC, sizeof(TemplateParameterList*) * Expansions.size()) - TemplateTemplateParmDecl(DC, L, D, P, Id, Params, - Expansions.size(), Expansions.data()); + return new (C, DC, + additionalSizeToAlloc(Expansions.size())) + TemplateTemplateParmDecl(DC, L, D, P, Id, Params, Expansions.size(), + Expansions.data()); } TemplateTemplateParmDecl * @@ -661,7 +663,8 @@ TemplateTemplateParmDecl * TemplateTemplateParmDecl::CreateDeserialized(ASTContext &C, unsigned ID, unsigned NumExpansions) { - return new (C, ID, sizeof(TemplateParameterList*) * NumExpansions) + return new (C, ID, + additionalSizeToAlloc(NumExpansions)) TemplateTemplateParmDecl(nullptr, SourceLocation(), 0, 0, nullptr, nullptr, NumExpansions, nullptr); } @@ -682,18 +685,19 @@ //===----------------------------------------------------------------------===// // TemplateArgumentList Implementation //===----------------------------------------------------------------------===// +TemplateArgumentList::TemplateArgumentList(const TemplateArgument *Args, + unsigned NumArgs) + : Arguments(getTrailingObjects()), NumArguments(NumArgs) { + std::uninitialized_copy(Args, Args + NumArgs, + getTrailingObjects()); +} + TemplateArgumentList * TemplateArgumentList::CreateCopy(ASTContext &Context, const TemplateArgument *Args, unsigned NumArgs) { - std::size_t Size = sizeof(TemplateArgumentList) - + NumArgs * sizeof(TemplateArgument); - void *Mem = Context.Allocate(Size); - TemplateArgument *StoredArgs - = reinterpret_cast( - static_cast(Mem) + 1); - std::uninitialized_copy(Args, Args + NumArgs, StoredArgs); - return new (Mem) TemplateArgumentList(StoredArgs, NumArgs, true); + void *Mem = Context.Allocate(totalSizeToAlloc(NumArgs)); + return new (Mem) TemplateArgumentList(Args, NumArgs); } FunctionTemplateSpecializationInfo * Index: lib/Sema/SemaTemplateDeduction.cpp =================================================================== --- lib/Sema/SemaTemplateDeduction.cpp +++ lib/Sema/SemaTemplateDeduction.cpp @@ -3989,8 +3989,8 @@ nullptr, false, false); QualType TemplArg = QualType(TemplParam->getTypeForDecl(), 0); NamedDecl *TemplParamPtr = TemplParam; - FixedSizeTemplateParameterList<1> TemplateParams(Loc, Loc, &TemplParamPtr, - Loc); + FixedSizeTemplateParameterListStorage<1> TemplateParamsSt( + Loc, Loc, &TemplParamPtr, Loc); QualType FuncParam = SubstituteAutoTransform(*this, TemplArg).Apply(Type); assert(!FuncParam.isNull() && @@ -4007,20 +4007,19 @@ InitListExpr *InitList = dyn_cast(Init); if (InitList) { for (unsigned i = 0, e = InitList->getNumInits(); i < e; ++i) { - if (DeduceTemplateArgumentByListElement(*this, &TemplateParams, - TemplArg, - InitList->getInit(i), + if (DeduceTemplateArgumentByListElement(*this, TemplateParamsSt.get(), + TemplArg, InitList->getInit(i), Info, Deduced, TDF)) return DAR_Failed; } } else { - if (AdjustFunctionParmAndArgTypesForDeduction(*this, &TemplateParams, - FuncParam, InitType, Init, - TDF)) + if (AdjustFunctionParmAndArgTypesForDeduction( + *this, TemplateParamsSt.get(), FuncParam, InitType, Init, TDF)) return DAR_Failed; - if (DeduceTemplateArgumentsByTypeMatch(*this, &TemplateParams, FuncParam, - InitType, Info, Deduced, TDF)) + if (DeduceTemplateArgumentsByTypeMatch(*this, TemplateParamsSt.get(), + FuncParam, InitType, Info, Deduced, + TDF)) return DAR_Failed; }