| File: | tools/clang/lib/AST/ExprCXX.cpp |
| Warning: | line 1581, column 19 Access to field 'Temporary' results in a dereference of a null pointer (loaded from variable 'ES') |
Press '?' to see keyboard shortcuts
Keyboard shortcuts:
| 1 | //===- ExprCXX.cpp - (C++) Expression AST Node Implementation -------------===// | |||
| 2 | // | |||
| 3 | // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. | |||
| 4 | // See https://llvm.org/LICENSE.txt for license information. | |||
| 5 | // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception | |||
| 6 | // | |||
| 7 | //===----------------------------------------------------------------------===// | |||
| 8 | // | |||
| 9 | // This file implements the subclesses of Expr class declared in ExprCXX.h | |||
| 10 | // | |||
| 11 | //===----------------------------------------------------------------------===// | |||
| 12 | ||||
| 13 | #include "clang/AST/ExprCXX.h" | |||
| 14 | #include "clang/AST/ASTContext.h" | |||
| 15 | #include "clang/AST/Attr.h" | |||
| 16 | #include "clang/AST/Decl.h" | |||
| 17 | #include "clang/AST/DeclAccessPair.h" | |||
| 18 | #include "clang/AST/DeclBase.h" | |||
| 19 | #include "clang/AST/DeclCXX.h" | |||
| 20 | #include "clang/AST/DeclarationName.h" | |||
| 21 | #include "clang/AST/Expr.h" | |||
| 22 | #include "clang/AST/LambdaCapture.h" | |||
| 23 | #include "clang/AST/NestedNameSpecifier.h" | |||
| 24 | #include "clang/AST/TemplateBase.h" | |||
| 25 | #include "clang/AST/Type.h" | |||
| 26 | #include "clang/AST/TypeLoc.h" | |||
| 27 | #include "clang/Basic/LLVM.h" | |||
| 28 | #include "clang/Basic/OperatorKinds.h" | |||
| 29 | #include "clang/Basic/SourceLocation.h" | |||
| 30 | #include "clang/Basic/Specifiers.h" | |||
| 31 | #include "llvm/ADT/ArrayRef.h" | |||
| 32 | #include "llvm/Support/Casting.h" | |||
| 33 | #include "llvm/Support/ErrorHandling.h" | |||
| 34 | #include <cassert> | |||
| 35 | #include <cstddef> | |||
| 36 | #include <cstring> | |||
| 37 | #include <memory> | |||
| 38 | ||||
| 39 | using namespace clang; | |||
| 40 | ||||
| 41 | //===----------------------------------------------------------------------===// | |||
| 42 | // Child Iterators for iterating over subexpressions/substatements | |||
| 43 | //===----------------------------------------------------------------------===// | |||
| 44 | ||||
| 45 | bool CXXOperatorCallExpr::isInfixBinaryOp() const { | |||
| 46 | // An infix binary operator is any operator with two arguments other than | |||
| 47 | // operator() and operator[]. Note that none of these operators can have | |||
| 48 | // default arguments, so it suffices to check the number of argument | |||
| 49 | // expressions. | |||
| 50 | if (getNumArgs() != 2) | |||
| 51 | return false; | |||
| 52 | ||||
| 53 | switch (getOperator()) { | |||
| 54 | case OO_Call: case OO_Subscript: | |||
| 55 | return false; | |||
| 56 | default: | |||
| 57 | return true; | |||
| 58 | } | |||
| 59 | } | |||
| 60 | ||||
| 61 | bool CXXTypeidExpr::isPotentiallyEvaluated() const { | |||
| 62 | if (isTypeOperand()) | |||
| 63 | return false; | |||
| 64 | ||||
| 65 | // C++11 [expr.typeid]p3: | |||
| 66 | // When typeid is applied to an expression other than a glvalue of | |||
| 67 | // polymorphic class type, [...] the expression is an unevaluated operand. | |||
| 68 | const Expr *E = getExprOperand(); | |||
| 69 | if (const CXXRecordDecl *RD = E->getType()->getAsCXXRecordDecl()) | |||
| 70 | if (RD->isPolymorphic() && E->isGLValue()) | |||
| 71 | return true; | |||
| 72 | ||||
| 73 | return false; | |||
| 74 | } | |||
| 75 | ||||
| 76 | QualType CXXTypeidExpr::getTypeOperand(ASTContext &Context) const { | |||
| 77 | assert(isTypeOperand() && "Cannot call getTypeOperand for typeid(expr)")((isTypeOperand() && "Cannot call getTypeOperand for typeid(expr)" ) ? static_cast<void> (0) : __assert_fail ("isTypeOperand() && \"Cannot call getTypeOperand for typeid(expr)\"" , "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/AST/ExprCXX.cpp" , 77, __PRETTY_FUNCTION__)); | |||
| 78 | Qualifiers Quals; | |||
| 79 | return Context.getUnqualifiedArrayType( | |||
| 80 | Operand.get<TypeSourceInfo *>()->getType().getNonReferenceType(), Quals); | |||
| 81 | } | |||
| 82 | ||||
| 83 | QualType CXXUuidofExpr::getTypeOperand(ASTContext &Context) const { | |||
| 84 | assert(isTypeOperand() && "Cannot call getTypeOperand for __uuidof(expr)")((isTypeOperand() && "Cannot call getTypeOperand for __uuidof(expr)" ) ? static_cast<void> (0) : __assert_fail ("isTypeOperand() && \"Cannot call getTypeOperand for __uuidof(expr)\"" , "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/AST/ExprCXX.cpp" , 84, __PRETTY_FUNCTION__)); | |||
| 85 | Qualifiers Quals; | |||
| 86 | return Context.getUnqualifiedArrayType( | |||
| 87 | Operand.get<TypeSourceInfo *>()->getType().getNonReferenceType(), Quals); | |||
| 88 | } | |||
| 89 | ||||
| 90 | // CXXScalarValueInitExpr | |||
| 91 | SourceLocation CXXScalarValueInitExpr::getBeginLoc() const { | |||
| 92 | return TypeInfo ? TypeInfo->getTypeLoc().getBeginLoc() : getRParenLoc(); | |||
| 93 | } | |||
| 94 | ||||
| 95 | // CXXNewExpr | |||
| 96 | CXXNewExpr::CXXNewExpr(bool IsGlobalNew, FunctionDecl *OperatorNew, | |||
| 97 | FunctionDecl *OperatorDelete, bool ShouldPassAlignment, | |||
| 98 | bool UsualArrayDeleteWantsSize, | |||
| 99 | ArrayRef<Expr *> PlacementArgs, SourceRange TypeIdParens, | |||
| 100 | Optional<Expr *> ArraySize, | |||
| 101 | InitializationStyle InitializationStyle, | |||
| 102 | Expr *Initializer, QualType Ty, | |||
| 103 | TypeSourceInfo *AllocatedTypeInfo, SourceRange Range, | |||
| 104 | SourceRange DirectInitRange) | |||
| 105 | : Expr(CXXNewExprClass, Ty, VK_RValue, OK_Ordinary, Ty->isDependentType(), | |||
| 106 | Ty->isDependentType(), Ty->isInstantiationDependentType(), | |||
| 107 | Ty->containsUnexpandedParameterPack()), | |||
| 108 | OperatorNew(OperatorNew), OperatorDelete(OperatorDelete), | |||
| 109 | AllocatedTypeInfo(AllocatedTypeInfo), Range(Range), | |||
| 110 | DirectInitRange(DirectInitRange) { | |||
| 111 | ||||
| 112 | assert((Initializer != nullptr || InitializationStyle == NoInit) &&(((Initializer != nullptr || InitializationStyle == NoInit) && "Only NoInit can have no initializer!") ? static_cast<void > (0) : __assert_fail ("(Initializer != nullptr || InitializationStyle == NoInit) && \"Only NoInit can have no initializer!\"" , "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/AST/ExprCXX.cpp" , 113, __PRETTY_FUNCTION__)) | |||
| 113 | "Only NoInit can have no initializer!")(((Initializer != nullptr || InitializationStyle == NoInit) && "Only NoInit can have no initializer!") ? static_cast<void > (0) : __assert_fail ("(Initializer != nullptr || InitializationStyle == NoInit) && \"Only NoInit can have no initializer!\"" , "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/AST/ExprCXX.cpp" , 113, __PRETTY_FUNCTION__)); | |||
| 114 | ||||
| 115 | CXXNewExprBits.IsGlobalNew = IsGlobalNew; | |||
| 116 | CXXNewExprBits.IsArray = ArraySize.hasValue(); | |||
| 117 | CXXNewExprBits.ShouldPassAlignment = ShouldPassAlignment; | |||
| 118 | CXXNewExprBits.UsualArrayDeleteWantsSize = UsualArrayDeleteWantsSize; | |||
| 119 | CXXNewExprBits.StoredInitializationStyle = | |||
| 120 | Initializer ? InitializationStyle + 1 : 0; | |||
| 121 | bool IsParenTypeId = TypeIdParens.isValid(); | |||
| 122 | CXXNewExprBits.IsParenTypeId = IsParenTypeId; | |||
| 123 | CXXNewExprBits.NumPlacementArgs = PlacementArgs.size(); | |||
| 124 | ||||
| 125 | if (ArraySize) { | |||
| 126 | if (Expr *SizeExpr = *ArraySize) { | |||
| 127 | if (SizeExpr->isInstantiationDependent()) | |||
| 128 | ExprBits.InstantiationDependent = true; | |||
| 129 | if (SizeExpr->containsUnexpandedParameterPack()) | |||
| 130 | ExprBits.ContainsUnexpandedParameterPack = true; | |||
| 131 | } | |||
| 132 | ||||
| 133 | getTrailingObjects<Stmt *>()[arraySizeOffset()] = *ArraySize; | |||
| 134 | } | |||
| 135 | ||||
| 136 | if (Initializer) { | |||
| 137 | if (Initializer->isInstantiationDependent()) | |||
| 138 | ExprBits.InstantiationDependent = true; | |||
| 139 | if (Initializer->containsUnexpandedParameterPack()) | |||
| 140 | ExprBits.ContainsUnexpandedParameterPack = true; | |||
| 141 | ||||
| 142 | getTrailingObjects<Stmt *>()[initExprOffset()] = Initializer; | |||
| 143 | } | |||
| 144 | ||||
| 145 | for (unsigned I = 0; I != PlacementArgs.size(); ++I) { | |||
| 146 | if (PlacementArgs[I]->isInstantiationDependent()) | |||
| 147 | ExprBits.InstantiationDependent = true; | |||
| 148 | if (PlacementArgs[I]->containsUnexpandedParameterPack()) | |||
| 149 | ExprBits.ContainsUnexpandedParameterPack = true; | |||
| 150 | ||||
| 151 | getTrailingObjects<Stmt *>()[placementNewArgsOffset() + I] = | |||
| 152 | PlacementArgs[I]; | |||
| 153 | } | |||
| 154 | ||||
| 155 | if (IsParenTypeId) | |||
| 156 | getTrailingObjects<SourceRange>()[0] = TypeIdParens; | |||
| 157 | ||||
| 158 | switch (getInitializationStyle()) { | |||
| 159 | case CallInit: | |||
| 160 | this->Range.setEnd(DirectInitRange.getEnd()); | |||
| 161 | break; | |||
| 162 | case ListInit: | |||
| 163 | this->Range.setEnd(getInitializer()->getSourceRange().getEnd()); | |||
| 164 | break; | |||
| 165 | default: | |||
| 166 | if (IsParenTypeId) | |||
| 167 | this->Range.setEnd(TypeIdParens.getEnd()); | |||
| 168 | break; | |||
| 169 | } | |||
| 170 | } | |||
| 171 | ||||
| 172 | CXXNewExpr::CXXNewExpr(EmptyShell Empty, bool IsArray, | |||
| 173 | unsigned NumPlacementArgs, bool IsParenTypeId) | |||
| 174 | : Expr(CXXNewExprClass, Empty) { | |||
| 175 | CXXNewExprBits.IsArray = IsArray; | |||
| 176 | CXXNewExprBits.NumPlacementArgs = NumPlacementArgs; | |||
| 177 | CXXNewExprBits.IsParenTypeId = IsParenTypeId; | |||
| 178 | } | |||
| 179 | ||||
| 180 | CXXNewExpr * | |||
| 181 | CXXNewExpr::Create(const ASTContext &Ctx, bool IsGlobalNew, | |||
| 182 | FunctionDecl *OperatorNew, FunctionDecl *OperatorDelete, | |||
| 183 | bool ShouldPassAlignment, bool UsualArrayDeleteWantsSize, | |||
| 184 | ArrayRef<Expr *> PlacementArgs, SourceRange TypeIdParens, | |||
| 185 | Optional<Expr *> ArraySize, | |||
| 186 | InitializationStyle InitializationStyle, Expr *Initializer, | |||
| 187 | QualType Ty, TypeSourceInfo *AllocatedTypeInfo, | |||
| 188 | SourceRange Range, SourceRange DirectInitRange) { | |||
| 189 | bool IsArray = ArraySize.hasValue(); | |||
| 190 | bool HasInit = Initializer != nullptr; | |||
| 191 | unsigned NumPlacementArgs = PlacementArgs.size(); | |||
| 192 | bool IsParenTypeId = TypeIdParens.isValid(); | |||
| 193 | void *Mem = | |||
| 194 | Ctx.Allocate(totalSizeToAlloc<Stmt *, SourceRange>( | |||
| 195 | IsArray + HasInit + NumPlacementArgs, IsParenTypeId), | |||
| 196 | alignof(CXXNewExpr)); | |||
| 197 | return new (Mem) | |||
| 198 | CXXNewExpr(IsGlobalNew, OperatorNew, OperatorDelete, ShouldPassAlignment, | |||
| 199 | UsualArrayDeleteWantsSize, PlacementArgs, TypeIdParens, | |||
| 200 | ArraySize, InitializationStyle, Initializer, Ty, | |||
| 201 | AllocatedTypeInfo, Range, DirectInitRange); | |||
| 202 | } | |||
| 203 | ||||
| 204 | CXXNewExpr *CXXNewExpr::CreateEmpty(const ASTContext &Ctx, bool IsArray, | |||
| 205 | bool HasInit, unsigned NumPlacementArgs, | |||
| 206 | bool IsParenTypeId) { | |||
| 207 | void *Mem = | |||
| 208 | Ctx.Allocate(totalSizeToAlloc<Stmt *, SourceRange>( | |||
| 209 | IsArray + HasInit + NumPlacementArgs, IsParenTypeId), | |||
| 210 | alignof(CXXNewExpr)); | |||
| 211 | return new (Mem) | |||
| 212 | CXXNewExpr(EmptyShell(), IsArray, NumPlacementArgs, IsParenTypeId); | |||
| 213 | } | |||
| 214 | ||||
| 215 | bool CXXNewExpr::shouldNullCheckAllocation() const { | |||
| 216 | return getOperatorNew() | |||
| 217 | ->getType() | |||
| 218 | ->castAs<FunctionProtoType>() | |||
| 219 | ->isNothrow() && | |||
| 220 | !getOperatorNew()->isReservedGlobalPlacementOperator(); | |||
| 221 | } | |||
| 222 | ||||
| 223 | // CXXDeleteExpr | |||
| 224 | QualType CXXDeleteExpr::getDestroyedType() const { | |||
| 225 | const Expr *Arg = getArgument(); | |||
| 226 | ||||
| 227 | // For a destroying operator delete, we may have implicitly converted the | |||
| 228 | // pointer type to the type of the parameter of the 'operator delete' | |||
| 229 | // function. | |||
| 230 | while (const auto *ICE = dyn_cast<ImplicitCastExpr>(Arg)) { | |||
| 231 | if (ICE->getCastKind() == CK_DerivedToBase || | |||
| 232 | ICE->getCastKind() == CK_UncheckedDerivedToBase || | |||
| 233 | ICE->getCastKind() == CK_NoOp) { | |||
| 234 | assert((ICE->getCastKind() == CK_NoOp ||(((ICE->getCastKind() == CK_NoOp || getOperatorDelete()-> isDestroyingOperatorDelete()) && "only a destroying operator delete can have a converted arg" ) ? static_cast<void> (0) : __assert_fail ("(ICE->getCastKind() == CK_NoOp || getOperatorDelete()->isDestroyingOperatorDelete()) && \"only a destroying operator delete can have a converted arg\"" , "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/AST/ExprCXX.cpp" , 236, __PRETTY_FUNCTION__)) | |||
| 235 | getOperatorDelete()->isDestroyingOperatorDelete()) &&(((ICE->getCastKind() == CK_NoOp || getOperatorDelete()-> isDestroyingOperatorDelete()) && "only a destroying operator delete can have a converted arg" ) ? static_cast<void> (0) : __assert_fail ("(ICE->getCastKind() == CK_NoOp || getOperatorDelete()->isDestroyingOperatorDelete()) && \"only a destroying operator delete can have a converted arg\"" , "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/AST/ExprCXX.cpp" , 236, __PRETTY_FUNCTION__)) | |||
| 236 | "only a destroying operator delete can have a converted arg")(((ICE->getCastKind() == CK_NoOp || getOperatorDelete()-> isDestroyingOperatorDelete()) && "only a destroying operator delete can have a converted arg" ) ? static_cast<void> (0) : __assert_fail ("(ICE->getCastKind() == CK_NoOp || getOperatorDelete()->isDestroyingOperatorDelete()) && \"only a destroying operator delete can have a converted arg\"" , "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/AST/ExprCXX.cpp" , 236, __PRETTY_FUNCTION__)); | |||
| 237 | Arg = ICE->getSubExpr(); | |||
| 238 | } else | |||
| 239 | break; | |||
| 240 | } | |||
| 241 | ||||
| 242 | // The type-to-delete may not be a pointer if it's a dependent type. | |||
| 243 | const QualType ArgType = Arg->getType(); | |||
| 244 | ||||
| 245 | if (ArgType->isDependentType() && !ArgType->isPointerType()) | |||
| 246 | return QualType(); | |||
| 247 | ||||
| 248 | return ArgType->getAs<PointerType>()->getPointeeType(); | |||
| 249 | } | |||
| 250 | ||||
| 251 | // CXXPseudoDestructorExpr | |||
| 252 | PseudoDestructorTypeStorage::PseudoDestructorTypeStorage(TypeSourceInfo *Info) | |||
| 253 | : Type(Info) { | |||
| 254 | Location = Info->getTypeLoc().getLocalSourceRange().getBegin(); | |||
| 255 | } | |||
| 256 | ||||
| 257 | CXXPseudoDestructorExpr::CXXPseudoDestructorExpr(const ASTContext &Context, | |||
| 258 | Expr *Base, bool isArrow, SourceLocation OperatorLoc, | |||
| 259 | NestedNameSpecifierLoc QualifierLoc, TypeSourceInfo *ScopeType, | |||
| 260 | SourceLocation ColonColonLoc, SourceLocation TildeLoc, | |||
| 261 | PseudoDestructorTypeStorage DestroyedType) | |||
| 262 | : Expr(CXXPseudoDestructorExprClass, | |||
| 263 | Context.BoundMemberTy, | |||
| 264 | VK_RValue, OK_Ordinary, | |||
| 265 | /*isTypeDependent=*/(Base->isTypeDependent() || | |||
| 266 | (DestroyedType.getTypeSourceInfo() && | |||
| 267 | DestroyedType.getTypeSourceInfo()->getType()->isDependentType())), | |||
| 268 | /*isValueDependent=*/Base->isValueDependent(), | |||
| 269 | (Base->isInstantiationDependent() || | |||
| 270 | (QualifierLoc && | |||
| 271 | QualifierLoc.getNestedNameSpecifier()->isInstantiationDependent()) || | |||
| 272 | (ScopeType && | |||
| 273 | ScopeType->getType()->isInstantiationDependentType()) || | |||
| 274 | (DestroyedType.getTypeSourceInfo() && | |||
| 275 | DestroyedType.getTypeSourceInfo()->getType() | |||
| 276 | ->isInstantiationDependentType())), | |||
| 277 | // ContainsUnexpandedParameterPack | |||
| 278 | (Base->containsUnexpandedParameterPack() || | |||
| 279 | (QualifierLoc && | |||
| 280 | QualifierLoc.getNestedNameSpecifier() | |||
| 281 | ->containsUnexpandedParameterPack()) || | |||
| 282 | (ScopeType && | |||
| 283 | ScopeType->getType()->containsUnexpandedParameterPack()) || | |||
| 284 | (DestroyedType.getTypeSourceInfo() && | |||
| 285 | DestroyedType.getTypeSourceInfo()->getType() | |||
| 286 | ->containsUnexpandedParameterPack()))), | |||
| 287 | Base(static_cast<Stmt *>(Base)), IsArrow(isArrow), | |||
| 288 | OperatorLoc(OperatorLoc), QualifierLoc(QualifierLoc), | |||
| 289 | ScopeType(ScopeType), ColonColonLoc(ColonColonLoc), TildeLoc(TildeLoc), | |||
| 290 | DestroyedType(DestroyedType) {} | |||
| 291 | ||||
| 292 | QualType CXXPseudoDestructorExpr::getDestroyedType() const { | |||
| 293 | if (TypeSourceInfo *TInfo = DestroyedType.getTypeSourceInfo()) | |||
| 294 | return TInfo->getType(); | |||
| 295 | ||||
| 296 | return QualType(); | |||
| 297 | } | |||
| 298 | ||||
| 299 | SourceLocation CXXPseudoDestructorExpr::getEndLoc() const { | |||
| 300 | SourceLocation End = DestroyedType.getLocation(); | |||
| 301 | if (TypeSourceInfo *TInfo = DestroyedType.getTypeSourceInfo()) | |||
| 302 | End = TInfo->getTypeLoc().getLocalSourceRange().getEnd(); | |||
| 303 | return End; | |||
| 304 | } | |||
| 305 | ||||
| 306 | // UnresolvedLookupExpr | |||
| 307 | UnresolvedLookupExpr::UnresolvedLookupExpr( | |||
| 308 | const ASTContext &Context, CXXRecordDecl *NamingClass, | |||
| 309 | NestedNameSpecifierLoc QualifierLoc, SourceLocation TemplateKWLoc, | |||
| 310 | const DeclarationNameInfo &NameInfo, bool RequiresADL, bool Overloaded, | |||
| 311 | const TemplateArgumentListInfo *TemplateArgs, UnresolvedSetIterator Begin, | |||
| 312 | UnresolvedSetIterator End) | |||
| 313 | : OverloadExpr(UnresolvedLookupExprClass, Context, QualifierLoc, | |||
| 314 | TemplateKWLoc, NameInfo, TemplateArgs, Begin, End, false, | |||
| 315 | false, false), | |||
| 316 | NamingClass(NamingClass) { | |||
| 317 | UnresolvedLookupExprBits.RequiresADL = RequiresADL; | |||
| 318 | UnresolvedLookupExprBits.Overloaded = Overloaded; | |||
| 319 | } | |||
| 320 | ||||
| 321 | UnresolvedLookupExpr::UnresolvedLookupExpr(EmptyShell Empty, | |||
| 322 | unsigned NumResults, | |||
| 323 | bool HasTemplateKWAndArgsInfo) | |||
| 324 | : OverloadExpr(UnresolvedLookupExprClass, Empty, NumResults, | |||
| 325 | HasTemplateKWAndArgsInfo) {} | |||
| 326 | ||||
| 327 | UnresolvedLookupExpr *UnresolvedLookupExpr::Create( | |||
| 328 | const ASTContext &Context, CXXRecordDecl *NamingClass, | |||
| 329 | NestedNameSpecifierLoc QualifierLoc, const DeclarationNameInfo &NameInfo, | |||
| 330 | bool RequiresADL, bool Overloaded, UnresolvedSetIterator Begin, | |||
| 331 | UnresolvedSetIterator End) { | |||
| 332 | unsigned NumResults = End - Begin; | |||
| 333 | unsigned Size = totalSizeToAlloc<DeclAccessPair, ASTTemplateKWAndArgsInfo, | |||
| 334 | TemplateArgumentLoc>(NumResults, 0, 0); | |||
| 335 | void *Mem = Context.Allocate(Size, alignof(UnresolvedLookupExpr)); | |||
| 336 | return new (Mem) UnresolvedLookupExpr(Context, NamingClass, QualifierLoc, | |||
| 337 | SourceLocation(), NameInfo, RequiresADL, | |||
| 338 | Overloaded, nullptr, Begin, End); | |||
| 339 | } | |||
| 340 | ||||
| 341 | UnresolvedLookupExpr *UnresolvedLookupExpr::Create( | |||
| 342 | const ASTContext &Context, CXXRecordDecl *NamingClass, | |||
| 343 | NestedNameSpecifierLoc QualifierLoc, SourceLocation TemplateKWLoc, | |||
| 344 | const DeclarationNameInfo &NameInfo, bool RequiresADL, | |||
| 345 | const TemplateArgumentListInfo *Args, UnresolvedSetIterator Begin, | |||
| 346 | UnresolvedSetIterator End) { | |||
| 347 | assert(Args || TemplateKWLoc.isValid())((Args || TemplateKWLoc.isValid()) ? static_cast<void> ( 0) : __assert_fail ("Args || TemplateKWLoc.isValid()", "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/AST/ExprCXX.cpp" , 347, __PRETTY_FUNCTION__)); | |||
| 348 | unsigned NumResults = End - Begin; | |||
| 349 | unsigned NumTemplateArgs = Args ? Args->size() : 0; | |||
| 350 | unsigned Size = | |||
| 351 | totalSizeToAlloc<DeclAccessPair, ASTTemplateKWAndArgsInfo, | |||
| 352 | TemplateArgumentLoc>(NumResults, 1, NumTemplateArgs); | |||
| 353 | void *Mem = Context.Allocate(Size, alignof(UnresolvedLookupExpr)); | |||
| 354 | return new (Mem) UnresolvedLookupExpr(Context, NamingClass, QualifierLoc, | |||
| 355 | TemplateKWLoc, NameInfo, RequiresADL, | |||
| 356 | /*Overloaded*/ true, Args, Begin, End); | |||
| 357 | } | |||
| 358 | ||||
| 359 | UnresolvedLookupExpr *UnresolvedLookupExpr::CreateEmpty( | |||
| 360 | const ASTContext &Context, unsigned NumResults, | |||
| 361 | bool HasTemplateKWAndArgsInfo, unsigned NumTemplateArgs) { | |||
| 362 | assert(NumTemplateArgs == 0 || HasTemplateKWAndArgsInfo)((NumTemplateArgs == 0 || HasTemplateKWAndArgsInfo) ? static_cast <void> (0) : __assert_fail ("NumTemplateArgs == 0 || HasTemplateKWAndArgsInfo" , "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/AST/ExprCXX.cpp" , 362, __PRETTY_FUNCTION__)); | |||
| 363 | unsigned Size = totalSizeToAlloc<DeclAccessPair, ASTTemplateKWAndArgsInfo, | |||
| 364 | TemplateArgumentLoc>( | |||
| 365 | NumResults, HasTemplateKWAndArgsInfo, NumTemplateArgs); | |||
| 366 | void *Mem = Context.Allocate(Size, alignof(UnresolvedLookupExpr)); | |||
| 367 | return new (Mem) | |||
| 368 | UnresolvedLookupExpr(EmptyShell(), NumResults, HasTemplateKWAndArgsInfo); | |||
| 369 | } | |||
| 370 | ||||
| 371 | OverloadExpr::OverloadExpr(StmtClass SC, const ASTContext &Context, | |||
| 372 | NestedNameSpecifierLoc QualifierLoc, | |||
| 373 | SourceLocation TemplateKWLoc, | |||
| 374 | const DeclarationNameInfo &NameInfo, | |||
| 375 | const TemplateArgumentListInfo *TemplateArgs, | |||
| 376 | UnresolvedSetIterator Begin, | |||
| 377 | UnresolvedSetIterator End, bool KnownDependent, | |||
| 378 | bool KnownInstantiationDependent, | |||
| 379 | bool KnownContainsUnexpandedParameterPack) | |||
| 380 | : Expr( | |||
| 381 | SC, Context.OverloadTy, VK_LValue, OK_Ordinary, KnownDependent, | |||
| 382 | KnownDependent, | |||
| 383 | (KnownInstantiationDependent || NameInfo.isInstantiationDependent() || | |||
| 384 | (QualifierLoc && | |||
| 385 | QualifierLoc.getNestedNameSpecifier()->isInstantiationDependent())), | |||
| 386 | (KnownContainsUnexpandedParameterPack || | |||
| 387 | NameInfo.containsUnexpandedParameterPack() || | |||
| 388 | (QualifierLoc && QualifierLoc.getNestedNameSpecifier() | |||
| 389 | ->containsUnexpandedParameterPack()))), | |||
| 390 | NameInfo(NameInfo), QualifierLoc(QualifierLoc) { | |||
| 391 | unsigned NumResults = End - Begin; | |||
| 392 | OverloadExprBits.NumResults = NumResults; | |||
| 393 | OverloadExprBits.HasTemplateKWAndArgsInfo = | |||
| 394 | (TemplateArgs != nullptr ) || TemplateKWLoc.isValid(); | |||
| 395 | ||||
| 396 | if (NumResults) { | |||
| 397 | // Determine whether this expression is type-dependent. | |||
| 398 | for (UnresolvedSetImpl::const_iterator I = Begin; I != End; ++I) { | |||
| 399 | if ((*I)->getDeclContext()->isDependentContext() || | |||
| 400 | isa<UnresolvedUsingValueDecl>(*I)) { | |||
| 401 | ExprBits.TypeDependent = true; | |||
| 402 | ExprBits.ValueDependent = true; | |||
| 403 | ExprBits.InstantiationDependent = true; | |||
| 404 | } | |||
| 405 | } | |||
| 406 | ||||
| 407 | // Copy the results to the trailing array past UnresolvedLookupExpr | |||
| 408 | // or UnresolvedMemberExpr. | |||
| 409 | DeclAccessPair *Results = getTrailingResults(); | |||
| 410 | memcpy(Results, Begin.I, NumResults * sizeof(DeclAccessPair)); | |||
| 411 | } | |||
| 412 | ||||
| 413 | // If we have explicit template arguments, check for dependent | |||
| 414 | // template arguments and whether they contain any unexpanded pack | |||
| 415 | // expansions. | |||
| 416 | if (TemplateArgs) { | |||
| 417 | bool Dependent = false; | |||
| 418 | bool InstantiationDependent = false; | |||
| 419 | bool ContainsUnexpandedParameterPack = false; | |||
| 420 | getTrailingASTTemplateKWAndArgsInfo()->initializeFrom( | |||
| 421 | TemplateKWLoc, *TemplateArgs, getTrailingTemplateArgumentLoc(), | |||
| 422 | Dependent, InstantiationDependent, ContainsUnexpandedParameterPack); | |||
| 423 | ||||
| 424 | if (Dependent) { | |||
| 425 | ExprBits.TypeDependent = true; | |||
| 426 | ExprBits.ValueDependent = true; | |||
| 427 | } | |||
| 428 | if (InstantiationDependent) | |||
| 429 | ExprBits.InstantiationDependent = true; | |||
| 430 | if (ContainsUnexpandedParameterPack) | |||
| 431 | ExprBits.ContainsUnexpandedParameterPack = true; | |||
| 432 | } else if (TemplateKWLoc.isValid()) { | |||
| 433 | getTrailingASTTemplateKWAndArgsInfo()->initializeFrom(TemplateKWLoc); | |||
| 434 | } | |||
| 435 | ||||
| 436 | if (isTypeDependent()) | |||
| 437 | setType(Context.DependentTy); | |||
| 438 | } | |||
| 439 | ||||
| 440 | OverloadExpr::OverloadExpr(StmtClass SC, EmptyShell Empty, unsigned NumResults, | |||
| 441 | bool HasTemplateKWAndArgsInfo) | |||
| 442 | : Expr(SC, Empty) { | |||
| 443 | OverloadExprBits.NumResults = NumResults; | |||
| 444 | OverloadExprBits.HasTemplateKWAndArgsInfo = HasTemplateKWAndArgsInfo; | |||
| 445 | } | |||
| 446 | ||||
| 447 | // DependentScopeDeclRefExpr | |||
| 448 | DependentScopeDeclRefExpr::DependentScopeDeclRefExpr( | |||
| 449 | QualType Ty, NestedNameSpecifierLoc QualifierLoc, | |||
| 450 | SourceLocation TemplateKWLoc, const DeclarationNameInfo &NameInfo, | |||
| 451 | const TemplateArgumentListInfo *Args) | |||
| 452 | : Expr( | |||
| 453 | DependentScopeDeclRefExprClass, Ty, VK_LValue, OK_Ordinary, true, | |||
| 454 | true, | |||
| 455 | (NameInfo.isInstantiationDependent() || | |||
| 456 | (QualifierLoc && | |||
| 457 | QualifierLoc.getNestedNameSpecifier()->isInstantiationDependent())), | |||
| 458 | (NameInfo.containsUnexpandedParameterPack() || | |||
| 459 | (QualifierLoc && QualifierLoc.getNestedNameSpecifier() | |||
| 460 | ->containsUnexpandedParameterPack()))), | |||
| 461 | QualifierLoc(QualifierLoc), NameInfo(NameInfo) { | |||
| 462 | DependentScopeDeclRefExprBits.HasTemplateKWAndArgsInfo = | |||
| 463 | (Args != nullptr) || TemplateKWLoc.isValid(); | |||
| 464 | if (Args) { | |||
| 465 | bool Dependent = true; | |||
| 466 | bool InstantiationDependent = true; | |||
| 467 | bool ContainsUnexpandedParameterPack | |||
| 468 | = ExprBits.ContainsUnexpandedParameterPack; | |||
| 469 | getTrailingObjects<ASTTemplateKWAndArgsInfo>()->initializeFrom( | |||
| 470 | TemplateKWLoc, *Args, getTrailingObjects<TemplateArgumentLoc>(), | |||
| 471 | Dependent, InstantiationDependent, ContainsUnexpandedParameterPack); | |||
| 472 | ExprBits.ContainsUnexpandedParameterPack = ContainsUnexpandedParameterPack; | |||
| 473 | } else if (TemplateKWLoc.isValid()) { | |||
| 474 | getTrailingObjects<ASTTemplateKWAndArgsInfo>()->initializeFrom( | |||
| 475 | TemplateKWLoc); | |||
| 476 | } | |||
| 477 | } | |||
| 478 | ||||
| 479 | DependentScopeDeclRefExpr *DependentScopeDeclRefExpr::Create( | |||
| 480 | const ASTContext &Context, NestedNameSpecifierLoc QualifierLoc, | |||
| 481 | SourceLocation TemplateKWLoc, const DeclarationNameInfo &NameInfo, | |||
| 482 | const TemplateArgumentListInfo *Args) { | |||
| 483 | assert(QualifierLoc && "should be created for dependent qualifiers")((QualifierLoc && "should be created for dependent qualifiers" ) ? static_cast<void> (0) : __assert_fail ("QualifierLoc && \"should be created for dependent qualifiers\"" , "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/AST/ExprCXX.cpp" , 483, __PRETTY_FUNCTION__)); | |||
| 484 | bool HasTemplateKWAndArgsInfo = Args || TemplateKWLoc.isValid(); | |||
| 485 | std::size_t Size = | |||
| 486 | totalSizeToAlloc<ASTTemplateKWAndArgsInfo, TemplateArgumentLoc>( | |||
| 487 | HasTemplateKWAndArgsInfo, Args ? Args->size() : 0); | |||
| 488 | void *Mem = Context.Allocate(Size); | |||
| 489 | return new (Mem) DependentScopeDeclRefExpr(Context.DependentTy, QualifierLoc, | |||
| 490 | TemplateKWLoc, NameInfo, Args); | |||
| 491 | } | |||
| 492 | ||||
| 493 | DependentScopeDeclRefExpr * | |||
| 494 | DependentScopeDeclRefExpr::CreateEmpty(const ASTContext &Context, | |||
| 495 | bool HasTemplateKWAndArgsInfo, | |||
| 496 | unsigned NumTemplateArgs) { | |||
| 497 | assert(NumTemplateArgs == 0 || HasTemplateKWAndArgsInfo)((NumTemplateArgs == 0 || HasTemplateKWAndArgsInfo) ? static_cast <void> (0) : __assert_fail ("NumTemplateArgs == 0 || HasTemplateKWAndArgsInfo" , "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/AST/ExprCXX.cpp" , 497, __PRETTY_FUNCTION__)); | |||
| 498 | std::size_t Size = | |||
| 499 | totalSizeToAlloc<ASTTemplateKWAndArgsInfo, TemplateArgumentLoc>( | |||
| 500 | HasTemplateKWAndArgsInfo, NumTemplateArgs); | |||
| 501 | void *Mem = Context.Allocate(Size); | |||
| 502 | auto *E = new (Mem) DependentScopeDeclRefExpr( | |||
| 503 | QualType(), NestedNameSpecifierLoc(), SourceLocation(), | |||
| 504 | DeclarationNameInfo(), nullptr); | |||
| 505 | E->DependentScopeDeclRefExprBits.HasTemplateKWAndArgsInfo = | |||
| 506 | HasTemplateKWAndArgsInfo; | |||
| 507 | return E; | |||
| 508 | } | |||
| 509 | ||||
| 510 | SourceLocation CXXConstructExpr::getBeginLoc() const { | |||
| 511 | if (isa<CXXTemporaryObjectExpr>(this)) | |||
| 512 | return cast<CXXTemporaryObjectExpr>(this)->getBeginLoc(); | |||
| 513 | return getLocation(); | |||
| 514 | } | |||
| 515 | ||||
| 516 | SourceLocation CXXConstructExpr::getEndLoc() const { | |||
| 517 | if (isa<CXXTemporaryObjectExpr>(this)) | |||
| 518 | return cast<CXXTemporaryObjectExpr>(this)->getEndLoc(); | |||
| 519 | ||||
| 520 | if (ParenOrBraceRange.isValid()) | |||
| 521 | return ParenOrBraceRange.getEnd(); | |||
| 522 | ||||
| 523 | SourceLocation End = getLocation(); | |||
| 524 | for (unsigned I = getNumArgs(); I > 0; --I) { | |||
| 525 | const Expr *Arg = getArg(I-1); | |||
| 526 | if (!Arg->isDefaultArgument()) { | |||
| 527 | SourceLocation NewEnd = Arg->getEndLoc(); | |||
| 528 | if (NewEnd.isValid()) { | |||
| 529 | End = NewEnd; | |||
| 530 | break; | |||
| 531 | } | |||
| 532 | } | |||
| 533 | } | |||
| 534 | ||||
| 535 | return End; | |||
| 536 | } | |||
| 537 | ||||
| 538 | CXXOperatorCallExpr::CXXOperatorCallExpr(OverloadedOperatorKind OpKind, | |||
| 539 | Expr *Fn, ArrayRef<Expr *> Args, | |||
| 540 | QualType Ty, ExprValueKind VK, | |||
| 541 | SourceLocation OperatorLoc, | |||
| 542 | FPOptions FPFeatures, | |||
| 543 | ADLCallKind UsesADL) | |||
| 544 | : CallExpr(CXXOperatorCallExprClass, Fn, /*PreArgs=*/{}, Args, Ty, VK, | |||
| 545 | OperatorLoc, /*MinNumArgs=*/0, UsesADL) { | |||
| 546 | CXXOperatorCallExprBits.OperatorKind = OpKind; | |||
| 547 | CXXOperatorCallExprBits.FPFeatures = FPFeatures.getInt(); | |||
| 548 | assert((((CXXOperatorCallExprBits.OperatorKind == static_cast<unsigned >(OpKind)) && "OperatorKind overflow!") ? static_cast <void> (0) : __assert_fail ("(CXXOperatorCallExprBits.OperatorKind == static_cast<unsigned>(OpKind)) && \"OperatorKind overflow!\"" , "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/AST/ExprCXX.cpp" , 550, __PRETTY_FUNCTION__)) | |||
| 549 | (CXXOperatorCallExprBits.OperatorKind == static_cast<unsigned>(OpKind)) &&(((CXXOperatorCallExprBits.OperatorKind == static_cast<unsigned >(OpKind)) && "OperatorKind overflow!") ? static_cast <void> (0) : __assert_fail ("(CXXOperatorCallExprBits.OperatorKind == static_cast<unsigned>(OpKind)) && \"OperatorKind overflow!\"" , "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/AST/ExprCXX.cpp" , 550, __PRETTY_FUNCTION__)) | |||
| 550 | "OperatorKind overflow!")(((CXXOperatorCallExprBits.OperatorKind == static_cast<unsigned >(OpKind)) && "OperatorKind overflow!") ? static_cast <void> (0) : __assert_fail ("(CXXOperatorCallExprBits.OperatorKind == static_cast<unsigned>(OpKind)) && \"OperatorKind overflow!\"" , "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/AST/ExprCXX.cpp" , 550, __PRETTY_FUNCTION__)); | |||
| 551 | assert((CXXOperatorCallExprBits.FPFeatures == FPFeatures.getInt()) &&(((CXXOperatorCallExprBits.FPFeatures == FPFeatures.getInt()) && "FPFeatures overflow!") ? static_cast<void> (0) : __assert_fail ("(CXXOperatorCallExprBits.FPFeatures == FPFeatures.getInt()) && \"FPFeatures overflow!\"" , "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/AST/ExprCXX.cpp" , 552, __PRETTY_FUNCTION__)) | |||
| 552 | "FPFeatures overflow!")(((CXXOperatorCallExprBits.FPFeatures == FPFeatures.getInt()) && "FPFeatures overflow!") ? static_cast<void> (0) : __assert_fail ("(CXXOperatorCallExprBits.FPFeatures == FPFeatures.getInt()) && \"FPFeatures overflow!\"" , "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/AST/ExprCXX.cpp" , 552, __PRETTY_FUNCTION__)); | |||
| 553 | Range = getSourceRangeImpl(); | |||
| 554 | } | |||
| 555 | ||||
| 556 | CXXOperatorCallExpr::CXXOperatorCallExpr(unsigned NumArgs, EmptyShell Empty) | |||
| 557 | : CallExpr(CXXOperatorCallExprClass, /*NumPreArgs=*/0, NumArgs, Empty) {} | |||
| 558 | ||||
| 559 | CXXOperatorCallExpr *CXXOperatorCallExpr::Create( | |||
| 560 | const ASTContext &Ctx, OverloadedOperatorKind OpKind, Expr *Fn, | |||
| 561 | ArrayRef<Expr *> Args, QualType Ty, ExprValueKind VK, | |||
| 562 | SourceLocation OperatorLoc, FPOptions FPFeatures, ADLCallKind UsesADL) { | |||
| 563 | // Allocate storage for the trailing objects of CallExpr. | |||
| 564 | unsigned NumArgs = Args.size(); | |||
| 565 | unsigned SizeOfTrailingObjects = | |||
| 566 | CallExpr::sizeOfTrailingObjects(/*NumPreArgs=*/0, NumArgs); | |||
| 567 | void *Mem = Ctx.Allocate(sizeof(CXXOperatorCallExpr) + SizeOfTrailingObjects, | |||
| 568 | alignof(CXXOperatorCallExpr)); | |||
| 569 | return new (Mem) CXXOperatorCallExpr(OpKind, Fn, Args, Ty, VK, OperatorLoc, | |||
| 570 | FPFeatures, UsesADL); | |||
| 571 | } | |||
| 572 | ||||
| 573 | CXXOperatorCallExpr *CXXOperatorCallExpr::CreateEmpty(const ASTContext &Ctx, | |||
| 574 | unsigned NumArgs, | |||
| 575 | EmptyShell Empty) { | |||
| 576 | // Allocate storage for the trailing objects of CallExpr. | |||
| 577 | unsigned SizeOfTrailingObjects = | |||
| 578 | CallExpr::sizeOfTrailingObjects(/*NumPreArgs=*/0, NumArgs); | |||
| 579 | void *Mem = Ctx.Allocate(sizeof(CXXOperatorCallExpr) + SizeOfTrailingObjects, | |||
| 580 | alignof(CXXOperatorCallExpr)); | |||
| 581 | return new (Mem) CXXOperatorCallExpr(NumArgs, Empty); | |||
| 582 | } | |||
| 583 | ||||
| 584 | SourceRange CXXOperatorCallExpr::getSourceRangeImpl() const { | |||
| 585 | OverloadedOperatorKind Kind = getOperator(); | |||
| 586 | if (Kind == OO_PlusPlus || Kind == OO_MinusMinus) { | |||
| 587 | if (getNumArgs() == 1) | |||
| 588 | // Prefix operator | |||
| 589 | return SourceRange(getOperatorLoc(), getArg(0)->getEndLoc()); | |||
| 590 | else | |||
| 591 | // Postfix operator | |||
| 592 | return SourceRange(getArg(0)->getBeginLoc(), getOperatorLoc()); | |||
| 593 | } else if (Kind == OO_Arrow) { | |||
| 594 | return getArg(0)->getSourceRange(); | |||
| 595 | } else if (Kind == OO_Call) { | |||
| 596 | return SourceRange(getArg(0)->getBeginLoc(), getRParenLoc()); | |||
| 597 | } else if (Kind == OO_Subscript) { | |||
| 598 | return SourceRange(getArg(0)->getBeginLoc(), getRParenLoc()); | |||
| 599 | } else if (getNumArgs() == 1) { | |||
| 600 | return SourceRange(getOperatorLoc(), getArg(0)->getEndLoc()); | |||
| 601 | } else if (getNumArgs() == 2) { | |||
| 602 | return SourceRange(getArg(0)->getBeginLoc(), getArg(1)->getEndLoc()); | |||
| 603 | } else { | |||
| 604 | return getOperatorLoc(); | |||
| 605 | } | |||
| 606 | } | |||
| 607 | ||||
| 608 | CXXMemberCallExpr::CXXMemberCallExpr(Expr *Fn, ArrayRef<Expr *> Args, | |||
| 609 | QualType Ty, ExprValueKind VK, | |||
| 610 | SourceLocation RP, unsigned MinNumArgs) | |||
| 611 | : CallExpr(CXXMemberCallExprClass, Fn, /*PreArgs=*/{}, Args, Ty, VK, RP, | |||
| 612 | MinNumArgs, NotADL) {} | |||
| 613 | ||||
| 614 | CXXMemberCallExpr::CXXMemberCallExpr(unsigned NumArgs, EmptyShell Empty) | |||
| 615 | : CallExpr(CXXMemberCallExprClass, /*NumPreArgs=*/0, NumArgs, Empty) {} | |||
| 616 | ||||
| 617 | CXXMemberCallExpr *CXXMemberCallExpr::Create(const ASTContext &Ctx, Expr *Fn, | |||
| 618 | ArrayRef<Expr *> Args, QualType Ty, | |||
| 619 | ExprValueKind VK, | |||
| 620 | SourceLocation RP, | |||
| 621 | unsigned MinNumArgs) { | |||
| 622 | // Allocate storage for the trailing objects of CallExpr. | |||
| 623 | unsigned NumArgs = std::max<unsigned>(Args.size(), MinNumArgs); | |||
| 624 | unsigned SizeOfTrailingObjects = | |||
| 625 | CallExpr::sizeOfTrailingObjects(/*NumPreArgs=*/0, NumArgs); | |||
| 626 | void *Mem = Ctx.Allocate(sizeof(CXXMemberCallExpr) + SizeOfTrailingObjects, | |||
| 627 | alignof(CXXMemberCallExpr)); | |||
| 628 | return new (Mem) CXXMemberCallExpr(Fn, Args, Ty, VK, RP, MinNumArgs); | |||
| 629 | } | |||
| 630 | ||||
| 631 | CXXMemberCallExpr *CXXMemberCallExpr::CreateEmpty(const ASTContext &Ctx, | |||
| 632 | unsigned NumArgs, | |||
| 633 | EmptyShell Empty) { | |||
| 634 | // Allocate storage for the trailing objects of CallExpr. | |||
| 635 | unsigned SizeOfTrailingObjects = | |||
| 636 | CallExpr::sizeOfTrailingObjects(/*NumPreArgs=*/0, NumArgs); | |||
| 637 | void *Mem = Ctx.Allocate(sizeof(CXXMemberCallExpr) + SizeOfTrailingObjects, | |||
| 638 | alignof(CXXMemberCallExpr)); | |||
| 639 | return new (Mem) CXXMemberCallExpr(NumArgs, Empty); | |||
| 640 | } | |||
| 641 | ||||
| 642 | Expr *CXXMemberCallExpr::getImplicitObjectArgument() const { | |||
| 643 | const Expr *Callee = getCallee()->IgnoreParens(); | |||
| 644 | if (const auto *MemExpr = dyn_cast<MemberExpr>(Callee)) | |||
| 645 | return MemExpr->getBase(); | |||
| 646 | if (const auto *BO = dyn_cast<BinaryOperator>(Callee)) | |||
| 647 | if (BO->getOpcode() == BO_PtrMemD || BO->getOpcode() == BO_PtrMemI) | |||
| 648 | return BO->getLHS(); | |||
| 649 | ||||
| 650 | // FIXME: Will eventually need to cope with member pointers. | |||
| 651 | return nullptr; | |||
| 652 | } | |||
| 653 | ||||
| 654 | CXXMethodDecl *CXXMemberCallExpr::getMethodDecl() const { | |||
| 655 | if (const auto *MemExpr = dyn_cast<MemberExpr>(getCallee()->IgnoreParens())) | |||
| 656 | return cast<CXXMethodDecl>(MemExpr->getMemberDecl()); | |||
| 657 | ||||
| 658 | // FIXME: Will eventually need to cope with member pointers. | |||
| 659 | return nullptr; | |||
| 660 | } | |||
| 661 | ||||
| 662 | CXXRecordDecl *CXXMemberCallExpr::getRecordDecl() const { | |||
| 663 | Expr* ThisArg = getImplicitObjectArgument(); | |||
| 664 | if (!ThisArg) | |||
| 665 | return nullptr; | |||
| 666 | ||||
| 667 | if (ThisArg->getType()->isAnyPointerType()) | |||
| 668 | return ThisArg->getType()->getPointeeType()->getAsCXXRecordDecl(); | |||
| 669 | ||||
| 670 | return ThisArg->getType()->getAsCXXRecordDecl(); | |||
| 671 | } | |||
| 672 | ||||
| 673 | //===----------------------------------------------------------------------===// | |||
| 674 | // Named casts | |||
| 675 | //===----------------------------------------------------------------------===// | |||
| 676 | ||||
| 677 | /// getCastName - Get the name of the C++ cast being used, e.g., | |||
| 678 | /// "static_cast", "dynamic_cast", "reinterpret_cast", or | |||
| 679 | /// "const_cast". The returned pointer must not be freed. | |||
| 680 | const char *CXXNamedCastExpr::getCastName() const { | |||
| 681 | switch (getStmtClass()) { | |||
| 682 | case CXXStaticCastExprClass: return "static_cast"; | |||
| 683 | case CXXDynamicCastExprClass: return "dynamic_cast"; | |||
| 684 | case CXXReinterpretCastExprClass: return "reinterpret_cast"; | |||
| 685 | case CXXConstCastExprClass: return "const_cast"; | |||
| 686 | default: return "<invalid cast>"; | |||
| 687 | } | |||
| 688 | } | |||
| 689 | ||||
| 690 | CXXStaticCastExpr *CXXStaticCastExpr::Create(const ASTContext &C, QualType T, | |||
| 691 | ExprValueKind VK, | |||
| 692 | CastKind K, Expr *Op, | |||
| 693 | const CXXCastPath *BasePath, | |||
| 694 | TypeSourceInfo *WrittenTy, | |||
| 695 | SourceLocation L, | |||
| 696 | SourceLocation RParenLoc, | |||
| 697 | SourceRange AngleBrackets) { | |||
| 698 | unsigned PathSize = (BasePath ? BasePath->size() : 0); | |||
| 699 | void *Buffer = C.Allocate(totalSizeToAlloc<CXXBaseSpecifier *>(PathSize)); | |||
| 700 | auto *E = | |||
| 701 | new (Buffer) CXXStaticCastExpr(T, VK, K, Op, PathSize, WrittenTy, L, | |||
| 702 | RParenLoc, AngleBrackets); | |||
| 703 | if (PathSize) | |||
| 704 | std::uninitialized_copy_n(BasePath->data(), BasePath->size(), | |||
| 705 | E->getTrailingObjects<CXXBaseSpecifier *>()); | |||
| 706 | return E; | |||
| 707 | } | |||
| 708 | ||||
| 709 | CXXStaticCastExpr *CXXStaticCastExpr::CreateEmpty(const ASTContext &C, | |||
| 710 | unsigned PathSize) { | |||
| 711 | void *Buffer = C.Allocate(totalSizeToAlloc<CXXBaseSpecifier *>(PathSize)); | |||
| 712 | return new (Buffer) CXXStaticCastExpr(EmptyShell(), PathSize); | |||
| 713 | } | |||
| 714 | ||||
| 715 | CXXDynamicCastExpr *CXXDynamicCastExpr::Create(const ASTContext &C, QualType T, | |||
| 716 | ExprValueKind VK, | |||
| 717 | CastKind K, Expr *Op, | |||
| 718 | const CXXCastPath *BasePath, | |||
| 719 | TypeSourceInfo *WrittenTy, | |||
| 720 | SourceLocation L, | |||
| 721 | SourceLocation RParenLoc, | |||
| 722 | SourceRange AngleBrackets) { | |||
| 723 | unsigned PathSize = (BasePath ? BasePath->size() : 0); | |||
| 724 | void *Buffer = C.Allocate(totalSizeToAlloc<CXXBaseSpecifier *>(PathSize)); | |||
| 725 | auto *E = | |||
| 726 | new (Buffer) CXXDynamicCastExpr(T, VK, K, Op, PathSize, WrittenTy, L, | |||
| 727 | RParenLoc, AngleBrackets); | |||
| 728 | if (PathSize) | |||
| 729 | std::uninitialized_copy_n(BasePath->data(), BasePath->size(), | |||
| 730 | E->getTrailingObjects<CXXBaseSpecifier *>()); | |||
| 731 | return E; | |||
| 732 | } | |||
| 733 | ||||
| 734 | CXXDynamicCastExpr *CXXDynamicCastExpr::CreateEmpty(const ASTContext &C, | |||
| 735 | unsigned PathSize) { | |||
| 736 | void *Buffer = C.Allocate(totalSizeToAlloc<CXXBaseSpecifier *>(PathSize)); | |||
| 737 | return new (Buffer) CXXDynamicCastExpr(EmptyShell(), PathSize); | |||
| 738 | } | |||
| 739 | ||||
| 740 | /// isAlwaysNull - Return whether the result of the dynamic_cast is proven | |||
| 741 | /// to always be null. For example: | |||
| 742 | /// | |||
| 743 | /// struct A { }; | |||
| 744 | /// struct B final : A { }; | |||
| 745 | /// struct C { }; | |||
| 746 | /// | |||
| 747 | /// C *f(B* b) { return dynamic_cast<C*>(b); } | |||
| 748 | bool CXXDynamicCastExpr::isAlwaysNull() const | |||
| 749 | { | |||
| 750 | QualType SrcType = getSubExpr()->getType(); | |||
| 751 | QualType DestType = getType(); | |||
| 752 | ||||
| 753 | if (const auto *SrcPTy = SrcType->getAs<PointerType>()) { | |||
| 754 | SrcType = SrcPTy->getPointeeType(); | |||
| 755 | DestType = DestType->castAs<PointerType>()->getPointeeType(); | |||
| 756 | } | |||
| 757 | ||||
| 758 | if (DestType->isVoidType()) | |||
| 759 | return false; | |||
| 760 | ||||
| 761 | const auto *SrcRD = | |||
| 762 | cast<CXXRecordDecl>(SrcType->castAs<RecordType>()->getDecl()); | |||
| 763 | ||||
| 764 | if (!SrcRD->hasAttr<FinalAttr>()) | |||
| 765 | return false; | |||
| 766 | ||||
| 767 | const auto *DestRD = | |||
| 768 | cast<CXXRecordDecl>(DestType->castAs<RecordType>()->getDecl()); | |||
| 769 | ||||
| 770 | return !DestRD->isDerivedFrom(SrcRD); | |||
| 771 | } | |||
| 772 | ||||
| 773 | CXXReinterpretCastExpr * | |||
| 774 | CXXReinterpretCastExpr::Create(const ASTContext &C, QualType T, | |||
| 775 | ExprValueKind VK, CastKind K, Expr *Op, | |||
| 776 | const CXXCastPath *BasePath, | |||
| 777 | TypeSourceInfo *WrittenTy, SourceLocation L, | |||
| 778 | SourceLocation RParenLoc, | |||
| 779 | SourceRange AngleBrackets) { | |||
| 780 | unsigned PathSize = (BasePath ? BasePath->size() : 0); | |||
| 781 | void *Buffer = C.Allocate(totalSizeToAlloc<CXXBaseSpecifier *>(PathSize)); | |||
| 782 | auto *E = | |||
| 783 | new (Buffer) CXXReinterpretCastExpr(T, VK, K, Op, PathSize, WrittenTy, L, | |||
| 784 | RParenLoc, AngleBrackets); | |||
| 785 | if (PathSize) | |||
| 786 | std::uninitialized_copy_n(BasePath->data(), BasePath->size(), | |||
| 787 | E->getTrailingObjects<CXXBaseSpecifier *>()); | |||
| 788 | return E; | |||
| 789 | } | |||
| 790 | ||||
| 791 | CXXReinterpretCastExpr * | |||
| 792 | CXXReinterpretCastExpr::CreateEmpty(const ASTContext &C, unsigned PathSize) { | |||
| 793 | void *Buffer = C.Allocate(totalSizeToAlloc<CXXBaseSpecifier *>(PathSize)); | |||
| 794 | return new (Buffer) CXXReinterpretCastExpr(EmptyShell(), PathSize); | |||
| 795 | } | |||
| 796 | ||||
| 797 | CXXConstCastExpr *CXXConstCastExpr::Create(const ASTContext &C, QualType T, | |||
| 798 | ExprValueKind VK, Expr *Op, | |||
| 799 | TypeSourceInfo *WrittenTy, | |||
| 800 | SourceLocation L, | |||
| 801 | SourceLocation RParenLoc, | |||
| 802 | SourceRange AngleBrackets) { | |||
| 803 | return new (C) CXXConstCastExpr(T, VK, Op, WrittenTy, L, RParenLoc, AngleBrackets); | |||
| 804 | } | |||
| 805 | ||||
| 806 | CXXConstCastExpr *CXXConstCastExpr::CreateEmpty(const ASTContext &C) { | |||
| 807 | return new (C) CXXConstCastExpr(EmptyShell()); | |||
| 808 | } | |||
| 809 | ||||
| 810 | CXXFunctionalCastExpr * | |||
| 811 | CXXFunctionalCastExpr::Create(const ASTContext &C, QualType T, ExprValueKind VK, | |||
| 812 | TypeSourceInfo *Written, CastKind K, Expr *Op, | |||
| 813 | const CXXCastPath *BasePath, | |||
| 814 | SourceLocation L, SourceLocation R) { | |||
| 815 | unsigned PathSize = (BasePath ? BasePath->size() : 0); | |||
| 816 | void *Buffer = C.Allocate(totalSizeToAlloc<CXXBaseSpecifier *>(PathSize)); | |||
| 817 | auto *E = | |||
| 818 | new (Buffer) CXXFunctionalCastExpr(T, VK, Written, K, Op, PathSize, L, R); | |||
| 819 | if (PathSize) | |||
| 820 | std::uninitialized_copy_n(BasePath->data(), BasePath->size(), | |||
| 821 | E->getTrailingObjects<CXXBaseSpecifier *>()); | |||
| 822 | return E; | |||
| 823 | } | |||
| 824 | ||||
| 825 | CXXFunctionalCastExpr * | |||
| 826 | CXXFunctionalCastExpr::CreateEmpty(const ASTContext &C, unsigned PathSize) { | |||
| 827 | void *Buffer = C.Allocate(totalSizeToAlloc<CXXBaseSpecifier *>(PathSize)); | |||
| 828 | return new (Buffer) CXXFunctionalCastExpr(EmptyShell(), PathSize); | |||
| 829 | } | |||
| 830 | ||||
| 831 | SourceLocation CXXFunctionalCastExpr::getBeginLoc() const { | |||
| 832 | return getTypeInfoAsWritten()->getTypeLoc().getBeginLoc(); | |||
| 833 | } | |||
| 834 | ||||
| 835 | SourceLocation CXXFunctionalCastExpr::getEndLoc() const { | |||
| 836 | return RParenLoc.isValid() ? RParenLoc : getSubExpr()->getEndLoc(); | |||
| 837 | } | |||
| 838 | ||||
| 839 | UserDefinedLiteral::UserDefinedLiteral(Expr *Fn, ArrayRef<Expr *> Args, | |||
| 840 | QualType Ty, ExprValueKind VK, | |||
| 841 | SourceLocation LitEndLoc, | |||
| 842 | SourceLocation SuffixLoc) | |||
| 843 | : CallExpr(UserDefinedLiteralClass, Fn, /*PreArgs=*/{}, Args, Ty, VK, | |||
| 844 | LitEndLoc, /*MinNumArgs=*/0, NotADL), | |||
| 845 | UDSuffixLoc(SuffixLoc) {} | |||
| 846 | ||||
| 847 | UserDefinedLiteral::UserDefinedLiteral(unsigned NumArgs, EmptyShell Empty) | |||
| 848 | : CallExpr(UserDefinedLiteralClass, /*NumPreArgs=*/0, NumArgs, Empty) {} | |||
| 849 | ||||
| 850 | UserDefinedLiteral *UserDefinedLiteral::Create(const ASTContext &Ctx, Expr *Fn, | |||
| 851 | ArrayRef<Expr *> Args, | |||
| 852 | QualType Ty, ExprValueKind VK, | |||
| 853 | SourceLocation LitEndLoc, | |||
| 854 | SourceLocation SuffixLoc) { | |||
| 855 | // Allocate storage for the trailing objects of CallExpr. | |||
| 856 | unsigned NumArgs = Args.size(); | |||
| 857 | unsigned SizeOfTrailingObjects = | |||
| 858 | CallExpr::sizeOfTrailingObjects(/*NumPreArgs=*/0, NumArgs); | |||
| 859 | void *Mem = Ctx.Allocate(sizeof(UserDefinedLiteral) + SizeOfTrailingObjects, | |||
| 860 | alignof(UserDefinedLiteral)); | |||
| 861 | return new (Mem) UserDefinedLiteral(Fn, Args, Ty, VK, LitEndLoc, SuffixLoc); | |||
| 862 | } | |||
| 863 | ||||
| 864 | UserDefinedLiteral *UserDefinedLiteral::CreateEmpty(const ASTContext &Ctx, | |||
| 865 | unsigned NumArgs, | |||
| 866 | EmptyShell Empty) { | |||
| 867 | // Allocate storage for the trailing objects of CallExpr. | |||
| 868 | unsigned SizeOfTrailingObjects = | |||
| 869 | CallExpr::sizeOfTrailingObjects(/*NumPreArgs=*/0, NumArgs); | |||
| 870 | void *Mem = Ctx.Allocate(sizeof(UserDefinedLiteral) + SizeOfTrailingObjects, | |||
| 871 | alignof(UserDefinedLiteral)); | |||
| 872 | return new (Mem) UserDefinedLiteral(NumArgs, Empty); | |||
| 873 | } | |||
| 874 | ||||
| 875 | UserDefinedLiteral::LiteralOperatorKind | |||
| 876 | UserDefinedLiteral::getLiteralOperatorKind() const { | |||
| 877 | if (getNumArgs() == 0) | |||
| 878 | return LOK_Template; | |||
| 879 | if (getNumArgs() == 2) | |||
| 880 | return LOK_String; | |||
| 881 | ||||
| 882 | assert(getNumArgs() == 1 && "unexpected #args in literal operator call")((getNumArgs() == 1 && "unexpected #args in literal operator call" ) ? static_cast<void> (0) : __assert_fail ("getNumArgs() == 1 && \"unexpected #args in literal operator call\"" , "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/AST/ExprCXX.cpp" , 882, __PRETTY_FUNCTION__)); | |||
| 883 | QualType ParamTy = | |||
| 884 | cast<FunctionDecl>(getCalleeDecl())->getParamDecl(0)->getType(); | |||
| 885 | if (ParamTy->isPointerType()) | |||
| 886 | return LOK_Raw; | |||
| 887 | if (ParamTy->isAnyCharacterType()) | |||
| 888 | return LOK_Character; | |||
| 889 | if (ParamTy->isIntegerType()) | |||
| 890 | return LOK_Integer; | |||
| 891 | if (ParamTy->isFloatingType()) | |||
| 892 | return LOK_Floating; | |||
| 893 | ||||
| 894 | llvm_unreachable("unknown kind of literal operator")::llvm::llvm_unreachable_internal("unknown kind of literal operator" , "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/AST/ExprCXX.cpp" , 894); | |||
| 895 | } | |||
| 896 | ||||
| 897 | Expr *UserDefinedLiteral::getCookedLiteral() { | |||
| 898 | #ifndef NDEBUG | |||
| 899 | LiteralOperatorKind LOK = getLiteralOperatorKind(); | |||
| 900 | assert(LOK != LOK_Template && LOK != LOK_Raw && "not a cooked literal")((LOK != LOK_Template && LOK != LOK_Raw && "not a cooked literal" ) ? static_cast<void> (0) : __assert_fail ("LOK != LOK_Template && LOK != LOK_Raw && \"not a cooked literal\"" , "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/AST/ExprCXX.cpp" , 900, __PRETTY_FUNCTION__)); | |||
| 901 | #endif | |||
| 902 | return getArg(0); | |||
| 903 | } | |||
| 904 | ||||
| 905 | const IdentifierInfo *UserDefinedLiteral::getUDSuffix() const { | |||
| 906 | return cast<FunctionDecl>(getCalleeDecl())->getLiteralIdentifier(); | |||
| 907 | } | |||
| 908 | ||||
| 909 | CXXDefaultInitExpr::CXXDefaultInitExpr(const ASTContext &Ctx, SourceLocation Loc, | |||
| 910 | FieldDecl *Field, QualType Ty, | |||
| 911 | DeclContext *UsedContext) | |||
| 912 | : Expr(CXXDefaultInitExprClass, Ty.getNonLValueExprType(Ctx), | |||
| 913 | Ty->isLValueReferenceType() ? VK_LValue : Ty->isRValueReferenceType() | |||
| 914 | ? VK_XValue | |||
| 915 | : VK_RValue, | |||
| 916 | /*FIXME*/ OK_Ordinary, false, false, false, false), | |||
| 917 | Field(Field), UsedContext(UsedContext) { | |||
| 918 | CXXDefaultInitExprBits.Loc = Loc; | |||
| 919 | assert(Field->hasInClassInitializer())((Field->hasInClassInitializer()) ? static_cast<void> (0) : __assert_fail ("Field->hasInClassInitializer()", "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/AST/ExprCXX.cpp" , 919, __PRETTY_FUNCTION__)); | |||
| 920 | } | |||
| 921 | ||||
| 922 | CXXTemporary *CXXTemporary::Create(const ASTContext &C, | |||
| 923 | const CXXDestructorDecl *Destructor) { | |||
| 924 | return new (C) CXXTemporary(Destructor); | |||
| 925 | } | |||
| 926 | ||||
| 927 | CXXBindTemporaryExpr *CXXBindTemporaryExpr::Create(const ASTContext &C, | |||
| 928 | CXXTemporary *Temp, | |||
| 929 | Expr* SubExpr) { | |||
| 930 | assert((SubExpr->getType()->isRecordType() ||(((SubExpr->getType()->isRecordType() || SubExpr->getType ()->isArrayType()) && "Expression bound to a temporary must have record or array type!" ) ? static_cast<void> (0) : __assert_fail ("(SubExpr->getType()->isRecordType() || SubExpr->getType()->isArrayType()) && \"Expression bound to a temporary must have record or array type!\"" , "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/AST/ExprCXX.cpp" , 932, __PRETTY_FUNCTION__)) | |||
| 931 | SubExpr->getType()->isArrayType()) &&(((SubExpr->getType()->isRecordType() || SubExpr->getType ()->isArrayType()) && "Expression bound to a temporary must have record or array type!" ) ? static_cast<void> (0) : __assert_fail ("(SubExpr->getType()->isRecordType() || SubExpr->getType()->isArrayType()) && \"Expression bound to a temporary must have record or array type!\"" , "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/AST/ExprCXX.cpp" , 932, __PRETTY_FUNCTION__)) | |||
| 932 | "Expression bound to a temporary must have record or array type!")(((SubExpr->getType()->isRecordType() || SubExpr->getType ()->isArrayType()) && "Expression bound to a temporary must have record or array type!" ) ? static_cast<void> (0) : __assert_fail ("(SubExpr->getType()->isRecordType() || SubExpr->getType()->isArrayType()) && \"Expression bound to a temporary must have record or array type!\"" , "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/AST/ExprCXX.cpp" , 932, __PRETTY_FUNCTION__)); | |||
| 933 | ||||
| 934 | return new (C) CXXBindTemporaryExpr(Temp, SubExpr); | |||
| 935 | } | |||
| 936 | ||||
| 937 | CXXTemporaryObjectExpr::CXXTemporaryObjectExpr( | |||
| 938 | CXXConstructorDecl *Cons, QualType Ty, TypeSourceInfo *TSI, | |||
| 939 | ArrayRef<Expr *> Args, SourceRange ParenOrBraceRange, | |||
| 940 | bool HadMultipleCandidates, bool ListInitialization, | |||
| 941 | bool StdInitListInitialization, bool ZeroInitialization) | |||
| 942 | : CXXConstructExpr( | |||
| 943 | CXXTemporaryObjectExprClass, Ty, TSI->getTypeLoc().getBeginLoc(), | |||
| 944 | Cons, /* Elidable=*/false, Args, HadMultipleCandidates, | |||
| 945 | ListInitialization, StdInitListInitialization, ZeroInitialization, | |||
| 946 | CXXConstructExpr::CK_Complete, ParenOrBraceRange), | |||
| 947 | TSI(TSI) {} | |||
| 948 | ||||
| 949 | CXXTemporaryObjectExpr::CXXTemporaryObjectExpr(EmptyShell Empty, | |||
| 950 | unsigned NumArgs) | |||
| 951 | : CXXConstructExpr(CXXTemporaryObjectExprClass, Empty, NumArgs) {} | |||
| 952 | ||||
| 953 | CXXTemporaryObjectExpr *CXXTemporaryObjectExpr::Create( | |||
| 954 | const ASTContext &Ctx, CXXConstructorDecl *Cons, QualType Ty, | |||
| 955 | TypeSourceInfo *TSI, ArrayRef<Expr *> Args, SourceRange ParenOrBraceRange, | |||
| 956 | bool HadMultipleCandidates, bool ListInitialization, | |||
| 957 | bool StdInitListInitialization, bool ZeroInitialization) { | |||
| 958 | unsigned SizeOfTrailingObjects = sizeOfTrailingObjects(Args.size()); | |||
| 959 | void *Mem = | |||
| 960 | Ctx.Allocate(sizeof(CXXTemporaryObjectExpr) + SizeOfTrailingObjects, | |||
| 961 | alignof(CXXTemporaryObjectExpr)); | |||
| 962 | return new (Mem) CXXTemporaryObjectExpr( | |||
| 963 | Cons, Ty, TSI, Args, ParenOrBraceRange, HadMultipleCandidates, | |||
| 964 | ListInitialization, StdInitListInitialization, ZeroInitialization); | |||
| 965 | } | |||
| 966 | ||||
| 967 | CXXTemporaryObjectExpr * | |||
| 968 | CXXTemporaryObjectExpr::CreateEmpty(const ASTContext &Ctx, unsigned NumArgs) { | |||
| 969 | unsigned SizeOfTrailingObjects = sizeOfTrailingObjects(NumArgs); | |||
| 970 | void *Mem = | |||
| 971 | Ctx.Allocate(sizeof(CXXTemporaryObjectExpr) + SizeOfTrailingObjects, | |||
| 972 | alignof(CXXTemporaryObjectExpr)); | |||
| 973 | return new (Mem) CXXTemporaryObjectExpr(EmptyShell(), NumArgs); | |||
| 974 | } | |||
| 975 | ||||
| 976 | SourceLocation CXXTemporaryObjectExpr::getBeginLoc() const { | |||
| 977 | return getTypeSourceInfo()->getTypeLoc().getBeginLoc(); | |||
| 978 | } | |||
| 979 | ||||
| 980 | SourceLocation CXXTemporaryObjectExpr::getEndLoc() const { | |||
| 981 | SourceLocation Loc = getParenOrBraceRange().getEnd(); | |||
| 982 | if (Loc.isInvalid() && getNumArgs()) | |||
| 983 | Loc = getArg(getNumArgs() - 1)->getEndLoc(); | |||
| 984 | return Loc; | |||
| 985 | } | |||
| 986 | ||||
| 987 | CXXConstructExpr *CXXConstructExpr::Create( | |||
| 988 | const ASTContext &Ctx, QualType Ty, SourceLocation Loc, | |||
| 989 | CXXConstructorDecl *Ctor, bool Elidable, ArrayRef<Expr *> Args, | |||
| 990 | bool HadMultipleCandidates, bool ListInitialization, | |||
| 991 | bool StdInitListInitialization, bool ZeroInitialization, | |||
| 992 | ConstructionKind ConstructKind, SourceRange ParenOrBraceRange) { | |||
| 993 | unsigned SizeOfTrailingObjects = sizeOfTrailingObjects(Args.size()); | |||
| 994 | void *Mem = Ctx.Allocate(sizeof(CXXConstructExpr) + SizeOfTrailingObjects, | |||
| 995 | alignof(CXXConstructExpr)); | |||
| 996 | return new (Mem) CXXConstructExpr( | |||
| 997 | CXXConstructExprClass, Ty, Loc, Ctor, Elidable, Args, | |||
| 998 | HadMultipleCandidates, ListInitialization, StdInitListInitialization, | |||
| 999 | ZeroInitialization, ConstructKind, ParenOrBraceRange); | |||
| 1000 | } | |||
| 1001 | ||||
| 1002 | CXXConstructExpr *CXXConstructExpr::CreateEmpty(const ASTContext &Ctx, | |||
| 1003 | unsigned NumArgs) { | |||
| 1004 | unsigned SizeOfTrailingObjects = sizeOfTrailingObjects(NumArgs); | |||
| 1005 | void *Mem = Ctx.Allocate(sizeof(CXXConstructExpr) + SizeOfTrailingObjects, | |||
| 1006 | alignof(CXXConstructExpr)); | |||
| 1007 | return new (Mem) | |||
| 1008 | CXXConstructExpr(CXXConstructExprClass, EmptyShell(), NumArgs); | |||
| 1009 | } | |||
| 1010 | ||||
| 1011 | CXXConstructExpr::CXXConstructExpr( | |||
| 1012 | StmtClass SC, QualType Ty, SourceLocation Loc, CXXConstructorDecl *Ctor, | |||
| 1013 | bool Elidable, ArrayRef<Expr *> Args, bool HadMultipleCandidates, | |||
| 1014 | bool ListInitialization, bool StdInitListInitialization, | |||
| 1015 | bool ZeroInitialization, ConstructionKind ConstructKind, | |||
| 1016 | SourceRange ParenOrBraceRange) | |||
| 1017 | : Expr(SC, Ty, VK_RValue, OK_Ordinary, Ty->isDependentType(), | |||
| 1018 | Ty->isDependentType(), Ty->isInstantiationDependentType(), | |||
| 1019 | Ty->containsUnexpandedParameterPack()), | |||
| 1020 | Constructor(Ctor), ParenOrBraceRange(ParenOrBraceRange), | |||
| 1021 | NumArgs(Args.size()) { | |||
| 1022 | CXXConstructExprBits.Elidable = Elidable; | |||
| 1023 | CXXConstructExprBits.HadMultipleCandidates = HadMultipleCandidates; | |||
| 1024 | CXXConstructExprBits.ListInitialization = ListInitialization; | |||
| 1025 | CXXConstructExprBits.StdInitListInitialization = StdInitListInitialization; | |||
| 1026 | CXXConstructExprBits.ZeroInitialization = ZeroInitialization; | |||
| 1027 | CXXConstructExprBits.ConstructionKind = ConstructKind; | |||
| 1028 | CXXConstructExprBits.Loc = Loc; | |||
| 1029 | ||||
| 1030 | Stmt **TrailingArgs = getTrailingArgs(); | |||
| 1031 | for (unsigned I = 0, N = Args.size(); I != N; ++I) { | |||
| 1032 | assert(Args[I] && "NULL argument in CXXConstructExpr!")((Args[I] && "NULL argument in CXXConstructExpr!") ? static_cast <void> (0) : __assert_fail ("Args[I] && \"NULL argument in CXXConstructExpr!\"" , "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/AST/ExprCXX.cpp" , 1032, __PRETTY_FUNCTION__)); | |||
| 1033 | ||||
| 1034 | if (Args[I]->isValueDependent()) | |||
| 1035 | ExprBits.ValueDependent = true; | |||
| 1036 | if (Args[I]->isInstantiationDependent()) | |||
| 1037 | ExprBits.InstantiationDependent = true; | |||
| 1038 | if (Args[I]->containsUnexpandedParameterPack()) | |||
| 1039 | ExprBits.ContainsUnexpandedParameterPack = true; | |||
| 1040 | ||||
| 1041 | TrailingArgs[I] = Args[I]; | |||
| 1042 | } | |||
| 1043 | } | |||
| 1044 | ||||
| 1045 | CXXConstructExpr::CXXConstructExpr(StmtClass SC, EmptyShell Empty, | |||
| 1046 | unsigned NumArgs) | |||
| 1047 | : Expr(SC, Empty), NumArgs(NumArgs) {} | |||
| 1048 | ||||
| 1049 | LambdaCapture::LambdaCapture(SourceLocation Loc, bool Implicit, | |||
| 1050 | LambdaCaptureKind Kind, VarDecl *Var, | |||
| 1051 | SourceLocation EllipsisLoc) | |||
| 1052 | : DeclAndBits(Var, 0), Loc(Loc), EllipsisLoc(EllipsisLoc) { | |||
| 1053 | unsigned Bits = 0; | |||
| 1054 | if (Implicit) | |||
| 1055 | Bits |= Capture_Implicit; | |||
| 1056 | ||||
| 1057 | switch (Kind) { | |||
| 1058 | case LCK_StarThis: | |||
| 1059 | Bits |= Capture_ByCopy; | |||
| 1060 | LLVM_FALLTHROUGH[[clang::fallthrough]]; | |||
| 1061 | case LCK_This: | |||
| 1062 | assert(!Var && "'this' capture cannot have a variable!")((!Var && "'this' capture cannot have a variable!") ? static_cast<void> (0) : __assert_fail ("!Var && \"'this' capture cannot have a variable!\"" , "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/AST/ExprCXX.cpp" , 1062, __PRETTY_FUNCTION__)); | |||
| 1063 | Bits |= Capture_This; | |||
| 1064 | break; | |||
| 1065 | ||||
| 1066 | case LCK_ByCopy: | |||
| 1067 | Bits |= Capture_ByCopy; | |||
| 1068 | LLVM_FALLTHROUGH[[clang::fallthrough]]; | |||
| 1069 | case LCK_ByRef: | |||
| 1070 | assert(Var && "capture must have a variable!")((Var && "capture must have a variable!") ? static_cast <void> (0) : __assert_fail ("Var && \"capture must have a variable!\"" , "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/AST/ExprCXX.cpp" , 1070, __PRETTY_FUNCTION__)); | |||
| 1071 | break; | |||
| 1072 | case LCK_VLAType: | |||
| 1073 | assert(!Var && "VLA type capture cannot have a variable!")((!Var && "VLA type capture cannot have a variable!") ? static_cast<void> (0) : __assert_fail ("!Var && \"VLA type capture cannot have a variable!\"" , "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/AST/ExprCXX.cpp" , 1073, __PRETTY_FUNCTION__)); | |||
| 1074 | break; | |||
| 1075 | } | |||
| 1076 | DeclAndBits.setInt(Bits); | |||
| 1077 | } | |||
| 1078 | ||||
| 1079 | LambdaCaptureKind LambdaCapture::getCaptureKind() const { | |||
| 1080 | if (capturesVLAType()) | |||
| 1081 | return LCK_VLAType; | |||
| 1082 | bool CapByCopy = DeclAndBits.getInt() & Capture_ByCopy; | |||
| 1083 | if (capturesThis()) | |||
| 1084 | return CapByCopy ? LCK_StarThis : LCK_This; | |||
| 1085 | return CapByCopy ? LCK_ByCopy : LCK_ByRef; | |||
| 1086 | } | |||
| 1087 | ||||
| 1088 | LambdaExpr::LambdaExpr(QualType T, SourceRange IntroducerRange, | |||
| 1089 | LambdaCaptureDefault CaptureDefault, | |||
| 1090 | SourceLocation CaptureDefaultLoc, | |||
| 1091 | ArrayRef<LambdaCapture> Captures, bool ExplicitParams, | |||
| 1092 | bool ExplicitResultType, ArrayRef<Expr *> CaptureInits, | |||
| 1093 | SourceLocation ClosingBrace, | |||
| 1094 | bool ContainsUnexpandedParameterPack) | |||
| 1095 | : Expr(LambdaExprClass, T, VK_RValue, OK_Ordinary, T->isDependentType(), | |||
| 1096 | T->isDependentType(), T->isDependentType(), | |||
| 1097 | ContainsUnexpandedParameterPack), | |||
| 1098 | IntroducerRange(IntroducerRange), CaptureDefaultLoc(CaptureDefaultLoc), | |||
| 1099 | NumCaptures(Captures.size()), CaptureDefault(CaptureDefault), | |||
| 1100 | ExplicitParams(ExplicitParams), ExplicitResultType(ExplicitResultType), | |||
| 1101 | ClosingBrace(ClosingBrace) { | |||
| 1102 | assert(CaptureInits.size() == Captures.size() && "Wrong number of arguments")((CaptureInits.size() == Captures.size() && "Wrong number of arguments" ) ? static_cast<void> (0) : __assert_fail ("CaptureInits.size() == Captures.size() && \"Wrong number of arguments\"" , "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/AST/ExprCXX.cpp" , 1102, __PRETTY_FUNCTION__)); | |||
| 1103 | CXXRecordDecl *Class = getLambdaClass(); | |||
| 1104 | CXXRecordDecl::LambdaDefinitionData &Data = Class->getLambdaData(); | |||
| 1105 | ||||
| 1106 | // FIXME: Propagate "has unexpanded parameter pack" bit. | |||
| 1107 | ||||
| 1108 | // Copy captures. | |||
| 1109 | const ASTContext &Context = Class->getASTContext(); | |||
| 1110 | Data.NumCaptures = NumCaptures; | |||
| 1111 | Data.NumExplicitCaptures = 0; | |||
| 1112 | Data.Captures = | |||
| 1113 | (LambdaCapture *)Context.Allocate(sizeof(LambdaCapture) * NumCaptures); | |||
| 1114 | LambdaCapture *ToCapture = Data.Captures; | |||
| 1115 | for (unsigned I = 0, N = Captures.size(); I != N; ++I) { | |||
| 1116 | if (Captures[I].isExplicit()) | |||
| 1117 | ++Data.NumExplicitCaptures; | |||
| 1118 | ||||
| 1119 | *ToCapture++ = Captures[I]; | |||
| 1120 | } | |||
| 1121 | ||||
| 1122 | // Copy initialization expressions for the non-static data members. | |||
| 1123 | Stmt **Stored = getStoredStmts(); | |||
| 1124 | for (unsigned I = 0, N = CaptureInits.size(); I != N; ++I) | |||
| 1125 | *Stored++ = CaptureInits[I]; | |||
| 1126 | ||||
| 1127 | // Copy the body of the lambda. | |||
| 1128 | *Stored++ = getCallOperator()->getBody(); | |||
| 1129 | } | |||
| 1130 | ||||
| 1131 | LambdaExpr *LambdaExpr::Create( | |||
| 1132 | const ASTContext &Context, CXXRecordDecl *Class, | |||
| 1133 | SourceRange IntroducerRange, LambdaCaptureDefault CaptureDefault, | |||
| 1134 | SourceLocation CaptureDefaultLoc, ArrayRef<LambdaCapture> Captures, | |||
| 1135 | bool ExplicitParams, bool ExplicitResultType, ArrayRef<Expr *> CaptureInits, | |||
| 1136 | SourceLocation ClosingBrace, bool ContainsUnexpandedParameterPack) { | |||
| 1137 | // Determine the type of the expression (i.e., the type of the | |||
| 1138 | // function object we're creating). | |||
| 1139 | QualType T = Context.getTypeDeclType(Class); | |||
| 1140 | ||||
| 1141 | unsigned Size = totalSizeToAlloc<Stmt *>(Captures.size() + 1); | |||
| 1142 | void *Mem = Context.Allocate(Size); | |||
| 1143 | return new (Mem) | |||
| 1144 | LambdaExpr(T, IntroducerRange, CaptureDefault, CaptureDefaultLoc, | |||
| 1145 | Captures, ExplicitParams, ExplicitResultType, CaptureInits, | |||
| 1146 | ClosingBrace, ContainsUnexpandedParameterPack); | |||
| 1147 | } | |||
| 1148 | ||||
| 1149 | LambdaExpr *LambdaExpr::CreateDeserialized(const ASTContext &C, | |||
| 1150 | unsigned NumCaptures) { | |||
| 1151 | unsigned Size = totalSizeToAlloc<Stmt *>(NumCaptures + 1); | |||
| 1152 | void *Mem = C.Allocate(Size); | |||
| 1153 | return new (Mem) LambdaExpr(EmptyShell(), NumCaptures); | |||
| 1154 | } | |||
| 1155 | ||||
| 1156 | bool LambdaExpr::isInitCapture(const LambdaCapture *C) const { | |||
| 1157 | return (C->capturesVariable() && C->getCapturedVar()->isInitCapture() && | |||
| 1158 | (getCallOperator() == C->getCapturedVar()->getDeclContext())); | |||
| 1159 | } | |||
| 1160 | ||||
| 1161 | LambdaExpr::capture_iterator LambdaExpr::capture_begin() const { | |||
| 1162 | return getLambdaClass()->getLambdaData().Captures; | |||
| 1163 | } | |||
| 1164 | ||||
| 1165 | LambdaExpr::capture_iterator LambdaExpr::capture_end() const { | |||
| 1166 | return capture_begin() + NumCaptures; | |||
| 1167 | } | |||
| 1168 | ||||
| 1169 | LambdaExpr::capture_range LambdaExpr::captures() const { | |||
| 1170 | return capture_range(capture_begin(), capture_end()); | |||
| 1171 | } | |||
| 1172 | ||||
| 1173 | LambdaExpr::capture_iterator LambdaExpr::explicit_capture_begin() const { | |||
| 1174 | return capture_begin(); | |||
| 1175 | } | |||
| 1176 | ||||
| 1177 | LambdaExpr::capture_iterator LambdaExpr::explicit_capture_end() const { | |||
| 1178 | struct CXXRecordDecl::LambdaDefinitionData &Data | |||
| 1179 | = getLambdaClass()->getLambdaData(); | |||
| 1180 | return Data.Captures + Data.NumExplicitCaptures; | |||
| 1181 | } | |||
| 1182 | ||||
| 1183 | LambdaExpr::capture_range LambdaExpr::explicit_captures() const { | |||
| 1184 | return capture_range(explicit_capture_begin(), explicit_capture_end()); | |||
| 1185 | } | |||
| 1186 | ||||
| 1187 | LambdaExpr::capture_iterator LambdaExpr::implicit_capture_begin() const { | |||
| 1188 | return explicit_capture_end(); | |||
| 1189 | } | |||
| 1190 | ||||
| 1191 | LambdaExpr::capture_iterator LambdaExpr::implicit_capture_end() const { | |||
| 1192 | return capture_end(); | |||
| 1193 | } | |||
| 1194 | ||||
| 1195 | LambdaExpr::capture_range LambdaExpr::implicit_captures() const { | |||
| 1196 | return capture_range(implicit_capture_begin(), implicit_capture_end()); | |||
| 1197 | } | |||
| 1198 | ||||
| 1199 | CXXRecordDecl *LambdaExpr::getLambdaClass() const { | |||
| 1200 | return getType()->getAsCXXRecordDecl(); | |||
| 1201 | } | |||
| 1202 | ||||
| 1203 | CXXMethodDecl *LambdaExpr::getCallOperator() const { | |||
| 1204 | CXXRecordDecl *Record = getLambdaClass(); | |||
| 1205 | return Record->getLambdaCallOperator(); | |||
| 1206 | } | |||
| 1207 | ||||
| 1208 | TemplateParameterList *LambdaExpr::getTemplateParameterList() const { | |||
| 1209 | CXXRecordDecl *Record = getLambdaClass(); | |||
| 1210 | return Record->getGenericLambdaTemplateParameterList(); | |||
| 1211 | } | |||
| 1212 | ||||
| 1213 | ArrayRef<NamedDecl *> LambdaExpr::getExplicitTemplateParameters() const { | |||
| 1214 | const CXXRecordDecl *Record = getLambdaClass(); | |||
| 1215 | return Record->getLambdaExplicitTemplateParameters(); | |||
| 1216 | } | |||
| 1217 | ||||
| 1218 | CompoundStmt *LambdaExpr::getBody() const { | |||
| 1219 | // FIXME: this mutation in getBody is bogus. It should be | |||
| 1220 | // initialized in ASTStmtReader::VisitLambdaExpr, but for reasons I | |||
| 1221 | // don't understand, that doesn't work. | |||
| 1222 | if (!getStoredStmts()[NumCaptures]) | |||
| 1223 | *const_cast<Stmt **>(&getStoredStmts()[NumCaptures]) = | |||
| 1224 | getCallOperator()->getBody(); | |||
| 1225 | ||||
| 1226 | return static_cast<CompoundStmt *>(getStoredStmts()[NumCaptures]); | |||
| 1227 | } | |||
| 1228 | ||||
| 1229 | bool LambdaExpr::isMutable() const { | |||
| 1230 | return !getCallOperator()->isConst(); | |||
| 1231 | } | |||
| 1232 | ||||
| 1233 | ExprWithCleanups::ExprWithCleanups(Expr *subexpr, | |||
| 1234 | bool CleanupsHaveSideEffects, | |||
| 1235 | ArrayRef<CleanupObject> objects) | |||
| 1236 | : FullExpr(ExprWithCleanupsClass, subexpr) { | |||
| 1237 | ExprWithCleanupsBits.CleanupsHaveSideEffects = CleanupsHaveSideEffects; | |||
| 1238 | ExprWithCleanupsBits.NumObjects = objects.size(); | |||
| 1239 | for (unsigned i = 0, e = objects.size(); i != e; ++i) | |||
| 1240 | getTrailingObjects<CleanupObject>()[i] = objects[i]; | |||
| 1241 | } | |||
| 1242 | ||||
| 1243 | ExprWithCleanups *ExprWithCleanups::Create(const ASTContext &C, Expr *subexpr, | |||
| 1244 | bool CleanupsHaveSideEffects, | |||
| 1245 | ArrayRef<CleanupObject> objects) { | |||
| 1246 | void *buffer = C.Allocate(totalSizeToAlloc<CleanupObject>(objects.size()), | |||
| 1247 | alignof(ExprWithCleanups)); | |||
| 1248 | return new (buffer) | |||
| 1249 | ExprWithCleanups(subexpr, CleanupsHaveSideEffects, objects); | |||
| 1250 | } | |||
| 1251 | ||||
| 1252 | ExprWithCleanups::ExprWithCleanups(EmptyShell empty, unsigned numObjects) | |||
| 1253 | : FullExpr(ExprWithCleanupsClass, empty) { | |||
| 1254 | ExprWithCleanupsBits.NumObjects = numObjects; | |||
| 1255 | } | |||
| 1256 | ||||
| 1257 | ExprWithCleanups *ExprWithCleanups::Create(const ASTContext &C, | |||
| 1258 | EmptyShell empty, | |||
| 1259 | unsigned numObjects) { | |||
| 1260 | void *buffer = C.Allocate(totalSizeToAlloc<CleanupObject>(numObjects), | |||
| 1261 | alignof(ExprWithCleanups)); | |||
| 1262 | return new (buffer) ExprWithCleanups(empty, numObjects); | |||
| 1263 | } | |||
| 1264 | ||||
| 1265 | CXXUnresolvedConstructExpr::CXXUnresolvedConstructExpr(TypeSourceInfo *TSI, | |||
| 1266 | SourceLocation LParenLoc, | |||
| 1267 | ArrayRef<Expr *> Args, | |||
| 1268 | SourceLocation RParenLoc) | |||
| 1269 | : Expr(CXXUnresolvedConstructExprClass, | |||
| 1270 | TSI->getType().getNonReferenceType(), | |||
| 1271 | (TSI->getType()->isLValueReferenceType() | |||
| 1272 | ? VK_LValue | |||
| 1273 | : TSI->getType()->isRValueReferenceType() ? VK_XValue | |||
| 1274 | : VK_RValue), | |||
| 1275 | OK_Ordinary, | |||
| 1276 | TSI->getType()->isDependentType() || | |||
| 1277 | TSI->getType()->getContainedDeducedType(), | |||
| 1278 | true, true, TSI->getType()->containsUnexpandedParameterPack()), | |||
| 1279 | TSI(TSI), LParenLoc(LParenLoc), RParenLoc(RParenLoc) { | |||
| 1280 | CXXUnresolvedConstructExprBits.NumArgs = Args.size(); | |||
| 1281 | auto **StoredArgs = getTrailingObjects<Expr *>(); | |||
| 1282 | for (unsigned I = 0; I != Args.size(); ++I) { | |||
| 1283 | if (Args[I]->containsUnexpandedParameterPack()) | |||
| 1284 | ExprBits.ContainsUnexpandedParameterPack = true; | |||
| 1285 | ||||
| 1286 | StoredArgs[I] = Args[I]; | |||
| 1287 | } | |||
| 1288 | } | |||
| 1289 | ||||
| 1290 | CXXUnresolvedConstructExpr *CXXUnresolvedConstructExpr::Create( | |||
| 1291 | const ASTContext &Context, TypeSourceInfo *TSI, SourceLocation LParenLoc, | |||
| 1292 | ArrayRef<Expr *> Args, SourceLocation RParenLoc) { | |||
| 1293 | void *Mem = Context.Allocate(totalSizeToAlloc<Expr *>(Args.size())); | |||
| 1294 | return new (Mem) CXXUnresolvedConstructExpr(TSI, LParenLoc, Args, RParenLoc); | |||
| 1295 | } | |||
| 1296 | ||||
| 1297 | CXXUnresolvedConstructExpr * | |||
| 1298 | CXXUnresolvedConstructExpr::CreateEmpty(const ASTContext &Context, | |||
| 1299 | unsigned NumArgs) { | |||
| 1300 | void *Mem = Context.Allocate(totalSizeToAlloc<Expr *>(NumArgs)); | |||
| 1301 | return new (Mem) CXXUnresolvedConstructExpr(EmptyShell(), NumArgs); | |||
| 1302 | } | |||
| 1303 | ||||
| 1304 | SourceLocation CXXUnresolvedConstructExpr::getBeginLoc() const { | |||
| 1305 | return TSI->getTypeLoc().getBeginLoc(); | |||
| 1306 | } | |||
| 1307 | ||||
| 1308 | CXXDependentScopeMemberExpr::CXXDependentScopeMemberExpr( | |||
| 1309 | const ASTContext &Ctx, Expr *Base, QualType BaseType, bool IsArrow, | |||
| 1310 | SourceLocation OperatorLoc, NestedNameSpecifierLoc QualifierLoc, | |||
| 1311 | SourceLocation TemplateKWLoc, NamedDecl *FirstQualifierFoundInScope, | |||
| 1312 | DeclarationNameInfo MemberNameInfo, | |||
| 1313 | const TemplateArgumentListInfo *TemplateArgs) | |||
| 1314 | : Expr(CXXDependentScopeMemberExprClass, Ctx.DependentTy, VK_LValue, | |||
| 1315 | OK_Ordinary, true, true, true, | |||
| 1316 | ((Base && Base->containsUnexpandedParameterPack()) || | |||
| 1317 | (QualifierLoc && QualifierLoc.getNestedNameSpecifier() | |||
| 1318 | ->containsUnexpandedParameterPack()) || | |||
| 1319 | MemberNameInfo.containsUnexpandedParameterPack())), | |||
| 1320 | Base(Base), BaseType(BaseType), QualifierLoc(QualifierLoc), | |||
| 1321 | MemberNameInfo(MemberNameInfo) { | |||
| 1322 | CXXDependentScopeMemberExprBits.IsArrow = IsArrow; | |||
| 1323 | CXXDependentScopeMemberExprBits.HasTemplateKWAndArgsInfo = | |||
| 1324 | (TemplateArgs != nullptr) || TemplateKWLoc.isValid(); | |||
| 1325 | CXXDependentScopeMemberExprBits.HasFirstQualifierFoundInScope = | |||
| 1326 | FirstQualifierFoundInScope != nullptr; | |||
| 1327 | CXXDependentScopeMemberExprBits.OperatorLoc = OperatorLoc; | |||
| 1328 | ||||
| 1329 | if (TemplateArgs) { | |||
| 1330 | bool Dependent = true; | |||
| 1331 | bool InstantiationDependent = true; | |||
| 1332 | bool ContainsUnexpandedParameterPack = false; | |||
| 1333 | getTrailingObjects<ASTTemplateKWAndArgsInfo>()->initializeFrom( | |||
| 1334 | TemplateKWLoc, *TemplateArgs, getTrailingObjects<TemplateArgumentLoc>(), | |||
| 1335 | Dependent, InstantiationDependent, ContainsUnexpandedParameterPack); | |||
| 1336 | if (ContainsUnexpandedParameterPack) | |||
| 1337 | ExprBits.ContainsUnexpandedParameterPack = true; | |||
| 1338 | } else if (TemplateKWLoc.isValid()) { | |||
| 1339 | getTrailingObjects<ASTTemplateKWAndArgsInfo>()->initializeFrom( | |||
| 1340 | TemplateKWLoc); | |||
| 1341 | } | |||
| 1342 | ||||
| 1343 | if (hasFirstQualifierFoundInScope()) | |||
| 1344 | *getTrailingObjects<NamedDecl *>() = FirstQualifierFoundInScope; | |||
| 1345 | } | |||
| 1346 | ||||
| 1347 | CXXDependentScopeMemberExpr::CXXDependentScopeMemberExpr( | |||
| 1348 | EmptyShell Empty, bool HasTemplateKWAndArgsInfo, | |||
| 1349 | bool HasFirstQualifierFoundInScope) | |||
| 1350 | : Expr(CXXDependentScopeMemberExprClass, Empty) { | |||
| 1351 | CXXDependentScopeMemberExprBits.HasTemplateKWAndArgsInfo = | |||
| 1352 | HasTemplateKWAndArgsInfo; | |||
| 1353 | CXXDependentScopeMemberExprBits.HasFirstQualifierFoundInScope = | |||
| 1354 | HasFirstQualifierFoundInScope; | |||
| 1355 | } | |||
| 1356 | ||||
| 1357 | CXXDependentScopeMemberExpr *CXXDependentScopeMemberExpr::Create( | |||
| 1358 | const ASTContext &Ctx, Expr *Base, QualType BaseType, bool IsArrow, | |||
| 1359 | SourceLocation OperatorLoc, NestedNameSpecifierLoc QualifierLoc, | |||
| 1360 | SourceLocation TemplateKWLoc, NamedDecl *FirstQualifierFoundInScope, | |||
| 1361 | DeclarationNameInfo MemberNameInfo, | |||
| 1362 | const TemplateArgumentListInfo *TemplateArgs) { | |||
| 1363 | bool HasTemplateKWAndArgsInfo = | |||
| 1364 | (TemplateArgs != nullptr) || TemplateKWLoc.isValid(); | |||
| 1365 | unsigned NumTemplateArgs = TemplateArgs ? TemplateArgs->size() : 0; | |||
| 1366 | bool HasFirstQualifierFoundInScope = FirstQualifierFoundInScope != nullptr; | |||
| 1367 | ||||
| 1368 | unsigned Size = totalSizeToAlloc<ASTTemplateKWAndArgsInfo, | |||
| 1369 | TemplateArgumentLoc, NamedDecl *>( | |||
| 1370 | HasTemplateKWAndArgsInfo, NumTemplateArgs, HasFirstQualifierFoundInScope); | |||
| 1371 | ||||
| 1372 | void *Mem = Ctx.Allocate(Size, alignof(CXXDependentScopeMemberExpr)); | |||
| 1373 | return new (Mem) CXXDependentScopeMemberExpr( | |||
| 1374 | Ctx, Base, BaseType, IsArrow, OperatorLoc, QualifierLoc, TemplateKWLoc, | |||
| 1375 | FirstQualifierFoundInScope, MemberNameInfo, TemplateArgs); | |||
| 1376 | } | |||
| 1377 | ||||
| 1378 | CXXDependentScopeMemberExpr *CXXDependentScopeMemberExpr::CreateEmpty( | |||
| 1379 | const ASTContext &Ctx, bool HasTemplateKWAndArgsInfo, | |||
| 1380 | unsigned NumTemplateArgs, bool HasFirstQualifierFoundInScope) { | |||
| 1381 | assert(NumTemplateArgs == 0 || HasTemplateKWAndArgsInfo)((NumTemplateArgs == 0 || HasTemplateKWAndArgsInfo) ? static_cast <void> (0) : __assert_fail ("NumTemplateArgs == 0 || HasTemplateKWAndArgsInfo" , "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/AST/ExprCXX.cpp" , 1381, __PRETTY_FUNCTION__)); | |||
| 1382 | ||||
| 1383 | unsigned Size = totalSizeToAlloc<ASTTemplateKWAndArgsInfo, | |||
| 1384 | TemplateArgumentLoc, NamedDecl *>( | |||
| 1385 | HasTemplateKWAndArgsInfo, NumTemplateArgs, HasFirstQualifierFoundInScope); | |||
| 1386 | ||||
| 1387 | void *Mem = Ctx.Allocate(Size, alignof(CXXDependentScopeMemberExpr)); | |||
| 1388 | return new (Mem) CXXDependentScopeMemberExpr( | |||
| 1389 | EmptyShell(), HasTemplateKWAndArgsInfo, HasFirstQualifierFoundInScope); | |||
| 1390 | } | |||
| 1391 | ||||
| 1392 | static bool hasOnlyNonStaticMemberFunctions(UnresolvedSetIterator begin, | |||
| 1393 | UnresolvedSetIterator end) { | |||
| 1394 | do { | |||
| 1395 | NamedDecl *decl = *begin; | |||
| 1396 | if (isa<UnresolvedUsingValueDecl>(decl)) | |||
| 1397 | return false; | |||
| 1398 | ||||
| 1399 | // Unresolved member expressions should only contain methods and | |||
| 1400 | // method templates. | |||
| 1401 | if (cast<CXXMethodDecl>(decl->getUnderlyingDecl()->getAsFunction()) | |||
| 1402 | ->isStatic()) | |||
| 1403 | return false; | |||
| 1404 | } while (++begin != end); | |||
| 1405 | ||||
| 1406 | return true; | |||
| 1407 | } | |||
| 1408 | ||||
| 1409 | UnresolvedMemberExpr::UnresolvedMemberExpr( | |||
| 1410 | const ASTContext &Context, bool HasUnresolvedUsing, Expr *Base, | |||
| 1411 | QualType BaseType, bool IsArrow, SourceLocation OperatorLoc, | |||
| 1412 | NestedNameSpecifierLoc QualifierLoc, SourceLocation TemplateKWLoc, | |||
| 1413 | const DeclarationNameInfo &MemberNameInfo, | |||
| 1414 | const TemplateArgumentListInfo *TemplateArgs, UnresolvedSetIterator Begin, | |||
| 1415 | UnresolvedSetIterator End) | |||
| 1416 | : OverloadExpr( | |||
| 1417 | UnresolvedMemberExprClass, Context, QualifierLoc, TemplateKWLoc, | |||
| 1418 | MemberNameInfo, TemplateArgs, Begin, End, | |||
| 1419 | // Dependent | |||
| 1420 | ((Base && Base->isTypeDependent()) || BaseType->isDependentType()), | |||
| 1421 | ((Base && Base->isInstantiationDependent()) || | |||
| 1422 | BaseType->isInstantiationDependentType()), | |||
| 1423 | // Contains unexpanded parameter pack | |||
| 1424 | ((Base && Base->containsUnexpandedParameterPack()) || | |||
| 1425 | BaseType->containsUnexpandedParameterPack())), | |||
| 1426 | Base(Base), BaseType(BaseType), OperatorLoc(OperatorLoc) { | |||
| 1427 | UnresolvedMemberExprBits.IsArrow = IsArrow; | |||
| 1428 | UnresolvedMemberExprBits.HasUnresolvedUsing = HasUnresolvedUsing; | |||
| 1429 | ||||
| 1430 | // Check whether all of the members are non-static member functions, | |||
| 1431 | // and if so, mark give this bound-member type instead of overload type. | |||
| 1432 | if (hasOnlyNonStaticMemberFunctions(Begin, End)) | |||
| 1433 | setType(Context.BoundMemberTy); | |||
| 1434 | } | |||
| 1435 | ||||
| 1436 | UnresolvedMemberExpr::UnresolvedMemberExpr(EmptyShell Empty, | |||
| 1437 | unsigned NumResults, | |||
| 1438 | bool HasTemplateKWAndArgsInfo) | |||
| 1439 | : OverloadExpr(UnresolvedMemberExprClass, Empty, NumResults, | |||
| 1440 | HasTemplateKWAndArgsInfo) {} | |||
| 1441 | ||||
| 1442 | bool UnresolvedMemberExpr::isImplicitAccess() const { | |||
| 1443 | if (!Base) | |||
| 1444 | return true; | |||
| 1445 | ||||
| 1446 | return cast<Expr>(Base)->isImplicitCXXThis(); | |||
| 1447 | } | |||
| 1448 | ||||
| 1449 | UnresolvedMemberExpr *UnresolvedMemberExpr::Create( | |||
| 1450 | const ASTContext &Context, bool HasUnresolvedUsing, Expr *Base, | |||
| 1451 | QualType BaseType, bool IsArrow, SourceLocation OperatorLoc, | |||
| 1452 | NestedNameSpecifierLoc QualifierLoc, SourceLocation TemplateKWLoc, | |||
| 1453 | const DeclarationNameInfo &MemberNameInfo, | |||
| 1454 | const TemplateArgumentListInfo *TemplateArgs, UnresolvedSetIterator Begin, | |||
| 1455 | UnresolvedSetIterator End) { | |||
| 1456 | unsigned NumResults = End - Begin; | |||
| 1457 | bool HasTemplateKWAndArgsInfo = TemplateArgs || TemplateKWLoc.isValid(); | |||
| 1458 | unsigned NumTemplateArgs = TemplateArgs ? TemplateArgs->size() : 0; | |||
| 1459 | unsigned Size = totalSizeToAlloc<DeclAccessPair, ASTTemplateKWAndArgsInfo, | |||
| 1460 | TemplateArgumentLoc>( | |||
| 1461 | NumResults, HasTemplateKWAndArgsInfo, NumTemplateArgs); | |||
| 1462 | void *Mem = Context.Allocate(Size, alignof(UnresolvedMemberExpr)); | |||
| 1463 | return new (Mem) UnresolvedMemberExpr( | |||
| 1464 | Context, HasUnresolvedUsing, Base, BaseType, IsArrow, OperatorLoc, | |||
| 1465 | QualifierLoc, TemplateKWLoc, MemberNameInfo, TemplateArgs, Begin, End); | |||
| 1466 | } | |||
| 1467 | ||||
| 1468 | UnresolvedMemberExpr *UnresolvedMemberExpr::CreateEmpty( | |||
| 1469 | const ASTContext &Context, unsigned NumResults, | |||
| 1470 | bool HasTemplateKWAndArgsInfo, unsigned NumTemplateArgs) { | |||
| 1471 | assert(NumTemplateArgs == 0 || HasTemplateKWAndArgsInfo)((NumTemplateArgs == 0 || HasTemplateKWAndArgsInfo) ? static_cast <void> (0) : __assert_fail ("NumTemplateArgs == 0 || HasTemplateKWAndArgsInfo" , "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/AST/ExprCXX.cpp" , 1471, __PRETTY_FUNCTION__)); | |||
| 1472 | unsigned Size = totalSizeToAlloc<DeclAccessPair, ASTTemplateKWAndArgsInfo, | |||
| 1473 | TemplateArgumentLoc>( | |||
| 1474 | NumResults, HasTemplateKWAndArgsInfo, NumTemplateArgs); | |||
| 1475 | void *Mem = Context.Allocate(Size, alignof(UnresolvedMemberExpr)); | |||
| 1476 | return new (Mem) | |||
| 1477 | UnresolvedMemberExpr(EmptyShell(), NumResults, HasTemplateKWAndArgsInfo); | |||
| 1478 | } | |||
| 1479 | ||||
| 1480 | CXXRecordDecl *UnresolvedMemberExpr::getNamingClass() { | |||
| 1481 | // Unlike for UnresolvedLookupExpr, it is very easy to re-derive this. | |||
| 1482 | ||||
| 1483 | // If there was a nested name specifier, it names the naming class. | |||
| 1484 | // It can't be dependent: after all, we were actually able to do the | |||
| 1485 | // lookup. | |||
| 1486 | CXXRecordDecl *Record = nullptr; | |||
| 1487 | auto *NNS = getQualifier(); | |||
| 1488 | if (NNS && NNS->getKind() != NestedNameSpecifier::Super) { | |||
| 1489 | const Type *T = getQualifier()->getAsType(); | |||
| 1490 | assert(T && "qualifier in member expression does not name type")((T && "qualifier in member expression does not name type" ) ? static_cast<void> (0) : __assert_fail ("T && \"qualifier in member expression does not name type\"" , "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/AST/ExprCXX.cpp" , 1490, __PRETTY_FUNCTION__)); | |||
| 1491 | Record = T->getAsCXXRecordDecl(); | |||
| 1492 | assert(Record && "qualifier in member expression does not name record")((Record && "qualifier in member expression does not name record" ) ? static_cast<void> (0) : __assert_fail ("Record && \"qualifier in member expression does not name record\"" , "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/AST/ExprCXX.cpp" , 1492, __PRETTY_FUNCTION__)); | |||
| 1493 | } | |||
| 1494 | // Otherwise the naming class must have been the base class. | |||
| 1495 | else { | |||
| 1496 | QualType BaseType = getBaseType().getNonReferenceType(); | |||
| 1497 | if (isArrow()) { | |||
| 1498 | const auto *PT = BaseType->getAs<PointerType>(); | |||
| 1499 | assert(PT && "base of arrow member access is not pointer")((PT && "base of arrow member access is not pointer") ? static_cast<void> (0) : __assert_fail ("PT && \"base of arrow member access is not pointer\"" , "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/AST/ExprCXX.cpp" , 1499, __PRETTY_FUNCTION__)); | |||
| 1500 | BaseType = PT->getPointeeType(); | |||
| 1501 | } | |||
| 1502 | ||||
| 1503 | Record = BaseType->getAsCXXRecordDecl(); | |||
| 1504 | assert(Record && "base of member expression does not name record")((Record && "base of member expression does not name record" ) ? static_cast<void> (0) : __assert_fail ("Record && \"base of member expression does not name record\"" , "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/AST/ExprCXX.cpp" , 1504, __PRETTY_FUNCTION__)); | |||
| 1505 | } | |||
| 1506 | ||||
| 1507 | return Record; | |||
| 1508 | } | |||
| 1509 | ||||
| 1510 | SizeOfPackExpr * | |||
| 1511 | SizeOfPackExpr::Create(ASTContext &Context, SourceLocation OperatorLoc, | |||
| 1512 | NamedDecl *Pack, SourceLocation PackLoc, | |||
| 1513 | SourceLocation RParenLoc, | |||
| 1514 | Optional<unsigned> Length, | |||
| 1515 | ArrayRef<TemplateArgument> PartialArgs) { | |||
| 1516 | void *Storage = | |||
| 1517 | Context.Allocate(totalSizeToAlloc<TemplateArgument>(PartialArgs.size())); | |||
| 1518 | return new (Storage) SizeOfPackExpr(Context.getSizeType(), OperatorLoc, Pack, | |||
| 1519 | PackLoc, RParenLoc, Length, PartialArgs); | |||
| 1520 | } | |||
| 1521 | ||||
| 1522 | SizeOfPackExpr *SizeOfPackExpr::CreateDeserialized(ASTContext &Context, | |||
| 1523 | unsigned NumPartialArgs) { | |||
| 1524 | void *Storage = | |||
| 1525 | Context.Allocate(totalSizeToAlloc<TemplateArgument>(NumPartialArgs)); | |||
| 1526 | return new (Storage) SizeOfPackExpr(EmptyShell(), NumPartialArgs); | |||
| 1527 | } | |||
| 1528 | ||||
| 1529 | SubstNonTypeTemplateParmPackExpr:: | |||
| 1530 | SubstNonTypeTemplateParmPackExpr(QualType T, | |||
| 1531 | ExprValueKind ValueKind, | |||
| 1532 | NonTypeTemplateParmDecl *Param, | |||
| 1533 | SourceLocation NameLoc, | |||
| 1534 | const TemplateArgument &ArgPack) | |||
| 1535 | : Expr(SubstNonTypeTemplateParmPackExprClass, T, ValueKind, OK_Ordinary, | |||
| 1536 | true, true, true, true), | |||
| 1537 | Param(Param), Arguments(ArgPack.pack_begin()), | |||
| 1538 | NumArguments(ArgPack.pack_size()), NameLoc(NameLoc) {} | |||
| 1539 | ||||
| 1540 | TemplateArgument SubstNonTypeTemplateParmPackExpr::getArgumentPack() const { | |||
| 1541 | return TemplateArgument(llvm::makeArrayRef(Arguments, NumArguments)); | |||
| 1542 | } | |||
| 1543 | ||||
| 1544 | FunctionParmPackExpr::FunctionParmPackExpr(QualType T, VarDecl *ParamPack, | |||
| 1545 | SourceLocation NameLoc, | |||
| 1546 | unsigned NumParams, | |||
| 1547 | VarDecl *const *Params) | |||
| 1548 | : Expr(FunctionParmPackExprClass, T, VK_LValue, OK_Ordinary, true, true, | |||
| 1549 | true, true), | |||
| 1550 | ParamPack(ParamPack), NameLoc(NameLoc), NumParameters(NumParams) { | |||
| 1551 | if (Params) | |||
| 1552 | std::uninitialized_copy(Params, Params + NumParams, | |||
| 1553 | getTrailingObjects<VarDecl *>()); | |||
| 1554 | } | |||
| 1555 | ||||
| 1556 | FunctionParmPackExpr * | |||
| 1557 | FunctionParmPackExpr::Create(const ASTContext &Context, QualType T, | |||
| 1558 | VarDecl *ParamPack, SourceLocation NameLoc, | |||
| 1559 | ArrayRef<VarDecl *> Params) { | |||
| 1560 | return new (Context.Allocate(totalSizeToAlloc<VarDecl *>(Params.size()))) | |||
| 1561 | FunctionParmPackExpr(T, ParamPack, NameLoc, Params.size(), Params.data()); | |||
| 1562 | } | |||
| 1563 | ||||
| 1564 | FunctionParmPackExpr * | |||
| 1565 | FunctionParmPackExpr::CreateEmpty(const ASTContext &Context, | |||
| 1566 | unsigned NumParams) { | |||
| 1567 | return new (Context.Allocate(totalSizeToAlloc<VarDecl *>(NumParams))) | |||
| 1568 | FunctionParmPackExpr(QualType(), nullptr, SourceLocation(), 0, nullptr); | |||
| 1569 | } | |||
| 1570 | ||||
| 1571 | void MaterializeTemporaryExpr::setExtendingDecl(const ValueDecl *ExtendedBy, | |||
| 1572 | unsigned ManglingNumber) { | |||
| 1573 | // We only need extra state if we have to remember more than just the Stmt. | |||
| 1574 | if (!ExtendedBy) | |||
| ||||
| 1575 | return; | |||
| 1576 | ||||
| 1577 | // We may need to allocate extra storage for the mangling number and the | |||
| 1578 | // extended-by ValueDecl. | |||
| 1579 | if (!State.is<ExtraState *>()) { | |||
| 1580 | auto *ES = new (ExtendedBy->getASTContext()) ExtraState; | |||
| 1581 | ES->Temporary = State.get<Stmt *>(); | |||
| ||||
| 1582 | State = ES; | |||
| 1583 | } | |||
| 1584 | ||||
| 1585 | auto ES = State.get<ExtraState *>(); | |||
| 1586 | ES->ExtendingDecl = ExtendedBy; | |||
| 1587 | ES->ManglingNumber = ManglingNumber; | |||
| 1588 | } | |||
| 1589 | ||||
| 1590 | TypeTraitExpr::TypeTraitExpr(QualType T, SourceLocation Loc, TypeTrait Kind, | |||
| 1591 | ArrayRef<TypeSourceInfo *> Args, | |||
| 1592 | SourceLocation RParenLoc, | |||
| 1593 | bool Value) | |||
| 1594 | : Expr(TypeTraitExprClass, T, VK_RValue, OK_Ordinary, | |||
| 1595 | /*TypeDependent=*/false, | |||
| 1596 | /*ValueDependent=*/false, | |||
| 1597 | /*InstantiationDependent=*/false, | |||
| 1598 | /*ContainsUnexpandedParameterPack=*/false), | |||
| 1599 | Loc(Loc), RParenLoc(RParenLoc) { | |||
| 1600 | TypeTraitExprBits.Kind = Kind; | |||
| 1601 | TypeTraitExprBits.Value = Value; | |||
| 1602 | TypeTraitExprBits.NumArgs = Args.size(); | |||
| 1603 | ||||
| 1604 | auto **ToArgs = getTrailingObjects<TypeSourceInfo *>(); | |||
| 1605 | ||||
| 1606 | for (unsigned I = 0, N = Args.size(); I != N; ++I) { | |||
| 1607 | if (Args[I]->getType()->isDependentType()) | |||
| 1608 | setValueDependent(true); | |||
| 1609 | if (Args[I]->getType()->isInstantiationDependentType()) | |||
| 1610 | setInstantiationDependent(true); | |||
| 1611 | if (Args[I]->getType()->containsUnexpandedParameterPack()) | |||
| 1612 | setContainsUnexpandedParameterPack(true); | |||
| 1613 | ||||
| 1614 | ToArgs[I] = Args[I]; | |||
| 1615 | } | |||
| 1616 | } | |||
| 1617 | ||||
| 1618 | TypeTraitExpr *TypeTraitExpr::Create(const ASTContext &C, QualType T, | |||
| 1619 | SourceLocation Loc, | |||
| 1620 | TypeTrait Kind, | |||
| 1621 | ArrayRef<TypeSourceInfo *> Args, | |||
| 1622 | SourceLocation RParenLoc, | |||
| 1623 | bool Value) { | |||
| 1624 | void *Mem = C.Allocate(totalSizeToAlloc<TypeSourceInfo *>(Args.size())); | |||
| 1625 | return new (Mem) TypeTraitExpr(T, Loc, Kind, Args, RParenLoc, Value); | |||
| 1626 | } | |||
| 1627 | ||||
| 1628 | TypeTraitExpr *TypeTraitExpr::CreateDeserialized(const ASTContext &C, | |||
| 1629 | unsigned NumArgs) { | |||
| 1630 | void *Mem = C.Allocate(totalSizeToAlloc<TypeSourceInfo *>(NumArgs)); | |||
| 1631 | return new (Mem) TypeTraitExpr(EmptyShell()); | |||
| 1632 | } | |||
| 1633 | ||||
| 1634 | CUDAKernelCallExpr::CUDAKernelCallExpr(Expr *Fn, CallExpr *Config, | |||
| 1635 | ArrayRef<Expr *> Args, QualType Ty, | |||
| 1636 | ExprValueKind VK, SourceLocation RP, | |||
| 1637 | unsigned MinNumArgs) | |||
| 1638 | : CallExpr(CUDAKernelCallExprClass, Fn, /*PreArgs=*/Config, Args, Ty, VK, | |||
| 1639 | RP, MinNumArgs, NotADL) {} | |||
| 1640 | ||||
| 1641 | CUDAKernelCallExpr::CUDAKernelCallExpr(unsigned NumArgs, EmptyShell Empty) | |||
| 1642 | : CallExpr(CUDAKernelCallExprClass, /*NumPreArgs=*/END_PREARG, NumArgs, | |||
| 1643 | Empty) {} | |||
| 1644 | ||||
| 1645 | CUDAKernelCallExpr * | |||
| 1646 | CUDAKernelCallExpr::Create(const ASTContext &Ctx, Expr *Fn, CallExpr *Config, | |||
| 1647 | ArrayRef<Expr *> Args, QualType Ty, ExprValueKind VK, | |||
| 1648 | SourceLocation RP, unsigned MinNumArgs) { | |||
| 1649 | // Allocate storage for the trailing objects of CallExpr. | |||
| 1650 | unsigned NumArgs = std::max<unsigned>(Args.size(), MinNumArgs); | |||
| 1651 | unsigned SizeOfTrailingObjects = | |||
| 1652 | CallExpr::sizeOfTrailingObjects(/*NumPreArgs=*/END_PREARG, NumArgs); | |||
| 1653 | void *Mem = Ctx.Allocate(sizeof(CUDAKernelCallExpr) + SizeOfTrailingObjects, | |||
| 1654 | alignof(CUDAKernelCallExpr)); | |||
| 1655 | return new (Mem) CUDAKernelCallExpr(Fn, Config, Args, Ty, VK, RP, MinNumArgs); | |||
| 1656 | } | |||
| 1657 | ||||
| 1658 | CUDAKernelCallExpr *CUDAKernelCallExpr::CreateEmpty(const ASTContext &Ctx, | |||
| 1659 | unsigned NumArgs, | |||
| 1660 | EmptyShell Empty) { | |||
| 1661 | // Allocate storage for the trailing objects of CallExpr. | |||
| 1662 | unsigned SizeOfTrailingObjects = | |||
| 1663 | CallExpr::sizeOfTrailingObjects(/*NumPreArgs=*/END_PREARG, NumArgs); | |||
| 1664 | void *Mem = Ctx.Allocate(sizeof(CUDAKernelCallExpr) + SizeOfTrailingObjects, | |||
| 1665 | alignof(CUDAKernelCallExpr)); | |||
| 1666 | return new (Mem) CUDAKernelCallExpr(NumArgs, Empty); | |||
| 1667 | } |