head 1.1; branch 1.1.1; access; symbols netbsd-11-0-RC4:1.1.1.9 netbsd-11-0-RC3:1.1.1.9 netbsd-11-0-RC2:1.1.1.9 netbsd-11-0-RC1:1.1.1.9 perseant-exfatfs-base-20250801:1.1.1.9 netbsd-11:1.1.1.9.0.10 netbsd-11-base:1.1.1.9 netbsd-10-1-RELEASE:1.1.1.9 perseant-exfatfs-base-20240630:1.1.1.9 perseant-exfatfs:1.1.1.9.0.8 perseant-exfatfs-base:1.1.1.9 netbsd-8-3-RELEASE:1.1.1.6 netbsd-9-4-RELEASE:1.1.1.8 netbsd-10-0-RELEASE:1.1.1.9 netbsd-10-0-RC6:1.1.1.9 netbsd-10-0-RC5:1.1.1.9 netbsd-10-0-RC4:1.1.1.9 netbsd-10-0-RC3:1.1.1.9 netbsd-10-0-RC2:1.1.1.9 netbsd-10-0-RC1:1.1.1.9 netbsd-10:1.1.1.9.0.6 netbsd-10-base:1.1.1.9 netbsd-9-3-RELEASE:1.1.1.8 cjep_sun2x:1.1.1.9.0.4 cjep_sun2x-base:1.1.1.9 cjep_staticlib_x-base1:1.1.1.9 netbsd-9-2-RELEASE:1.1.1.8 cjep_staticlib_x:1.1.1.9.0.2 cjep_staticlib_x-base:1.1.1.9 netbsd-9-1-RELEASE:1.1.1.8 phil-wifi-20200421:1.1.1.9 phil-wifi-20200411:1.1.1.9 phil-wifi-20200406:1.1.1.9 netbsd-8-2-RELEASE:1.1.1.6 netbsd-9-0-RELEASE:1.1.1.8 netbsd-9-0-RC2:1.1.1.8 netbsd-9-0-RC1:1.1.1.8 netbsd-9:1.1.1.8.0.2 netbsd-9-base:1.1.1.8 phil-wifi-20190609:1.1.1.8 netbsd-8-1-RELEASE:1.1.1.6 netbsd-8-1-RC1:1.1.1.6 pgoyette-compat-merge-20190127:1.1.1.7.2.1 pgoyette-compat-20190127:1.1.1.8 pgoyette-compat-20190118:1.1.1.8 pgoyette-compat-1226:1.1.1.8 pgoyette-compat-1126:1.1.1.8 pgoyette-compat-1020:1.1.1.8 pgoyette-compat-0930:1.1.1.8 pgoyette-compat-0906:1.1.1.8 netbsd-7-2-RELEASE:1.1.1.3.2.1 pgoyette-compat-0728:1.1.1.8 clang-337282:1.1.1.8 netbsd-8-0-RELEASE:1.1.1.6 phil-wifi:1.1.1.7.0.4 phil-wifi-base:1.1.1.7 pgoyette-compat-0625:1.1.1.7 netbsd-8-0-RC2:1.1.1.6 pgoyette-compat-0521:1.1.1.7 pgoyette-compat-0502:1.1.1.7 pgoyette-compat-0422:1.1.1.7 netbsd-8-0-RC1:1.1.1.6 pgoyette-compat-0415:1.1.1.7 pgoyette-compat-0407:1.1.1.7 pgoyette-compat-0330:1.1.1.7 pgoyette-compat-0322:1.1.1.7 pgoyette-compat-0315:1.1.1.7 netbsd-7-1-2-RELEASE:1.1.1.3.2.1 pgoyette-compat:1.1.1.7.0.2 pgoyette-compat-base:1.1.1.7 netbsd-7-1-1-RELEASE:1.1.1.3.2.1 clang-319952:1.1.1.7 matt-nb8-mediatek:1.1.1.6.0.10 matt-nb8-mediatek-base:1.1.1.6 clang-309604:1.1.1.7 perseant-stdc-iso10646:1.1.1.6.0.8 perseant-stdc-iso10646-base:1.1.1.6 netbsd-8:1.1.1.6.0.6 netbsd-8-base:1.1.1.6 prg-localcount2-base3:1.1.1.6 prg-localcount2-base2:1.1.1.6 prg-localcount2-base1:1.1.1.6 prg-localcount2:1.1.1.6.0.4 prg-localcount2-base:1.1.1.6 pgoyette-localcount-20170426:1.1.1.6 bouyer-socketcan-base1:1.1.1.6 pgoyette-localcount-20170320:1.1.1.6 netbsd-7-1:1.1.1.3.2.1.0.6 netbsd-7-1-RELEASE:1.1.1.3.2.1 netbsd-7-1-RC2:1.1.1.3.2.1 clang-294123:1.1.1.6 netbsd-7-nhusb-base-20170116:1.1.1.3.2.1 bouyer-socketcan:1.1.1.6.0.2 bouyer-socketcan-base:1.1.1.6 clang-291444:1.1.1.6 pgoyette-localcount-20170107:1.1.1.5 netbsd-7-1-RC1:1.1.1.3.2.1 pgoyette-localcount-20161104:1.1.1.5 netbsd-7-0-2-RELEASE:1.1.1.3.2.1 localcount-20160914:1.1.1.5 netbsd-7-nhusb:1.1.1.3.2.1.0.4 netbsd-7-nhusb-base:1.1.1.3.2.1 clang-280599:1.1.1.5 pgoyette-localcount-20160806:1.1.1.5 pgoyette-localcount-20160726:1.1.1.5 pgoyette-localcount:1.1.1.5.0.2 pgoyette-localcount-base:1.1.1.5 netbsd-7-0-1-RELEASE:1.1.1.3.2.1 clang-261930:1.1.1.5 netbsd-7-0:1.1.1.3.2.1.0.2 netbsd-7-0-RELEASE:1.1.1.3.2.1 netbsd-7-0-RC3:1.1.1.3.2.1 netbsd-7-0-RC2:1.1.1.3.2.1 netbsd-7-0-RC1:1.1.1.3.2.1 clang-237755:1.1.1.4 clang-232565:1.1.1.4 clang-227398:1.1.1.4 tls-maxphys-base:1.1.1.3 tls-maxphys:1.1.1.3.0.4 netbsd-7:1.1.1.3.0.2 netbsd-7-base:1.1.1.3 clang-215315:1.1.1.3 clang-209886:1.1.1.2 yamt-pagecache:1.1.1.1.0.4 yamt-pagecache-base9:1.1.1.1 tls-earlyentropy:1.1.1.1.0.2 tls-earlyentropy-base:1.1.1.2 riastradh-xf86-video-intel-2-7-1-pre-2-21-15:1.1.1.1 riastradh-drm2-base3:1.1.1.1 clang-202566:1.1.1.1 clang-201163:1.1.1.1 clang-199312:1.1.1.1 clang-198450:1.1.1.1 clang-196603:1.1.1.1 clang-195771:1.1.1.1 LLVM:1.1.1; locks; strict; comment @// @; 1.1 date 2013.11.28.14.14.52; author joerg; state Exp; branches 1.1.1.1; next ; commitid ow8OybrawrB1f3fx; 1.1.1.1 date 2013.11.28.14.14.52; author joerg; state Exp; branches 1.1.1.1.2.1 1.1.1.1.4.1; next 1.1.1.2; commitid ow8OybrawrB1f3fx; 1.1.1.2 date 2014.05.30.18.14.40; author joerg; state Exp; branches; next 1.1.1.3; commitid 8q0kdlBlCn09GACx; 1.1.1.3 date 2014.08.10.17.08.31; author joerg; state Exp; branches 1.1.1.3.2.1 1.1.1.3.4.1; next 1.1.1.4; commitid N85tXAN6Ex9VZPLx; 1.1.1.4 date 2015.01.29.19.57.29; author joerg; state Exp; branches; next 1.1.1.5; commitid mlISSizlPKvepX7y; 1.1.1.5 date 2016.02.27.22.12.03; author joerg; state Exp; branches 1.1.1.5.2.1; next 1.1.1.6; commitid tIimz3oDlh1NpBWy; 1.1.1.6 date 2017.01.11.10.34.33; author joerg; state Exp; branches; next 1.1.1.7; commitid CNnUNfII1jgNmxBz; 1.1.1.7 date 2017.08.01.19.34.50; author joerg; state Exp; branches 1.1.1.7.2.1 1.1.1.7.4.1; next 1.1.1.8; commitid pMuDy65V0VicSx1A; 1.1.1.8 date 2018.07.17.18.31.13; author joerg; state Exp; branches; next 1.1.1.9; commitid wDzL46ALjrCZgwKA; 1.1.1.9 date 2019.11.13.22.19.19; author joerg; state dead; branches; next ; commitid QD8YATxuNG34YJKB; 1.1.1.1.2.1 date 2014.08.10.07.08.07; author tls; state Exp; branches; next ; commitid t01A1TLTYxkpGMLx; 1.1.1.1.4.1 date 2013.11.28.14.14.52; author yamt; state dead; branches; next 1.1.1.1.4.2; commitid WSrDtL5nYAUyiyBx; 1.1.1.1.4.2 date 2014.05.22.16.18.25; author yamt; state Exp; branches; next ; commitid WSrDtL5nYAUyiyBx; 1.1.1.3.2.1 date 2015.06.04.20.04.27; author snj; state Exp; branches; next ; commitid yRnjq9fueSo6n9oy; 1.1.1.3.4.1 date 2014.08.10.17.08.31; author tls; state dead; branches; next 1.1.1.3.4.2; commitid jTnpym9Qu0o4R1Nx; 1.1.1.3.4.2 date 2014.08.19.23.47.26; author tls; state Exp; branches; next ; commitid jTnpym9Qu0o4R1Nx; 1.1.1.5.2.1 date 2017.03.20.06.52.36; author pgoyette; state Exp; branches; next ; commitid jjw7cAwgyKq7RfKz; 1.1.1.7.2.1 date 2018.07.28.04.33.15; author pgoyette; state Exp; branches; next ; commitid 1UP1xAIUxv1ZgRLA; 1.1.1.7.4.1 date 2019.06.10.21.45.19; author christos; state Exp; branches; next 1.1.1.7.4.2; commitid jtc8rnCzWiEEHGqB; 1.1.1.7.4.2 date 2020.04.13.07.46.30; author martin; state dead; branches; next ; commitid X01YhRUPVUDaec4C; desc @@ 1.1 log @Initial revision @ text @//===--- TemplateBase.cpp - Common template AST class implementation ------===// // // The LLVM Compiler Infrastructure // // This file is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// // // This file implements common classes used throughout C++ template // representations. // //===----------------------------------------------------------------------===// #include "clang/AST/TemplateBase.h" #include "clang/AST/ASTContext.h" #include "clang/AST/DeclBase.h" #include "clang/AST/DeclTemplate.h" #include "clang/AST/Expr.h" #include "clang/AST/ExprCXX.h" #include "clang/AST/Type.h" #include "clang/AST/TypeLoc.h" #include "clang/Basic/Diagnostic.h" #include "llvm/ADT/FoldingSet.h" #include "llvm/ADT/SmallString.h" #include "llvm/Support/raw_ostream.h" #include using namespace clang; /// \brief Print a template integral argument value. /// /// \param TemplArg the TemplateArgument instance to print. /// /// \param Out the raw_ostream instance to use for printing. static void printIntegral(const TemplateArgument &TemplArg, raw_ostream &Out) { const ::clang::Type *T = TemplArg.getIntegralType().getTypePtr(); const llvm::APSInt &Val = TemplArg.getAsIntegral(); if (T->isBooleanType()) { Out << (Val.getBoolValue() ? "true" : "false"); } else if (T->isCharType()) { const char Ch = Val.getZExtValue(); Out << ((Ch == '\'') ? "'\\" : "'"); Out.write_escaped(StringRef(&Ch, 1), /*UseHexEscapes=*/ true); Out << "'"; } else { Out << Val; } } //===----------------------------------------------------------------------===// // TemplateArgument Implementation //===----------------------------------------------------------------------===// TemplateArgument::TemplateArgument(ASTContext &Ctx, const llvm::APSInt &Value, QualType Type) { Integer.Kind = Integral; // Copy the APSInt value into our decomposed form. Integer.BitWidth = Value.getBitWidth(); Integer.IsUnsigned = Value.isUnsigned(); // If the value is large, we have to get additional memory from the ASTContext unsigned NumWords = Value.getNumWords(); if (NumWords > 1) { void *Mem = Ctx.Allocate(NumWords * sizeof(uint64_t)); std::memcpy(Mem, Value.getRawData(), NumWords * sizeof(uint64_t)); Integer.pVal = static_cast(Mem); } else { Integer.VAL = Value.getZExtValue(); } Integer.Type = Type.getAsOpaquePtr(); } TemplateArgument TemplateArgument::CreatePackCopy(ASTContext &Context, const TemplateArgument *Args, unsigned NumArgs) { if (NumArgs == 0) return getEmptyPack(); TemplateArgument *Storage = new (Context) TemplateArgument [NumArgs]; std::copy(Args, Args + NumArgs, Storage); return TemplateArgument(Storage, NumArgs); } bool TemplateArgument::isDependent() const { switch (getKind()) { case Null: llvm_unreachable("Should not have a NULL template argument"); case Type: return getAsType()->isDependentType(); case Template: return getAsTemplate().isDependent(); case TemplateExpansion: return true; case Declaration: if (DeclContext *DC = dyn_cast(getAsDecl())) return DC->isDependentContext(); return getAsDecl()->getDeclContext()->isDependentContext(); case NullPtr: return false; case Integral: // Never dependent return false; case Expression: return (getAsExpr()->isTypeDependent() || getAsExpr()->isValueDependent()); case Pack: for (pack_iterator P = pack_begin(), PEnd = pack_end(); P != PEnd; ++P) { if (P->isDependent()) return true; } return false; } llvm_unreachable("Invalid TemplateArgument Kind!"); } bool TemplateArgument::isInstantiationDependent() const { switch (getKind()) { case Null: llvm_unreachable("Should not have a NULL template argument"); case Type: return getAsType()->isInstantiationDependentType(); case Template: return getAsTemplate().isInstantiationDependent(); case TemplateExpansion: return true; case Declaration: if (DeclContext *DC = dyn_cast(getAsDecl())) return DC->isDependentContext(); return getAsDecl()->getDeclContext()->isDependentContext(); case NullPtr: return false; case Integral: // Never dependent return false; case Expression: return getAsExpr()->isInstantiationDependent(); case Pack: for (pack_iterator P = pack_begin(), PEnd = pack_end(); P != PEnd; ++P) { if (P->isInstantiationDependent()) return true; } return false; } llvm_unreachable("Invalid TemplateArgument Kind!"); } bool TemplateArgument::isPackExpansion() const { switch (getKind()) { case Null: case Declaration: case Integral: case Pack: case Template: case NullPtr: return false; case TemplateExpansion: return true; case Type: return isa(getAsType()); case Expression: return isa(getAsExpr()); } llvm_unreachable("Invalid TemplateArgument Kind!"); } bool TemplateArgument::containsUnexpandedParameterPack() const { switch (getKind()) { case Null: case Declaration: case Integral: case TemplateExpansion: case NullPtr: break; case Type: if (getAsType()->containsUnexpandedParameterPack()) return true; break; case Template: if (getAsTemplate().containsUnexpandedParameterPack()) return true; break; case Expression: if (getAsExpr()->containsUnexpandedParameterPack()) return true; break; case Pack: for (pack_iterator P = pack_begin(), PEnd = pack_end(); P != PEnd; ++P) if (P->containsUnexpandedParameterPack()) return true; break; } return false; } Optional TemplateArgument::getNumTemplateExpansions() const { assert(getKind() == TemplateExpansion); if (TemplateArg.NumExpansions) return TemplateArg.NumExpansions - 1; return None; } void TemplateArgument::Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context) const { ID.AddInteger(getKind()); switch (getKind()) { case Null: break; case Type: getAsType().Profile(ID); break; case NullPtr: getNullPtrType().Profile(ID); break; case Declaration: ID.AddPointer(getAsDecl()? getAsDecl()->getCanonicalDecl() : 0); break; case Template: case TemplateExpansion: { TemplateName Template = getAsTemplateOrTemplatePattern(); if (TemplateTemplateParmDecl *TTP = dyn_cast_or_null( Template.getAsTemplateDecl())) { ID.AddBoolean(true); ID.AddInteger(TTP->getDepth()); ID.AddInteger(TTP->getPosition()); ID.AddBoolean(TTP->isParameterPack()); } else { ID.AddBoolean(false); ID.AddPointer(Context.getCanonicalTemplateName(Template) .getAsVoidPointer()); } break; } case Integral: getAsIntegral().Profile(ID); getIntegralType().Profile(ID); break; case Expression: getAsExpr()->Profile(ID, Context, true); break; case Pack: ID.AddInteger(Args.NumArgs); for (unsigned I = 0; I != Args.NumArgs; ++I) Args.Args[I].Profile(ID, Context); } } bool TemplateArgument::structurallyEquals(const TemplateArgument &Other) const { if (getKind() != Other.getKind()) return false; switch (getKind()) { case Null: case Type: case Expression: case Template: case TemplateExpansion: case NullPtr: return TypeOrValue.V == Other.TypeOrValue.V; case Declaration: return getAsDecl() == Other.getAsDecl() && isDeclForReferenceParam() && Other.isDeclForReferenceParam(); case Integral: return getIntegralType() == Other.getIntegralType() && getAsIntegral() == Other.getAsIntegral(); case Pack: if (Args.NumArgs != Other.Args.NumArgs) return false; for (unsigned I = 0, E = Args.NumArgs; I != E; ++I) if (!Args.Args[I].structurallyEquals(Other.Args.Args[I])) return false; return true; } llvm_unreachable("Invalid TemplateArgument Kind!"); } TemplateArgument TemplateArgument::getPackExpansionPattern() const { assert(isPackExpansion()); switch (getKind()) { case Type: return getAsType()->getAs()->getPattern(); case Expression: return cast(getAsExpr())->getPattern(); case TemplateExpansion: return TemplateArgument(getAsTemplateOrTemplatePattern()); case Declaration: case Integral: case Pack: case Null: case Template: case NullPtr: return TemplateArgument(); } llvm_unreachable("Invalid TemplateArgument Kind!"); } void TemplateArgument::print(const PrintingPolicy &Policy, raw_ostream &Out) const { switch (getKind()) { case Null: Out << ""; break; case Type: { PrintingPolicy SubPolicy(Policy); SubPolicy.SuppressStrongLifetime = true; getAsType().print(Out, SubPolicy); break; } case Declaration: { NamedDecl *ND = cast(getAsDecl()); Out << '&'; if (ND->getDeclName()) { // FIXME: distinguish between pointer and reference args? ND->printQualifiedName(Out); } else { Out << ""; } break; } case NullPtr: Out << "nullptr"; break; case Template: getAsTemplate().print(Out, Policy); break; case TemplateExpansion: getAsTemplateOrTemplatePattern().print(Out, Policy); Out << "..."; break; case Integral: { printIntegral(*this, Out); break; } case Expression: getAsExpr()->printPretty(Out, 0, Policy); break; case Pack: Out << "<"; bool First = true; for (TemplateArgument::pack_iterator P = pack_begin(), PEnd = pack_end(); P != PEnd; ++P) { if (First) First = false; else Out << ", "; P->print(Policy, Out); } Out << ">"; break; } } //===----------------------------------------------------------------------===// // TemplateArgumentLoc Implementation //===----------------------------------------------------------------------===// TemplateArgumentLocInfo::TemplateArgumentLocInfo() { memset((void*)this, 0, sizeof(TemplateArgumentLocInfo)); } SourceRange TemplateArgumentLoc::getSourceRange() const { switch (Argument.getKind()) { case TemplateArgument::Expression: return getSourceExpression()->getSourceRange(); case TemplateArgument::Declaration: return getSourceDeclExpression()->getSourceRange(); case TemplateArgument::NullPtr: return getSourceNullPtrExpression()->getSourceRange(); case TemplateArgument::Type: if (TypeSourceInfo *TSI = getTypeSourceInfo()) return TSI->getTypeLoc().getSourceRange(); else return SourceRange(); case TemplateArgument::Template: if (getTemplateQualifierLoc()) return SourceRange(getTemplateQualifierLoc().getBeginLoc(), getTemplateNameLoc()); return SourceRange(getTemplateNameLoc()); case TemplateArgument::TemplateExpansion: if (getTemplateQualifierLoc()) return SourceRange(getTemplateQualifierLoc().getBeginLoc(), getTemplateEllipsisLoc()); return SourceRange(getTemplateNameLoc(), getTemplateEllipsisLoc()); case TemplateArgument::Integral: return getSourceIntegralExpression()->getSourceRange(); case TemplateArgument::Pack: case TemplateArgument::Null: return SourceRange(); } llvm_unreachable("Invalid TemplateArgument Kind!"); } const DiagnosticBuilder &clang::operator<<(const DiagnosticBuilder &DB, const TemplateArgument &Arg) { switch (Arg.getKind()) { case TemplateArgument::Null: // This is bad, but not as bad as crashing because of argument // count mismatches. return DB << "(null template argument)"; case TemplateArgument::Type: return DB << Arg.getAsType(); case TemplateArgument::Declaration: return DB << Arg.getAsDecl(); case TemplateArgument::NullPtr: return DB << "nullptr"; case TemplateArgument::Integral: return DB << Arg.getAsIntegral().toString(10); case TemplateArgument::Template: return DB << Arg.getAsTemplate(); case TemplateArgument::TemplateExpansion: return DB << Arg.getAsTemplateOrTemplatePattern() << "..."; case TemplateArgument::Expression: { // This shouldn't actually ever happen, so it's okay that we're // regurgitating an expression here. // FIXME: We're guessing at LangOptions! SmallString<32> Str; llvm::raw_svector_ostream OS(Str); LangOptions LangOpts; LangOpts.CPlusPlus = true; PrintingPolicy Policy(LangOpts); Arg.getAsExpr()->printPretty(OS, 0, Policy); return DB << OS.str(); } case TemplateArgument::Pack: { // FIXME: We're guessing at LangOptions! SmallString<32> Str; llvm::raw_svector_ostream OS(Str); LangOptions LangOpts; LangOpts.CPlusPlus = true; PrintingPolicy Policy(LangOpts); Arg.print(Policy, OS); return DB << OS.str(); } } llvm_unreachable("Invalid TemplateArgument Kind!"); } const ASTTemplateArgumentListInfo * ASTTemplateArgumentListInfo::Create(ASTContext &C, const TemplateArgumentListInfo &List) { std::size_t size = ASTTemplateArgumentListInfo::sizeFor(List.size()); void *Mem = C.Allocate(size, llvm::alignOf()); ASTTemplateArgumentListInfo *TAI = new (Mem) ASTTemplateArgumentListInfo(); TAI->initializeFrom(List); return TAI; } void ASTTemplateArgumentListInfo::initializeFrom( const TemplateArgumentListInfo &Info) { LAngleLoc = Info.getLAngleLoc(); RAngleLoc = Info.getRAngleLoc(); NumTemplateArgs = Info.size(); TemplateArgumentLoc *ArgBuffer = getTemplateArgs(); for (unsigned i = 0; i != NumTemplateArgs; ++i) new (&ArgBuffer[i]) TemplateArgumentLoc(Info[i]); } void ASTTemplateArgumentListInfo::initializeFrom( const TemplateArgumentListInfo &Info, bool &Dependent, bool &InstantiationDependent, bool &ContainsUnexpandedParameterPack) { LAngleLoc = Info.getLAngleLoc(); RAngleLoc = Info.getRAngleLoc(); NumTemplateArgs = Info.size(); TemplateArgumentLoc *ArgBuffer = getTemplateArgs(); for (unsigned i = 0; i != NumTemplateArgs; ++i) { Dependent = Dependent || Info[i].getArgument().isDependent(); InstantiationDependent = InstantiationDependent || Info[i].getArgument().isInstantiationDependent(); ContainsUnexpandedParameterPack = ContainsUnexpandedParameterPack || Info[i].getArgument().containsUnexpandedParameterPack(); new (&ArgBuffer[i]) TemplateArgumentLoc(Info[i]); } } void ASTTemplateArgumentListInfo::copyInto( TemplateArgumentListInfo &Info) const { Info.setLAngleLoc(LAngleLoc); Info.setRAngleLoc(RAngleLoc); for (unsigned I = 0; I != NumTemplateArgs; ++I) Info.addArgument(getTemplateArgs()[I]); } std::size_t ASTTemplateArgumentListInfo::sizeFor(unsigned NumTemplateArgs) { return sizeof(ASTTemplateArgumentListInfo) + sizeof(TemplateArgumentLoc) * NumTemplateArgs; } void ASTTemplateKWAndArgsInfo::initializeFrom(SourceLocation TemplateKWLoc, const TemplateArgumentListInfo &Info) { Base::initializeFrom(Info); setTemplateKeywordLoc(TemplateKWLoc); } void ASTTemplateKWAndArgsInfo ::initializeFrom(SourceLocation TemplateKWLoc, const TemplateArgumentListInfo &Info, bool &Dependent, bool &InstantiationDependent, bool &ContainsUnexpandedParameterPack) { Base::initializeFrom(Info, Dependent, InstantiationDependent, ContainsUnexpandedParameterPack); setTemplateKeywordLoc(TemplateKWLoc); } void ASTTemplateKWAndArgsInfo::initializeFrom(SourceLocation TemplateKWLoc) { // No explicit template arguments, but template keyword loc is valid. assert(TemplateKWLoc.isValid()); LAngleLoc = SourceLocation(); RAngleLoc = SourceLocation(); NumTemplateArgs = 0; setTemplateKeywordLoc(TemplateKWLoc); } std::size_t ASTTemplateKWAndArgsInfo::sizeFor(unsigned NumTemplateArgs) { // Add space for the template keyword location. // FIXME: There's room for this in the padding before the template args in // 64-bit builds. return Base::sizeFor(NumTemplateArgs) + sizeof(SourceLocation); } @ 1.1.1.1 log @Import Clang 3.4rc1 r195771. @ text @@ 1.1.1.1.2.1 log @Rebase. @ text @d251 1 a251 1 ID.AddPointer(getAsDecl()? getAsDecl()->getCanonicalDecl() : nullptr); d348 1 a348 1 Out << "(no value)"; d365 1 a365 1 Out << "(anonymous)"; d389 1 a389 1 getAsExpr()->printPretty(Out, nullptr, Policy); d492 1 a492 1 Arg.getAsExpr()->printPretty(OS, nullptr, Policy); a513 2 assert(llvm::alignOf() >= llvm::alignOf()); @ 1.1.1.2 log @Import Clang 3.5svn r209886. @ text @d251 1 a251 1 ID.AddPointer(getAsDecl()? getAsDecl()->getCanonicalDecl() : nullptr); d348 1 a348 1 Out << "(no value)"; d365 1 a365 1 Out << "(anonymous)"; d389 1 a389 1 getAsExpr()->printPretty(Out, nullptr, Policy); d492 1 a492 1 Arg.getAsExpr()->printPretty(OS, nullptr, Policy); a513 2 assert(llvm::alignOf() >= llvm::alignOf()); @ 1.1.1.3 log @Import clang 3.6svn r215315. @ text @d117 2 a118 2 for (const auto &P : pack_elements()) if (P.isDependent()) d120 2 d158 2 a159 2 for (const auto &P : pack_elements()) if (P.isInstantiationDependent()) d161 2 d217 2 a218 2 for (const auto &P : pack_elements()) if (P.containsUnexpandedParameterPack()) d395 2 a396 1 for (const auto &P : pack_elements()) { d402 1 a402 1 P.print(Policy, Out); @ 1.1.1.3.2.1 log @Update LLVM to 3.6.1, requested by joerg in ticket 824. @ text @a35 2 /// /// \param Policy the printing policy for EnumConstantDecl printing. d37 1 a37 1 raw_ostream &Out, const PrintingPolicy& Policy) { a40 13 if (const EnumType *ET = T->getAs()) { for (const EnumConstantDecl* ECD : ET->getDecl()->enumerators()) { // In Sema::CheckTemplateArugment, enum template arguments value are // extended to the size of the integer underlying the enum type. This // may create a size difference between the enum value and template // argument value, requiring isSameValue here instead of operator==. if (llvm::APSInt::isSameValue(ECD->getInitVal(), Val)) { ECD->printQualifiedName(Out, Policy); return; } } } d93 1 a93 2 return getAsType()->isDependentType() || isa(getAsType()); d114 1 a114 2 return (getAsExpr()->isTypeDependent() || getAsExpr()->isValueDependent() || isa(getAsExpr())); d297 2 a298 1 return getAsDecl() == Other.getAsDecl(); d380 1 a380 1 printIntegral(*this, Out, Policy); @ 1.1.1.4 log @Import Clang 3.6RC1 r227398. @ text @a35 2 /// /// \param Policy the printing policy for EnumConstantDecl printing. d37 1 a37 1 raw_ostream &Out, const PrintingPolicy& Policy) { a40 13 if (const EnumType *ET = T->getAs()) { for (const EnumConstantDecl* ECD : ET->getDecl()->enumerators()) { // In Sema::CheckTemplateArugment, enum template arguments value are // extended to the size of the integer underlying the enum type. This // may create a size difference between the enum value and template // argument value, requiring isSameValue here instead of operator==. if (llvm::APSInt::isSameValue(ECD->getInitVal(), Val)) { ECD->printQualifiedName(Out, Policy); return; } } } d93 1 a93 2 return getAsType()->isDependentType() || isa(getAsType()); d114 1 a114 2 return (getAsExpr()->isTypeDependent() || getAsExpr()->isValueDependent() || isa(getAsExpr())); d297 2 a298 1 return getAsDecl() == Other.getAsDecl(); d380 1 a380 1 printIntegral(*this, Out, Policy); @ 1.1.1.5 log @Import Clang 3.8.0rc3 r261930. @ text @d56 1 a56 1 if (T->isBooleanType() && !Policy.MSVCFormatting) { d91 4 a94 4 TemplateArgument TemplateArgument::CreatePackCopy(ASTContext &Context, ArrayRef Args) { if (Args.empty()) d96 4 a99 2 return TemplateArgument(Args.copy(Context)); d525 3 a527 1 std::size_t size = totalSizeToAlloc(List.size()); d529 3 a531 1 return new (Mem) ASTTemplateArgumentListInfo(List); d534 2 a535 2 ASTTemplateArgumentListInfo::ASTTemplateArgumentListInfo( const TemplateArgumentListInfo &Info) { d540 1 a540 1 TemplateArgumentLoc *ArgBuffer = getTrailingObjects(); d545 5 a549 25 void ASTTemplateKWAndArgsInfo::initializeFrom( SourceLocation TemplateKWLoc, const TemplateArgumentListInfo &Info, TemplateArgumentLoc *OutArgArray) { this->TemplateKWLoc = TemplateKWLoc; LAngleLoc = Info.getLAngleLoc(); RAngleLoc = Info.getRAngleLoc(); NumTemplateArgs = Info.size(); for (unsigned i = 0; i != NumTemplateArgs; ++i) new (&OutArgArray[i]) TemplateArgumentLoc(Info[i]); } void ASTTemplateKWAndArgsInfo::initializeFrom(SourceLocation TemplateKWLoc) { assert(TemplateKWLoc.isValid()); LAngleLoc = SourceLocation(); RAngleLoc = SourceLocation(); this->TemplateKWLoc = TemplateKWLoc; NumTemplateArgs = 0; } void ASTTemplateKWAndArgsInfo::initializeFrom( SourceLocation TemplateKWLoc, const TemplateArgumentListInfo &Info, TemplateArgumentLoc *OutArgArray, bool &Dependent, bool &InstantiationDependent, bool &ContainsUnexpandedParameterPack) { this->TemplateKWLoc = TemplateKWLoc; d554 1 d557 1 a557 1 InstantiationDependent = InstantiationDependent || d559 2 a560 2 ContainsUnexpandedParameterPack = ContainsUnexpandedParameterPack || d563 1 a563 1 new (&OutArgArray[i]) TemplateArgumentLoc(Info[i]); d567 2 a568 2 void ASTTemplateKWAndArgsInfo::copyInto(const TemplateArgumentLoc *ArgArray, TemplateArgumentListInfo &Info) const { d572 43 a614 1 Info.addArgument(ArgArray[I]); @ 1.1.1.5.2.1 log @Sync with HEAD @ text @a245 25 QualType TemplateArgument::getNonTypeTemplateArgumentType() const { switch (getKind()) { case TemplateArgument::Null: case TemplateArgument::Type: case TemplateArgument::Template: case TemplateArgument::TemplateExpansion: case TemplateArgument::Pack: return QualType(); case TemplateArgument::Integral: return getIntegralType(); case TemplateArgument::Expression: return getAsExpr()->getType(); case TemplateArgument::Declaration: return getParamTypeForDecl(); case TemplateArgument::NullPtr: return getNullPtrType(); } llvm_unreachable("Invalid TemplateArgument Kind!"); } a417 9 void TemplateArgument::dump(raw_ostream &Out) const { LangOptions LO; // FIXME! see also TemplateName::dump(). LO.CPlusPlus = true; LO.Bool = true; print(PrintingPolicy(LO), Out); } LLVM_DUMP_METHOD void TemplateArgument::dump() const { dump(llvm::errs()); } d524 1 a524 1 void *Mem = C.Allocate(size, alignof(ASTTemplateArgumentListInfo)); @ 1.1.1.6 log @Import Clang pre-4.0.0 r291444. @ text @a245 25 QualType TemplateArgument::getNonTypeTemplateArgumentType() const { switch (getKind()) { case TemplateArgument::Null: case TemplateArgument::Type: case TemplateArgument::Template: case TemplateArgument::TemplateExpansion: case TemplateArgument::Pack: return QualType(); case TemplateArgument::Integral: return getIntegralType(); case TemplateArgument::Expression: return getAsExpr()->getType(); case TemplateArgument::Declaration: return getParamTypeForDecl(); case TemplateArgument::NullPtr: return getNullPtrType(); } llvm_unreachable("Invalid TemplateArgument Kind!"); } a417 9 void TemplateArgument::dump(raw_ostream &Out) const { LangOptions LO; // FIXME! see also TemplateName::dump(). LO.CPlusPlus = true; LO.Bool = true; print(PrintingPolicy(LO), Out); } LLVM_DUMP_METHOD void TemplateArgument::dump() const { dump(llvm::errs()); } d524 1 a524 1 void *Mem = C.Allocate(size, alignof(ASTTemplateArgumentListInfo)); @ 1.1.1.7 log @Import clang r309604 from branches/release_50 @ text @d456 4 @ 1.1.1.7.4.1 log @Sync with HEAD @ text @d1 1 a1 1 //===- TemplateBase.cpp - Common template AST class implementation --------===// a16 1 #include "clang/AST/Decl.h" a20 2 #include "clang/AST/PrettyPrinter.h" #include "clang/AST/TemplateName.h" a23 4 #include "clang/Basic/LLVM.h" #include "clang/Basic/LangOptions.h" #include "clang/Basic/SourceLocation.h" #include "llvm/ADT/APSInt.h" a24 1 #include "llvm/ADT/None.h" a25 4 #include "llvm/ADT/StringRef.h" #include "llvm/Support/Casting.h" #include "llvm/Support/Compiler.h" #include "llvm/Support/ErrorHandling.h" d27 1 a27 4 #include #include #include #include d31 1 a31 1 /// Print a template integral argument value. d40 1 a40 1 const Type *T = TemplArg.getIntegralType().getTypePtr(); d394 1 a394 1 NamedDecl *ND = getAsDecl(); d418 1 a418 1 case Integral: d421 1 @ 1.1.1.7.4.2 log @Mostly merge changes from HEAD upto 20200411 @ text @@ 1.1.1.7.2.1 log @Sync with HEAD @ text @d1 1 a1 1 //===- TemplateBase.cpp - Common template AST class implementation --------===// a16 1 #include "clang/AST/Decl.h" a20 2 #include "clang/AST/PrettyPrinter.h" #include "clang/AST/TemplateName.h" a23 4 #include "clang/Basic/LLVM.h" #include "clang/Basic/LangOptions.h" #include "clang/Basic/SourceLocation.h" #include "llvm/ADT/APSInt.h" a24 1 #include "llvm/ADT/None.h" a25 4 #include "llvm/ADT/StringRef.h" #include "llvm/Support/Casting.h" #include "llvm/Support/Compiler.h" #include "llvm/Support/ErrorHandling.h" d27 1 a27 4 #include #include #include #include d31 1 a31 1 /// Print a template integral argument value. d40 1 a40 1 const Type *T = TemplArg.getIntegralType().getTypePtr(); d394 1 a394 1 NamedDecl *ND = getAsDecl(); d418 1 a418 1 case Integral: d421 1 @ 1.1.1.8 log @Import clang r337282 from trunk @ text @d1 1 a1 1 //===- TemplateBase.cpp - Common template AST class implementation --------===// a16 1 #include "clang/AST/Decl.h" a20 2 #include "clang/AST/PrettyPrinter.h" #include "clang/AST/TemplateName.h" a23 4 #include "clang/Basic/LLVM.h" #include "clang/Basic/LangOptions.h" #include "clang/Basic/SourceLocation.h" #include "llvm/ADT/APSInt.h" a24 1 #include "llvm/ADT/None.h" a25 4 #include "llvm/ADT/StringRef.h" #include "llvm/Support/Casting.h" #include "llvm/Support/Compiler.h" #include "llvm/Support/ErrorHandling.h" d27 1 a27 4 #include #include #include #include d31 1 a31 1 /// Print a template integral argument value. d40 1 a40 1 const Type *T = TemplArg.getIntegralType().getTypePtr(); d394 1 a394 1 NamedDecl *ND = getAsDecl(); d418 1 a418 1 case Integral: d421 1 @ 1.1.1.9 log @Mark old LLVM instance as dead. @ text @@ 1.1.1.3.4.1 log @file TemplateBase.cpp was added on branch tls-maxphys on 2014-08-19 23:47:26 +0000 @ text @d1 599 @ 1.1.1.3.4.2 log @Rebase to HEAD as of a few days ago. @ text @a0 599 //===--- TemplateBase.cpp - Common template AST class implementation ------===// // // The LLVM Compiler Infrastructure // // This file is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// // // This file implements common classes used throughout C++ template // representations. // //===----------------------------------------------------------------------===// #include "clang/AST/TemplateBase.h" #include "clang/AST/ASTContext.h" #include "clang/AST/DeclBase.h" #include "clang/AST/DeclTemplate.h" #include "clang/AST/Expr.h" #include "clang/AST/ExprCXX.h" #include "clang/AST/Type.h" #include "clang/AST/TypeLoc.h" #include "clang/Basic/Diagnostic.h" #include "llvm/ADT/FoldingSet.h" #include "llvm/ADT/SmallString.h" #include "llvm/Support/raw_ostream.h" #include using namespace clang; /// \brief Print a template integral argument value. /// /// \param TemplArg the TemplateArgument instance to print. /// /// \param Out the raw_ostream instance to use for printing. static void printIntegral(const TemplateArgument &TemplArg, raw_ostream &Out) { const ::clang::Type *T = TemplArg.getIntegralType().getTypePtr(); const llvm::APSInt &Val = TemplArg.getAsIntegral(); if (T->isBooleanType()) { Out << (Val.getBoolValue() ? "true" : "false"); } else if (T->isCharType()) { const char Ch = Val.getZExtValue(); Out << ((Ch == '\'') ? "'\\" : "'"); Out.write_escaped(StringRef(&Ch, 1), /*UseHexEscapes=*/ true); Out << "'"; } else { Out << Val; } } //===----------------------------------------------------------------------===// // TemplateArgument Implementation //===----------------------------------------------------------------------===// TemplateArgument::TemplateArgument(ASTContext &Ctx, const llvm::APSInt &Value, QualType Type) { Integer.Kind = Integral; // Copy the APSInt value into our decomposed form. Integer.BitWidth = Value.getBitWidth(); Integer.IsUnsigned = Value.isUnsigned(); // If the value is large, we have to get additional memory from the ASTContext unsigned NumWords = Value.getNumWords(); if (NumWords > 1) { void *Mem = Ctx.Allocate(NumWords * sizeof(uint64_t)); std::memcpy(Mem, Value.getRawData(), NumWords * sizeof(uint64_t)); Integer.pVal = static_cast(Mem); } else { Integer.VAL = Value.getZExtValue(); } Integer.Type = Type.getAsOpaquePtr(); } TemplateArgument TemplateArgument::CreatePackCopy(ASTContext &Context, const TemplateArgument *Args, unsigned NumArgs) { if (NumArgs == 0) return getEmptyPack(); TemplateArgument *Storage = new (Context) TemplateArgument [NumArgs]; std::copy(Args, Args + NumArgs, Storage); return TemplateArgument(Storage, NumArgs); } bool TemplateArgument::isDependent() const { switch (getKind()) { case Null: llvm_unreachable("Should not have a NULL template argument"); case Type: return getAsType()->isDependentType(); case Template: return getAsTemplate().isDependent(); case TemplateExpansion: return true; case Declaration: if (DeclContext *DC = dyn_cast(getAsDecl())) return DC->isDependentContext(); return getAsDecl()->getDeclContext()->isDependentContext(); case NullPtr: return false; case Integral: // Never dependent return false; case Expression: return (getAsExpr()->isTypeDependent() || getAsExpr()->isValueDependent()); case Pack: for (const auto &P : pack_elements()) if (P.isDependent()) return true; return false; } llvm_unreachable("Invalid TemplateArgument Kind!"); } bool TemplateArgument::isInstantiationDependent() const { switch (getKind()) { case Null: llvm_unreachable("Should not have a NULL template argument"); case Type: return getAsType()->isInstantiationDependentType(); case Template: return getAsTemplate().isInstantiationDependent(); case TemplateExpansion: return true; case Declaration: if (DeclContext *DC = dyn_cast(getAsDecl())) return DC->isDependentContext(); return getAsDecl()->getDeclContext()->isDependentContext(); case NullPtr: return false; case Integral: // Never dependent return false; case Expression: return getAsExpr()->isInstantiationDependent(); case Pack: for (const auto &P : pack_elements()) if (P.isInstantiationDependent()) return true; return false; } llvm_unreachable("Invalid TemplateArgument Kind!"); } bool TemplateArgument::isPackExpansion() const { switch (getKind()) { case Null: case Declaration: case Integral: case Pack: case Template: case NullPtr: return false; case TemplateExpansion: return true; case Type: return isa(getAsType()); case Expression: return isa(getAsExpr()); } llvm_unreachable("Invalid TemplateArgument Kind!"); } bool TemplateArgument::containsUnexpandedParameterPack() const { switch (getKind()) { case Null: case Declaration: case Integral: case TemplateExpansion: case NullPtr: break; case Type: if (getAsType()->containsUnexpandedParameterPack()) return true; break; case Template: if (getAsTemplate().containsUnexpandedParameterPack()) return true; break; case Expression: if (getAsExpr()->containsUnexpandedParameterPack()) return true; break; case Pack: for (const auto &P : pack_elements()) if (P.containsUnexpandedParameterPack()) return true; break; } return false; } Optional TemplateArgument::getNumTemplateExpansions() const { assert(getKind() == TemplateExpansion); if (TemplateArg.NumExpansions) return TemplateArg.NumExpansions - 1; return None; } void TemplateArgument::Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context) const { ID.AddInteger(getKind()); switch (getKind()) { case Null: break; case Type: getAsType().Profile(ID); break; case NullPtr: getNullPtrType().Profile(ID); break; case Declaration: ID.AddPointer(getAsDecl()? getAsDecl()->getCanonicalDecl() : nullptr); break; case Template: case TemplateExpansion: { TemplateName Template = getAsTemplateOrTemplatePattern(); if (TemplateTemplateParmDecl *TTP = dyn_cast_or_null( Template.getAsTemplateDecl())) { ID.AddBoolean(true); ID.AddInteger(TTP->getDepth()); ID.AddInteger(TTP->getPosition()); ID.AddBoolean(TTP->isParameterPack()); } else { ID.AddBoolean(false); ID.AddPointer(Context.getCanonicalTemplateName(Template) .getAsVoidPointer()); } break; } case Integral: getAsIntegral().Profile(ID); getIntegralType().Profile(ID); break; case Expression: getAsExpr()->Profile(ID, Context, true); break; case Pack: ID.AddInteger(Args.NumArgs); for (unsigned I = 0; I != Args.NumArgs; ++I) Args.Args[I].Profile(ID, Context); } } bool TemplateArgument::structurallyEquals(const TemplateArgument &Other) const { if (getKind() != Other.getKind()) return false; switch (getKind()) { case Null: case Type: case Expression: case Template: case TemplateExpansion: case NullPtr: return TypeOrValue.V == Other.TypeOrValue.V; case Declaration: return getAsDecl() == Other.getAsDecl() && isDeclForReferenceParam() && Other.isDeclForReferenceParam(); case Integral: return getIntegralType() == Other.getIntegralType() && getAsIntegral() == Other.getAsIntegral(); case Pack: if (Args.NumArgs != Other.Args.NumArgs) return false; for (unsigned I = 0, E = Args.NumArgs; I != E; ++I) if (!Args.Args[I].structurallyEquals(Other.Args.Args[I])) return false; return true; } llvm_unreachable("Invalid TemplateArgument Kind!"); } TemplateArgument TemplateArgument::getPackExpansionPattern() const { assert(isPackExpansion()); switch (getKind()) { case Type: return getAsType()->getAs()->getPattern(); case Expression: return cast(getAsExpr())->getPattern(); case TemplateExpansion: return TemplateArgument(getAsTemplateOrTemplatePattern()); case Declaration: case Integral: case Pack: case Null: case Template: case NullPtr: return TemplateArgument(); } llvm_unreachable("Invalid TemplateArgument Kind!"); } void TemplateArgument::print(const PrintingPolicy &Policy, raw_ostream &Out) const { switch (getKind()) { case Null: Out << "(no value)"; break; case Type: { PrintingPolicy SubPolicy(Policy); SubPolicy.SuppressStrongLifetime = true; getAsType().print(Out, SubPolicy); break; } case Declaration: { NamedDecl *ND = cast(getAsDecl()); Out << '&'; if (ND->getDeclName()) { // FIXME: distinguish between pointer and reference args? ND->printQualifiedName(Out); } else { Out << "(anonymous)"; } break; } case NullPtr: Out << "nullptr"; break; case Template: getAsTemplate().print(Out, Policy); break; case TemplateExpansion: getAsTemplateOrTemplatePattern().print(Out, Policy); Out << "..."; break; case Integral: { printIntegral(*this, Out); break; } case Expression: getAsExpr()->printPretty(Out, nullptr, Policy); break; case Pack: Out << "<"; bool First = true; for (const auto &P : pack_elements()) { if (First) First = false; else Out << ", "; P.print(Policy, Out); } Out << ">"; break; } } //===----------------------------------------------------------------------===// // TemplateArgumentLoc Implementation //===----------------------------------------------------------------------===// TemplateArgumentLocInfo::TemplateArgumentLocInfo() { memset((void*)this, 0, sizeof(TemplateArgumentLocInfo)); } SourceRange TemplateArgumentLoc::getSourceRange() const { switch (Argument.getKind()) { case TemplateArgument::Expression: return getSourceExpression()->getSourceRange(); case TemplateArgument::Declaration: return getSourceDeclExpression()->getSourceRange(); case TemplateArgument::NullPtr: return getSourceNullPtrExpression()->getSourceRange(); case TemplateArgument::Type: if (TypeSourceInfo *TSI = getTypeSourceInfo()) return TSI->getTypeLoc().getSourceRange(); else return SourceRange(); case TemplateArgument::Template: if (getTemplateQualifierLoc()) return SourceRange(getTemplateQualifierLoc().getBeginLoc(), getTemplateNameLoc()); return SourceRange(getTemplateNameLoc()); case TemplateArgument::TemplateExpansion: if (getTemplateQualifierLoc()) return SourceRange(getTemplateQualifierLoc().getBeginLoc(), getTemplateEllipsisLoc()); return SourceRange(getTemplateNameLoc(), getTemplateEllipsisLoc()); case TemplateArgument::Integral: return getSourceIntegralExpression()->getSourceRange(); case TemplateArgument::Pack: case TemplateArgument::Null: return SourceRange(); } llvm_unreachable("Invalid TemplateArgument Kind!"); } const DiagnosticBuilder &clang::operator<<(const DiagnosticBuilder &DB, const TemplateArgument &Arg) { switch (Arg.getKind()) { case TemplateArgument::Null: // This is bad, but not as bad as crashing because of argument // count mismatches. return DB << "(null template argument)"; case TemplateArgument::Type: return DB << Arg.getAsType(); case TemplateArgument::Declaration: return DB << Arg.getAsDecl(); case TemplateArgument::NullPtr: return DB << "nullptr"; case TemplateArgument::Integral: return DB << Arg.getAsIntegral().toString(10); case TemplateArgument::Template: return DB << Arg.getAsTemplate(); case TemplateArgument::TemplateExpansion: return DB << Arg.getAsTemplateOrTemplatePattern() << "..."; case TemplateArgument::Expression: { // This shouldn't actually ever happen, so it's okay that we're // regurgitating an expression here. // FIXME: We're guessing at LangOptions! SmallString<32> Str; llvm::raw_svector_ostream OS(Str); LangOptions LangOpts; LangOpts.CPlusPlus = true; PrintingPolicy Policy(LangOpts); Arg.getAsExpr()->printPretty(OS, nullptr, Policy); return DB << OS.str(); } case TemplateArgument::Pack: { // FIXME: We're guessing at LangOptions! SmallString<32> Str; llvm::raw_svector_ostream OS(Str); LangOptions LangOpts; LangOpts.CPlusPlus = true; PrintingPolicy Policy(LangOpts); Arg.print(Policy, OS); return DB << OS.str(); } } llvm_unreachable("Invalid TemplateArgument Kind!"); } const ASTTemplateArgumentListInfo * ASTTemplateArgumentListInfo::Create(ASTContext &C, const TemplateArgumentListInfo &List) { assert(llvm::alignOf() >= llvm::alignOf()); std::size_t size = ASTTemplateArgumentListInfo::sizeFor(List.size()); void *Mem = C.Allocate(size, llvm::alignOf()); ASTTemplateArgumentListInfo *TAI = new (Mem) ASTTemplateArgumentListInfo(); TAI->initializeFrom(List); return TAI; } void ASTTemplateArgumentListInfo::initializeFrom( const TemplateArgumentListInfo &Info) { LAngleLoc = Info.getLAngleLoc(); RAngleLoc = Info.getRAngleLoc(); NumTemplateArgs = Info.size(); TemplateArgumentLoc *ArgBuffer = getTemplateArgs(); for (unsigned i = 0; i != NumTemplateArgs; ++i) new (&ArgBuffer[i]) TemplateArgumentLoc(Info[i]); } void ASTTemplateArgumentListInfo::initializeFrom( const TemplateArgumentListInfo &Info, bool &Dependent, bool &InstantiationDependent, bool &ContainsUnexpandedParameterPack) { LAngleLoc = Info.getLAngleLoc(); RAngleLoc = Info.getRAngleLoc(); NumTemplateArgs = Info.size(); TemplateArgumentLoc *ArgBuffer = getTemplateArgs(); for (unsigned i = 0; i != NumTemplateArgs; ++i) { Dependent = Dependent || Info[i].getArgument().isDependent(); InstantiationDependent = InstantiationDependent || Info[i].getArgument().isInstantiationDependent(); ContainsUnexpandedParameterPack = ContainsUnexpandedParameterPack || Info[i].getArgument().containsUnexpandedParameterPack(); new (&ArgBuffer[i]) TemplateArgumentLoc(Info[i]); } } void ASTTemplateArgumentListInfo::copyInto( TemplateArgumentListInfo &Info) const { Info.setLAngleLoc(LAngleLoc); Info.setRAngleLoc(RAngleLoc); for (unsigned I = 0; I != NumTemplateArgs; ++I) Info.addArgument(getTemplateArgs()[I]); } std::size_t ASTTemplateArgumentListInfo::sizeFor(unsigned NumTemplateArgs) { return sizeof(ASTTemplateArgumentListInfo) + sizeof(TemplateArgumentLoc) * NumTemplateArgs; } void ASTTemplateKWAndArgsInfo::initializeFrom(SourceLocation TemplateKWLoc, const TemplateArgumentListInfo &Info) { Base::initializeFrom(Info); setTemplateKeywordLoc(TemplateKWLoc); } void ASTTemplateKWAndArgsInfo ::initializeFrom(SourceLocation TemplateKWLoc, const TemplateArgumentListInfo &Info, bool &Dependent, bool &InstantiationDependent, bool &ContainsUnexpandedParameterPack) { Base::initializeFrom(Info, Dependent, InstantiationDependent, ContainsUnexpandedParameterPack); setTemplateKeywordLoc(TemplateKWLoc); } void ASTTemplateKWAndArgsInfo::initializeFrom(SourceLocation TemplateKWLoc) { // No explicit template arguments, but template keyword loc is valid. assert(TemplateKWLoc.isValid()); LAngleLoc = SourceLocation(); RAngleLoc = SourceLocation(); NumTemplateArgs = 0; setTemplateKeywordLoc(TemplateKWLoc); } std::size_t ASTTemplateKWAndArgsInfo::sizeFor(unsigned NumTemplateArgs) { // Add space for the template keyword location. // FIXME: There's room for this in the padding before the template args in // 64-bit builds. return Base::sizeFor(NumTemplateArgs) + sizeof(SourceLocation); } @ 1.1.1.1.4.1 log @file TemplateBase.cpp was added on branch yamt-pagecache on 2014-05-22 16:18:25 +0000 @ text @d1 602 @ 1.1.1.1.4.2 log @sync with head. for a reference, the tree before this commit was tagged as yamt-pagecache-tag8. this commit was splitted into small chunks to avoid a limitation of cvs. ("Protocol error: too many arguments") @ text @a0 602 //===--- TemplateBase.cpp - Common template AST class implementation ------===// // // The LLVM Compiler Infrastructure // // This file is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// // // This file implements common classes used throughout C++ template // representations. // //===----------------------------------------------------------------------===// #include "clang/AST/TemplateBase.h" #include "clang/AST/ASTContext.h" #include "clang/AST/DeclBase.h" #include "clang/AST/DeclTemplate.h" #include "clang/AST/Expr.h" #include "clang/AST/ExprCXX.h" #include "clang/AST/Type.h" #include "clang/AST/TypeLoc.h" #include "clang/Basic/Diagnostic.h" #include "llvm/ADT/FoldingSet.h" #include "llvm/ADT/SmallString.h" #include "llvm/Support/raw_ostream.h" #include using namespace clang; /// \brief Print a template integral argument value. /// /// \param TemplArg the TemplateArgument instance to print. /// /// \param Out the raw_ostream instance to use for printing. static void printIntegral(const TemplateArgument &TemplArg, raw_ostream &Out) { const ::clang::Type *T = TemplArg.getIntegralType().getTypePtr(); const llvm::APSInt &Val = TemplArg.getAsIntegral(); if (T->isBooleanType()) { Out << (Val.getBoolValue() ? "true" : "false"); } else if (T->isCharType()) { const char Ch = Val.getZExtValue(); Out << ((Ch == '\'') ? "'\\" : "'"); Out.write_escaped(StringRef(&Ch, 1), /*UseHexEscapes=*/ true); Out << "'"; } else { Out << Val; } } //===----------------------------------------------------------------------===// // TemplateArgument Implementation //===----------------------------------------------------------------------===// TemplateArgument::TemplateArgument(ASTContext &Ctx, const llvm::APSInt &Value, QualType Type) { Integer.Kind = Integral; // Copy the APSInt value into our decomposed form. Integer.BitWidth = Value.getBitWidth(); Integer.IsUnsigned = Value.isUnsigned(); // If the value is large, we have to get additional memory from the ASTContext unsigned NumWords = Value.getNumWords(); if (NumWords > 1) { void *Mem = Ctx.Allocate(NumWords * sizeof(uint64_t)); std::memcpy(Mem, Value.getRawData(), NumWords * sizeof(uint64_t)); Integer.pVal = static_cast(Mem); } else { Integer.VAL = Value.getZExtValue(); } Integer.Type = Type.getAsOpaquePtr(); } TemplateArgument TemplateArgument::CreatePackCopy(ASTContext &Context, const TemplateArgument *Args, unsigned NumArgs) { if (NumArgs == 0) return getEmptyPack(); TemplateArgument *Storage = new (Context) TemplateArgument [NumArgs]; std::copy(Args, Args + NumArgs, Storage); return TemplateArgument(Storage, NumArgs); } bool TemplateArgument::isDependent() const { switch (getKind()) { case Null: llvm_unreachable("Should not have a NULL template argument"); case Type: return getAsType()->isDependentType(); case Template: return getAsTemplate().isDependent(); case TemplateExpansion: return true; case Declaration: if (DeclContext *DC = dyn_cast(getAsDecl())) return DC->isDependentContext(); return getAsDecl()->getDeclContext()->isDependentContext(); case NullPtr: return false; case Integral: // Never dependent return false; case Expression: return (getAsExpr()->isTypeDependent() || getAsExpr()->isValueDependent()); case Pack: for (pack_iterator P = pack_begin(), PEnd = pack_end(); P != PEnd; ++P) { if (P->isDependent()) return true; } return false; } llvm_unreachable("Invalid TemplateArgument Kind!"); } bool TemplateArgument::isInstantiationDependent() const { switch (getKind()) { case Null: llvm_unreachable("Should not have a NULL template argument"); case Type: return getAsType()->isInstantiationDependentType(); case Template: return getAsTemplate().isInstantiationDependent(); case TemplateExpansion: return true; case Declaration: if (DeclContext *DC = dyn_cast(getAsDecl())) return DC->isDependentContext(); return getAsDecl()->getDeclContext()->isDependentContext(); case NullPtr: return false; case Integral: // Never dependent return false; case Expression: return getAsExpr()->isInstantiationDependent(); case Pack: for (pack_iterator P = pack_begin(), PEnd = pack_end(); P != PEnd; ++P) { if (P->isInstantiationDependent()) return true; } return false; } llvm_unreachable("Invalid TemplateArgument Kind!"); } bool TemplateArgument::isPackExpansion() const { switch (getKind()) { case Null: case Declaration: case Integral: case Pack: case Template: case NullPtr: return false; case TemplateExpansion: return true; case Type: return isa(getAsType()); case Expression: return isa(getAsExpr()); } llvm_unreachable("Invalid TemplateArgument Kind!"); } bool TemplateArgument::containsUnexpandedParameterPack() const { switch (getKind()) { case Null: case Declaration: case Integral: case TemplateExpansion: case NullPtr: break; case Type: if (getAsType()->containsUnexpandedParameterPack()) return true; break; case Template: if (getAsTemplate().containsUnexpandedParameterPack()) return true; break; case Expression: if (getAsExpr()->containsUnexpandedParameterPack()) return true; break; case Pack: for (pack_iterator P = pack_begin(), PEnd = pack_end(); P != PEnd; ++P) if (P->containsUnexpandedParameterPack()) return true; break; } return false; } Optional TemplateArgument::getNumTemplateExpansions() const { assert(getKind() == TemplateExpansion); if (TemplateArg.NumExpansions) return TemplateArg.NumExpansions - 1; return None; } void TemplateArgument::Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context) const { ID.AddInteger(getKind()); switch (getKind()) { case Null: break; case Type: getAsType().Profile(ID); break; case NullPtr: getNullPtrType().Profile(ID); break; case Declaration: ID.AddPointer(getAsDecl()? getAsDecl()->getCanonicalDecl() : 0); break; case Template: case TemplateExpansion: { TemplateName Template = getAsTemplateOrTemplatePattern(); if (TemplateTemplateParmDecl *TTP = dyn_cast_or_null( Template.getAsTemplateDecl())) { ID.AddBoolean(true); ID.AddInteger(TTP->getDepth()); ID.AddInteger(TTP->getPosition()); ID.AddBoolean(TTP->isParameterPack()); } else { ID.AddBoolean(false); ID.AddPointer(Context.getCanonicalTemplateName(Template) .getAsVoidPointer()); } break; } case Integral: getAsIntegral().Profile(ID); getIntegralType().Profile(ID); break; case Expression: getAsExpr()->Profile(ID, Context, true); break; case Pack: ID.AddInteger(Args.NumArgs); for (unsigned I = 0; I != Args.NumArgs; ++I) Args.Args[I].Profile(ID, Context); } } bool TemplateArgument::structurallyEquals(const TemplateArgument &Other) const { if (getKind() != Other.getKind()) return false; switch (getKind()) { case Null: case Type: case Expression: case Template: case TemplateExpansion: case NullPtr: return TypeOrValue.V == Other.TypeOrValue.V; case Declaration: return getAsDecl() == Other.getAsDecl() && isDeclForReferenceParam() && Other.isDeclForReferenceParam(); case Integral: return getIntegralType() == Other.getIntegralType() && getAsIntegral() == Other.getAsIntegral(); case Pack: if (Args.NumArgs != Other.Args.NumArgs) return false; for (unsigned I = 0, E = Args.NumArgs; I != E; ++I) if (!Args.Args[I].structurallyEquals(Other.Args.Args[I])) return false; return true; } llvm_unreachable("Invalid TemplateArgument Kind!"); } TemplateArgument TemplateArgument::getPackExpansionPattern() const { assert(isPackExpansion()); switch (getKind()) { case Type: return getAsType()->getAs()->getPattern(); case Expression: return cast(getAsExpr())->getPattern(); case TemplateExpansion: return TemplateArgument(getAsTemplateOrTemplatePattern()); case Declaration: case Integral: case Pack: case Null: case Template: case NullPtr: return TemplateArgument(); } llvm_unreachable("Invalid TemplateArgument Kind!"); } void TemplateArgument::print(const PrintingPolicy &Policy, raw_ostream &Out) const { switch (getKind()) { case Null: Out << ""; break; case Type: { PrintingPolicy SubPolicy(Policy); SubPolicy.SuppressStrongLifetime = true; getAsType().print(Out, SubPolicy); break; } case Declaration: { NamedDecl *ND = cast(getAsDecl()); Out << '&'; if (ND->getDeclName()) { // FIXME: distinguish between pointer and reference args? ND->printQualifiedName(Out); } else { Out << ""; } break; } case NullPtr: Out << "nullptr"; break; case Template: getAsTemplate().print(Out, Policy); break; case TemplateExpansion: getAsTemplateOrTemplatePattern().print(Out, Policy); Out << "..."; break; case Integral: { printIntegral(*this, Out); break; } case Expression: getAsExpr()->printPretty(Out, 0, Policy); break; case Pack: Out << "<"; bool First = true; for (TemplateArgument::pack_iterator P = pack_begin(), PEnd = pack_end(); P != PEnd; ++P) { if (First) First = false; else Out << ", "; P->print(Policy, Out); } Out << ">"; break; } } //===----------------------------------------------------------------------===// // TemplateArgumentLoc Implementation //===----------------------------------------------------------------------===// TemplateArgumentLocInfo::TemplateArgumentLocInfo() { memset((void*)this, 0, sizeof(TemplateArgumentLocInfo)); } SourceRange TemplateArgumentLoc::getSourceRange() const { switch (Argument.getKind()) { case TemplateArgument::Expression: return getSourceExpression()->getSourceRange(); case TemplateArgument::Declaration: return getSourceDeclExpression()->getSourceRange(); case TemplateArgument::NullPtr: return getSourceNullPtrExpression()->getSourceRange(); case TemplateArgument::Type: if (TypeSourceInfo *TSI = getTypeSourceInfo()) return TSI->getTypeLoc().getSourceRange(); else return SourceRange(); case TemplateArgument::Template: if (getTemplateQualifierLoc()) return SourceRange(getTemplateQualifierLoc().getBeginLoc(), getTemplateNameLoc()); return SourceRange(getTemplateNameLoc()); case TemplateArgument::TemplateExpansion: if (getTemplateQualifierLoc()) return SourceRange(getTemplateQualifierLoc().getBeginLoc(), getTemplateEllipsisLoc()); return SourceRange(getTemplateNameLoc(), getTemplateEllipsisLoc()); case TemplateArgument::Integral: return getSourceIntegralExpression()->getSourceRange(); case TemplateArgument::Pack: case TemplateArgument::Null: return SourceRange(); } llvm_unreachable("Invalid TemplateArgument Kind!"); } const DiagnosticBuilder &clang::operator<<(const DiagnosticBuilder &DB, const TemplateArgument &Arg) { switch (Arg.getKind()) { case TemplateArgument::Null: // This is bad, but not as bad as crashing because of argument // count mismatches. return DB << "(null template argument)"; case TemplateArgument::Type: return DB << Arg.getAsType(); case TemplateArgument::Declaration: return DB << Arg.getAsDecl(); case TemplateArgument::NullPtr: return DB << "nullptr"; case TemplateArgument::Integral: return DB << Arg.getAsIntegral().toString(10); case TemplateArgument::Template: return DB << Arg.getAsTemplate(); case TemplateArgument::TemplateExpansion: return DB << Arg.getAsTemplateOrTemplatePattern() << "..."; case TemplateArgument::Expression: { // This shouldn't actually ever happen, so it's okay that we're // regurgitating an expression here. // FIXME: We're guessing at LangOptions! SmallString<32> Str; llvm::raw_svector_ostream OS(Str); LangOptions LangOpts; LangOpts.CPlusPlus = true; PrintingPolicy Policy(LangOpts); Arg.getAsExpr()->printPretty(OS, 0, Policy); return DB << OS.str(); } case TemplateArgument::Pack: { // FIXME: We're guessing at LangOptions! SmallString<32> Str; llvm::raw_svector_ostream OS(Str); LangOptions LangOpts; LangOpts.CPlusPlus = true; PrintingPolicy Policy(LangOpts); Arg.print(Policy, OS); return DB << OS.str(); } } llvm_unreachable("Invalid TemplateArgument Kind!"); } const ASTTemplateArgumentListInfo * ASTTemplateArgumentListInfo::Create(ASTContext &C, const TemplateArgumentListInfo &List) { std::size_t size = ASTTemplateArgumentListInfo::sizeFor(List.size()); void *Mem = C.Allocate(size, llvm::alignOf()); ASTTemplateArgumentListInfo *TAI = new (Mem) ASTTemplateArgumentListInfo(); TAI->initializeFrom(List); return TAI; } void ASTTemplateArgumentListInfo::initializeFrom( const TemplateArgumentListInfo &Info) { LAngleLoc = Info.getLAngleLoc(); RAngleLoc = Info.getRAngleLoc(); NumTemplateArgs = Info.size(); TemplateArgumentLoc *ArgBuffer = getTemplateArgs(); for (unsigned i = 0; i != NumTemplateArgs; ++i) new (&ArgBuffer[i]) TemplateArgumentLoc(Info[i]); } void ASTTemplateArgumentListInfo::initializeFrom( const TemplateArgumentListInfo &Info, bool &Dependent, bool &InstantiationDependent, bool &ContainsUnexpandedParameterPack) { LAngleLoc = Info.getLAngleLoc(); RAngleLoc = Info.getRAngleLoc(); NumTemplateArgs = Info.size(); TemplateArgumentLoc *ArgBuffer = getTemplateArgs(); for (unsigned i = 0; i != NumTemplateArgs; ++i) { Dependent = Dependent || Info[i].getArgument().isDependent(); InstantiationDependent = InstantiationDependent || Info[i].getArgument().isInstantiationDependent(); ContainsUnexpandedParameterPack = ContainsUnexpandedParameterPack || Info[i].getArgument().containsUnexpandedParameterPack(); new (&ArgBuffer[i]) TemplateArgumentLoc(Info[i]); } } void ASTTemplateArgumentListInfo::copyInto( TemplateArgumentListInfo &Info) const { Info.setLAngleLoc(LAngleLoc); Info.setRAngleLoc(RAngleLoc); for (unsigned I = 0; I != NumTemplateArgs; ++I) Info.addArgument(getTemplateArgs()[I]); } std::size_t ASTTemplateArgumentListInfo::sizeFor(unsigned NumTemplateArgs) { return sizeof(ASTTemplateArgumentListInfo) + sizeof(TemplateArgumentLoc) * NumTemplateArgs; } void ASTTemplateKWAndArgsInfo::initializeFrom(SourceLocation TemplateKWLoc, const TemplateArgumentListInfo &Info) { Base::initializeFrom(Info); setTemplateKeywordLoc(TemplateKWLoc); } void ASTTemplateKWAndArgsInfo ::initializeFrom(SourceLocation TemplateKWLoc, const TemplateArgumentListInfo &Info, bool &Dependent, bool &InstantiationDependent, bool &ContainsUnexpandedParameterPack) { Base::initializeFrom(Info, Dependent, InstantiationDependent, ContainsUnexpandedParameterPack); setTemplateKeywordLoc(TemplateKWLoc); } void ASTTemplateKWAndArgsInfo::initializeFrom(SourceLocation TemplateKWLoc) { // No explicit template arguments, but template keyword loc is valid. assert(TemplateKWLoc.isValid()); LAngleLoc = SourceLocation(); RAngleLoc = SourceLocation(); NumTemplateArgs = 0; setTemplateKeywordLoc(TemplateKWLoc); } std::size_t ASTTemplateKWAndArgsInfo::sizeFor(unsigned NumTemplateArgs) { // Add space for the template keyword location. // FIXME: There's room for this in the padding before the template args in // 64-bit builds. return Base::sizeFor(NumTemplateArgs) + sizeof(SourceLocation); } @