diff options
Diffstat (limited to 'lib/AST/Expr.cpp')
| -rw-r--r-- | lib/AST/Expr.cpp | 660 |
1 files changed, 162 insertions, 498 deletions
diff --git a/lib/AST/Expr.cpp b/lib/AST/Expr.cpp index 2e066b2c42c6b..bdd7a45f08505 100644 --- a/lib/AST/Expr.cpp +++ b/lib/AST/Expr.cpp @@ -331,7 +331,8 @@ DeclRefExpr::DeclRefExpr(const ASTContext &Ctx, D(D), Loc(NameInfo.getLoc()), DNLoc(NameInfo.getInfo()) { DeclRefExprBits.HasQualifier = QualifierLoc ? 1 : 0; if (QualifierLoc) { - getInternalQualifierLoc() = QualifierLoc; + new (getTrailingObjects<NestedNameSpecifierLoc>()) + NestedNameSpecifierLoc(QualifierLoc); auto *NNS = QualifierLoc.getNestedNameSpecifier(); if (NNS->isInstantiationDependent()) ExprBits.InstantiationDependent = true; @@ -340,7 +341,7 @@ DeclRefExpr::DeclRefExpr(const ASTContext &Ctx, } DeclRefExprBits.HasFoundDecl = FoundD ? 1 : 0; if (FoundD) - getInternalFoundDecl() = FoundD; + *getTrailingObjects<NamedDecl *>() = FoundD; DeclRefExprBits.HasTemplateKWAndArgsInfo = (TemplateArgs || TemplateKWLoc.isValid()) ? 1 : 0; DeclRefExprBits.RefersToEnclosingVariableOrCapture = @@ -349,15 +350,15 @@ DeclRefExpr::DeclRefExpr(const ASTContext &Ctx, bool Dependent = false; bool InstantiationDependent = false; bool ContainsUnexpandedParameterPack = false; - getTemplateKWAndArgsInfo()->initializeFrom(TemplateKWLoc, *TemplateArgs, - Dependent, - InstantiationDependent, - ContainsUnexpandedParameterPack); + getTrailingObjects<ASTTemplateKWAndArgsInfo>()->initializeFrom( + TemplateKWLoc, *TemplateArgs, getTrailingObjects<TemplateArgumentLoc>(), + Dependent, InstantiationDependent, ContainsUnexpandedParameterPack); assert(!Dependent && "built a DeclRefExpr with dependent template args"); ExprBits.InstantiationDependent |= InstantiationDependent; ExprBits.ContainsUnexpandedParameterPack |= ContainsUnexpandedParameterPack; } else if (TemplateKWLoc.isValid()) { - getTemplateKWAndArgsInfo()->initializeFrom(TemplateKWLoc); + getTrailingObjects<ASTTemplateKWAndArgsInfo>()->initializeFrom( + TemplateKWLoc); } DeclRefExprBits.HadMultipleCandidates = 0; @@ -394,15 +395,13 @@ DeclRefExpr *DeclRefExpr::Create(const ASTContext &Context, if (D == FoundD) FoundD = nullptr; - std::size_t Size = sizeof(DeclRefExpr); - if (QualifierLoc) - Size += sizeof(NestedNameSpecifierLoc); - if (FoundD) - Size += sizeof(NamedDecl *); - if (TemplateArgs) - Size += ASTTemplateKWAndArgsInfo::sizeFor(TemplateArgs->size()); - else if (TemplateKWLoc.isValid()) - Size += ASTTemplateKWAndArgsInfo::sizeFor(0); + bool HasTemplateKWAndArgsInfo = TemplateArgs || TemplateKWLoc.isValid(); + std::size_t Size = + totalSizeToAlloc<NestedNameSpecifierLoc, NamedDecl *, + ASTTemplateKWAndArgsInfo, TemplateArgumentLoc>( + QualifierLoc ? 1 : 0, FoundD ? 1 : 0, + HasTemplateKWAndArgsInfo ? 1 : 0, + TemplateArgs ? TemplateArgs->size() : 0); void *Mem = Context.Allocate(Size, llvm::alignOf<DeclRefExpr>()); return new (Mem) DeclRefExpr(Context, QualifierLoc, TemplateKWLoc, D, @@ -415,14 +414,12 @@ DeclRefExpr *DeclRefExpr::CreateEmpty(const ASTContext &Context, bool HasFoundDecl, bool HasTemplateKWAndArgsInfo, unsigned NumTemplateArgs) { - std::size_t Size = sizeof(DeclRefExpr); - if (HasQualifier) - Size += sizeof(NestedNameSpecifierLoc); - if (HasFoundDecl) - Size += sizeof(NamedDecl *); - if (HasTemplateKWAndArgsInfo) - Size += ASTTemplateKWAndArgsInfo::sizeFor(NumTemplateArgs); - + assert(NumTemplateArgs == 0 || HasTemplateKWAndArgsInfo); + std::size_t Size = + totalSizeToAlloc<NestedNameSpecifierLoc, NamedDecl *, + ASTTemplateKWAndArgsInfo, TemplateArgumentLoc>( + HasQualifier ? 1 : 0, HasFoundDecl ? 1 : 0, HasTemplateKWAndArgsInfo, + NumTemplateArgs); void *Mem = Context.Allocate(Size, llvm::alignOf<DeclRefExpr>()); return new (Mem) DeclRefExpr(EmptyShell()); } @@ -490,7 +487,6 @@ std::string PredefinedExpr::ComputeName(IdentType IT, const Decl *CurrentDecl) { else MC->mangleName(ND, Out); - Out.flush(); if (!Buffer.empty() && Buffer.front() == '\01') return Buffer.substr(1); return Buffer.str(); @@ -652,7 +648,6 @@ std::string PredefinedExpr::ComputeName(IdentType IT, const Decl *CurrentDecl) { Out << Proto; - Out.flush(); return Name.str().str(); } if (const CapturedDecl *CD = dyn_cast<CapturedDecl>(CurrentDecl)) { @@ -684,7 +679,6 @@ std::string PredefinedExpr::ComputeName(IdentType IT, const Decl *CurrentDecl) { MD->getSelector().print(Out); Out << ']'; - Out.flush(); return Name.str().str(); } if (isa<TranslationUnitDecl>(CurrentDecl) && IT == PrettyFunction) { @@ -1002,15 +996,33 @@ void StringLiteral::setString(const ASTContext &C, StringRef Str, /// can have escape sequences in them in addition to the usual trigraph and /// escaped newline business. This routine handles this complexity. /// -SourceLocation StringLiteral:: -getLocationOfByte(unsigned ByteNo, const SourceManager &SM, - const LangOptions &Features, const TargetInfo &Target) const { +/// The *StartToken sets the first token to be searched in this function and +/// the *StartTokenByteOffset is the byte offset of the first token. Before +/// returning, it updates the *StartToken to the TokNo of the token being found +/// and sets *StartTokenByteOffset to the byte offset of the token in the +/// string. +/// Using these two parameters can reduce the time complexity from O(n^2) to +/// O(n) if one wants to get the location of byte for all the tokens in a +/// string. +/// +SourceLocation +StringLiteral::getLocationOfByte(unsigned ByteNo, const SourceManager &SM, + const LangOptions &Features, + const TargetInfo &Target, unsigned *StartToken, + unsigned *StartTokenByteOffset) const { assert((Kind == StringLiteral::Ascii || Kind == StringLiteral::UTF8) && "Only narrow string literals are currently supported"); // Loop over all of the tokens in this string until we find the one that // contains the byte we're looking for. unsigned TokNo = 0; + unsigned StringOffset = 0; + if (StartToken) + TokNo = *StartToken; + if (StartTokenByteOffset) { + StringOffset = *StartTokenByteOffset; + ByteNo -= StringOffset; + } while (1) { assert(TokNo < getNumConcatenated() && "Invalid byte number!"); SourceLocation StrTokLoc = getStrTokenLoc(TokNo); @@ -1019,14 +1031,20 @@ getLocationOfByte(unsigned ByteNo, const SourceManager &SM, // the string literal, not the identifier for the macro it is potentially // expanded through. SourceLocation StrTokSpellingLoc = SM.getSpellingLoc(StrTokLoc); - + // Re-lex the token to get its length and original spelling. - std::pair<FileID, unsigned> LocInfo =SM.getDecomposedLoc(StrTokSpellingLoc); + std::pair<FileID, unsigned> LocInfo = + SM.getDecomposedLoc(StrTokSpellingLoc); bool Invalid = false; StringRef Buffer = SM.getBufferData(LocInfo.first, &Invalid); - if (Invalid) + if (Invalid) { + if (StartTokenByteOffset != nullptr) + *StartTokenByteOffset = StringOffset; + if (StartToken != nullptr) + *StartToken = TokNo; return StrTokSpellingLoc; - + } + const char *StrData = Buffer.data()+LocInfo.second; // Create a lexer starting at the beginning of this token. @@ -1042,14 +1060,19 @@ getLocationOfByte(unsigned ByteNo, const SourceManager &SM, // If the byte is in this token, return the location of the byte. if (ByteNo < TokNumBytes || (ByteNo == TokNumBytes && TokNo == getNumConcatenated() - 1)) { - unsigned Offset = SLP.getOffsetOfStringByte(TheTok, ByteNo); - + unsigned Offset = SLP.getOffsetOfStringByte(TheTok, ByteNo); + // Now that we know the offset of the token in the spelling, use the // preprocessor to get the offset in the original source. + if (StartTokenByteOffset != nullptr) + *StartTokenByteOffset = StringOffset; + if (StartToken != nullptr) + *StartToken = TokNo; return Lexer::AdvanceToTokenCharacter(StrTokLoc, Offset, SM, Features); } - + // Move to the next string token. + StringOffset += TokNumBytes; ++TokNo; ByteNo -= TokNumBytes; } @@ -1074,6 +1097,7 @@ StringRef UnaryOperator::getOpcodeStr(Opcode Op) { case UO_Real: return "__real"; case UO_Imag: return "__imag"; case UO_Extension: return "__extension__"; + case UO_Coawait: return "co_await"; } llvm_unreachable("Unknown unary operator"); } @@ -1090,6 +1114,7 @@ UnaryOperator::getOverloadedOpcode(OverloadedOperatorKind OO, bool Postfix) { case OO_Minus: return UO_Minus; case OO_Tilde: return UO_Not; case OO_Exclaim: return UO_LNot; + case OO_Coawait: return UO_Coawait; } } @@ -1103,6 +1128,7 @@ OverloadedOperatorKind UnaryOperator::getOverloadedOperator(Opcode Opc) { case UO_Minus: return OO_Minus; case UO_Not: return OO_Tilde; case UO_LNot: return OO_Exclaim; + case UO_Coawait: return OO_Coawait; default: return OO_None; } } @@ -1288,9 +1314,8 @@ OffsetOfExpr *OffsetOfExpr::Create(const ASTContext &C, QualType type, ArrayRef<OffsetOfNode> comps, ArrayRef<Expr*> exprs, SourceLocation RParenLoc) { - void *Mem = C.Allocate(sizeof(OffsetOfExpr) + - sizeof(OffsetOfNode) * comps.size() + - sizeof(Expr*) * exprs.size()); + void *Mem = C.Allocate( + totalSizeToAlloc<OffsetOfNode, Expr *>(comps.size(), exprs.size())); return new (Mem) OffsetOfExpr(C, type, OperatorLoc, tsi, comps, exprs, RParenLoc); @@ -1298,9 +1323,8 @@ OffsetOfExpr *OffsetOfExpr::Create(const ASTContext &C, QualType type, OffsetOfExpr *OffsetOfExpr::CreateEmpty(const ASTContext &C, unsigned numComps, unsigned numExprs) { - void *Mem = C.Allocate(sizeof(OffsetOfExpr) + - sizeof(OffsetOfNode) * numComps + - sizeof(Expr*) * numExprs); + void *Mem = + C.Allocate(totalSizeToAlloc<OffsetOfNode, Expr *>(numComps, numExprs)); return new (Mem) OffsetOfExpr(numComps, numExprs); } @@ -1330,7 +1354,7 @@ OffsetOfExpr::OffsetOfExpr(const ASTContext &C, QualType type, } } -IdentifierInfo *OffsetOfExpr::OffsetOfNode::getFieldName() const { +IdentifierInfo *OffsetOfNode::getFieldName() const { assert(getKind() == Field || getKind() == Identifier); if (getKind() == Field) return getField()->getIdentifier(); @@ -1382,18 +1406,17 @@ MemberExpr *MemberExpr::Create( ValueDecl *memberdecl, DeclAccessPair founddecl, DeclarationNameInfo nameinfo, const TemplateArgumentListInfo *targs, QualType ty, ExprValueKind vk, ExprObjectKind ok) { - std::size_t Size = sizeof(MemberExpr); bool hasQualOrFound = (QualifierLoc || founddecl.getDecl() != memberdecl || founddecl.getAccess() != memberdecl->getAccess()); - if (hasQualOrFound) - Size += sizeof(MemberNameQualifier); - if (targs) - Size += ASTTemplateKWAndArgsInfo::sizeFor(targs->size()); - else if (TemplateKWLoc.isValid()) - Size += ASTTemplateKWAndArgsInfo::sizeFor(0); + bool HasTemplateKWAndArgsInfo = targs || TemplateKWLoc.isValid(); + std::size_t Size = + totalSizeToAlloc<MemberExprNameQualifier, ASTTemplateKWAndArgsInfo, + TemplateArgumentLoc>(hasQualOrFound ? 1 : 0, + HasTemplateKWAndArgsInfo ? 1 : 0, + targs ? targs->size() : 0); void *Mem = C.Allocate(Size, llvm::alignOf<MemberExpr>()); MemberExpr *E = new (Mem) @@ -1412,7 +1435,8 @@ MemberExpr *MemberExpr::Create( E->HasQualifierOrFoundDecl = true; - MemberNameQualifier *NQ = E->getMemberQualifier(); + MemberExprNameQualifier *NQ = + E->getTrailingObjects<MemberExprNameQualifier>(); NQ->QualifierLoc = QualifierLoc; NQ->FoundDecl = founddecl; } @@ -1423,14 +1447,14 @@ MemberExpr *MemberExpr::Create( bool Dependent = false; bool InstantiationDependent = false; bool ContainsUnexpandedParameterPack = false; - E->getTemplateKWAndArgsInfo()->initializeFrom(TemplateKWLoc, *targs, - Dependent, - InstantiationDependent, - ContainsUnexpandedParameterPack); + E->getTrailingObjects<ASTTemplateKWAndArgsInfo>()->initializeFrom( + TemplateKWLoc, *targs, E->getTrailingObjects<TemplateArgumentLoc>(), + Dependent, InstantiationDependent, ContainsUnexpandedParameterPack); if (InstantiationDependent) E->setInstantiationDependent(true); } else if (TemplateKWLoc.isValid()) { - E->getTemplateKWAndArgsInfo()->initializeFrom(TemplateKWLoc); + E->getTrailingObjects<ASTTemplateKWAndArgsInfo>()->initializeFrom( + TemplateKWLoc); } return E; @@ -1719,9 +1743,9 @@ Expr *CastExpr::getSubExprAsWritten() { CXXBaseSpecifier **CastExpr::path_buffer() { switch (getStmtClass()) { #define ABSTRACT_STMT(x) -#define CASTEXPR(Type, Base) \ - case Stmt::Type##Class: \ - return reinterpret_cast<CXXBaseSpecifier**>(static_cast<Type*>(this)+1); +#define CASTEXPR(Type, Base) \ + case Stmt::Type##Class: \ + return static_cast<Type *>(this)->getTrailingObjects<CXXBaseSpecifier *>(); #define STMT(Type, Base) #include "clang/AST/StmtNodes.inc" default: @@ -1729,28 +1753,23 @@ CXXBaseSpecifier **CastExpr::path_buffer() { } } -void CastExpr::setCastPath(const CXXCastPath &Path) { - assert(Path.size() == path_size()); - memcpy(path_buffer(), Path.data(), Path.size() * sizeof(CXXBaseSpecifier*)); -} - ImplicitCastExpr *ImplicitCastExpr::Create(const ASTContext &C, QualType T, CastKind Kind, Expr *Operand, const CXXCastPath *BasePath, ExprValueKind VK) { unsigned PathSize = (BasePath ? BasePath->size() : 0); - void *Buffer = - C.Allocate(sizeof(ImplicitCastExpr) + PathSize * sizeof(CXXBaseSpecifier*)); + void *Buffer = C.Allocate(totalSizeToAlloc<CXXBaseSpecifier *>(PathSize)); ImplicitCastExpr *E = new (Buffer) ImplicitCastExpr(T, Kind, Operand, PathSize, VK); - if (PathSize) E->setCastPath(*BasePath); + if (PathSize) + std::uninitialized_copy_n(BasePath->data(), BasePath->size(), + E->getTrailingObjects<CXXBaseSpecifier *>()); return E; } ImplicitCastExpr *ImplicitCastExpr::CreateEmpty(const ASTContext &C, unsigned PathSize) { - void *Buffer = - C.Allocate(sizeof(ImplicitCastExpr) + PathSize * sizeof(CXXBaseSpecifier*)); + void *Buffer = C.Allocate(totalSizeToAlloc<CXXBaseSpecifier *>(PathSize)); return new (Buffer) ImplicitCastExpr(EmptyShell(), PathSize); } @@ -1761,18 +1780,18 @@ CStyleCastExpr *CStyleCastExpr::Create(const ASTContext &C, QualType T, TypeSourceInfo *WrittenTy, SourceLocation L, SourceLocation R) { unsigned PathSize = (BasePath ? BasePath->size() : 0); - void *Buffer = - C.Allocate(sizeof(CStyleCastExpr) + PathSize * sizeof(CXXBaseSpecifier*)); + void *Buffer = C.Allocate(totalSizeToAlloc<CXXBaseSpecifier *>(PathSize)); CStyleCastExpr *E = new (Buffer) CStyleCastExpr(T, VK, K, Op, PathSize, WrittenTy, L, R); - if (PathSize) E->setCastPath(*BasePath); + if (PathSize) + std::uninitialized_copy_n(BasePath->data(), BasePath->size(), + E->getTrailingObjects<CXXBaseSpecifier *>()); return E; } CStyleCastExpr *CStyleCastExpr::CreateEmpty(const ASTContext &C, unsigned PathSize) { - void *Buffer = - C.Allocate(sizeof(CStyleCastExpr) + PathSize * sizeof(CXXBaseSpecifier*)); + void *Buffer = C.Allocate(totalSizeToAlloc<CXXBaseSpecifier *>(PathSize)); return new (Buffer) CStyleCastExpr(EmptyShell(), PathSize); } @@ -2045,6 +2064,9 @@ bool Expr::isUnusedResultAWarning(const Expr *&WarnE, SourceLocation &Loc, case UO_LNot: case UO_Deref: break; + case UO_Coawait: + // This is just the 'operator co_await' call inside the guts of a + // dependent co_await call. case UO_PostInc: case UO_PostDec: case UO_PreInc: @@ -2880,7 +2902,10 @@ bool Expr::isConstantInitializer(ASTContext &Ctx, bool IsForRef, return cast<CXXDefaultInitExpr>(this)->getExpr() ->isConstantInitializer(Ctx, false, Culprit); } - if (isEvaluatable(Ctx)) + // Allow certain forms of UB in constant initializers: signed integer + // overflow and floating-point division by zero. We'll give a warning on + // these, but they're common enough that we have to accept them. + if (isEvaluatable(Ctx, SE_AllowUndefinedBehavior)) return true; if (Culprit) *Culprit = this; @@ -2993,6 +3018,7 @@ bool Expr::HasSideEffects(const ASTContext &Ctx, return true; case MSPropertyRefExprClass: + case MSPropertySubscriptExprClass: case CompoundAssignOperatorClass: case VAArgExprClass: case AtomicExprClass: @@ -3000,6 +3026,8 @@ bool Expr::HasSideEffects(const ASTContext &Ctx, case CXXNewExprClass: case CXXDeleteExprClass: case ExprWithCleanupsClass: + case CoawaitExprClass: + case CoyieldExprClass: // These always have a side-effect. return true; @@ -3012,6 +3040,7 @@ bool Expr::HasSideEffects(const ASTContext &Ctx, case ParenExprClass: case ArraySubscriptExprClass: + case OMPArraySectionExprClass: case MemberExprClass: case ConditionalOperatorClass: case BinaryConditionalOperatorClass: @@ -3246,9 +3275,20 @@ Expr::isNullPointerConstant(ASTContext &Ctx, // Check that it is a cast to void*. if (const PointerType *PT = CE->getType()->getAs<PointerType>()) { QualType Pointee = PT->getPointeeType(); - if (!Pointee.hasQualifiers() && - Pointee->isVoidType() && // to void* - CE->getSubExpr()->getType()->isIntegerType()) // from int. + Qualifiers Q = Pointee.getQualifiers(); + // In OpenCL v2.0 generic address space acts as a placeholder + // and should be ignored. + bool IsASValid = true; + if (Ctx.getLangOpts().OpenCLVersion >= 200) { + if (Pointee.getAddressSpace() == LangAS::opencl_generic) + Q.removeAddressSpace(); + else + IsASValid = false; + } + + if (IsASValid && !Q.hasQualifiers() && + Pointee->isVoidType() && // to void* + CE->getSubExpr()->getType()->isIntegerType()) // from int. return CE->getSubExpr()->isNullPointerConstant(Ctx, NPC); } } @@ -3429,6 +3469,18 @@ bool Expr::refersToVectorElement() const { return false; } +bool Expr::refersToGlobalRegisterVar() const { + const Expr *E = this->IgnoreParenImpCasts(); + + if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E)) + if (const auto *VD = dyn_cast<VarDecl>(DRE->getDecl())) + if (VD->getStorageClass() == SC_Register && + VD->hasAttr<AsmLabelAttr>() && !VD->isLocalVarDecl()) + return true; + + return false; +} + /// isArrow - Return true if the base expression is a pointer to vector, /// return false if the base expression is a vector. bool ExtVectorElementExpr::isArrow() const { @@ -3464,7 +3516,7 @@ bool ExtVectorElementExpr::containsDuplicateElements() const { /// getEncodedElementAccess - We encode the fields as a llvm ConstantArray. void ExtVectorElementExpr::getEncodedElementAccess( - SmallVectorImpl<unsigned> &Elts) const { + SmallVectorImpl<uint32_t> &Elts) const { StringRef Comp = Accessor->getName(); if (Comp[0] == 's' || Comp[0] == 'S') Comp = Comp.substr(1); @@ -3492,285 +3544,6 @@ void ExtVectorElementExpr::getEncodedElementAccess( } } -ObjCMessageExpr::ObjCMessageExpr(QualType T, - ExprValueKind VK, - SourceLocation LBracLoc, - SourceLocation SuperLoc, - bool IsInstanceSuper, - QualType SuperType, - Selector Sel, - ArrayRef<SourceLocation> SelLocs, - SelectorLocationsKind SelLocsK, - ObjCMethodDecl *Method, - ArrayRef<Expr *> Args, - SourceLocation RBracLoc, - bool isImplicit) - : Expr(ObjCMessageExprClass, T, VK, OK_Ordinary, - /*TypeDependent=*/false, /*ValueDependent=*/false, - /*InstantiationDependent=*/false, - /*ContainsUnexpandedParameterPack=*/false), - SelectorOrMethod(reinterpret_cast<uintptr_t>(Method? Method - : Sel.getAsOpaquePtr())), - Kind(IsInstanceSuper? SuperInstance : SuperClass), - HasMethod(Method != nullptr), IsDelegateInitCall(false), - IsImplicit(isImplicit), SuperLoc(SuperLoc), LBracLoc(LBracLoc), - RBracLoc(RBracLoc) -{ - initArgsAndSelLocs(Args, SelLocs, SelLocsK); - setReceiverPointer(SuperType.getAsOpaquePtr()); -} - -ObjCMessageExpr::ObjCMessageExpr(QualType T, - ExprValueKind VK, - SourceLocation LBracLoc, - TypeSourceInfo *Receiver, - Selector Sel, - ArrayRef<SourceLocation> SelLocs, - SelectorLocationsKind SelLocsK, - ObjCMethodDecl *Method, - ArrayRef<Expr *> Args, - SourceLocation RBracLoc, - bool isImplicit) - : Expr(ObjCMessageExprClass, T, VK, OK_Ordinary, T->isDependentType(), - T->isDependentType(), T->isInstantiationDependentType(), - T->containsUnexpandedParameterPack()), - SelectorOrMethod(reinterpret_cast<uintptr_t>(Method? Method - : Sel.getAsOpaquePtr())), - Kind(Class), - HasMethod(Method != nullptr), IsDelegateInitCall(false), - IsImplicit(isImplicit), LBracLoc(LBracLoc), RBracLoc(RBracLoc) -{ - initArgsAndSelLocs(Args, SelLocs, SelLocsK); - setReceiverPointer(Receiver); -} - -ObjCMessageExpr::ObjCMessageExpr(QualType T, - ExprValueKind VK, - SourceLocation LBracLoc, - Expr *Receiver, - Selector Sel, - ArrayRef<SourceLocation> SelLocs, - SelectorLocationsKind SelLocsK, - ObjCMethodDecl *Method, - ArrayRef<Expr *> Args, - SourceLocation RBracLoc, - bool isImplicit) - : Expr(ObjCMessageExprClass, T, VK, OK_Ordinary, Receiver->isTypeDependent(), - Receiver->isTypeDependent(), - Receiver->isInstantiationDependent(), - Receiver->containsUnexpandedParameterPack()), - SelectorOrMethod(reinterpret_cast<uintptr_t>(Method? Method - : Sel.getAsOpaquePtr())), - Kind(Instance), - HasMethod(Method != nullptr), IsDelegateInitCall(false), - IsImplicit(isImplicit), LBracLoc(LBracLoc), RBracLoc(RBracLoc) -{ - initArgsAndSelLocs(Args, SelLocs, SelLocsK); - setReceiverPointer(Receiver); -} - -void ObjCMessageExpr::initArgsAndSelLocs(ArrayRef<Expr *> Args, - ArrayRef<SourceLocation> SelLocs, - SelectorLocationsKind SelLocsK) { - setNumArgs(Args.size()); - Expr **MyArgs = getArgs(); - for (unsigned I = 0; I != Args.size(); ++I) { - if (Args[I]->isTypeDependent()) - ExprBits.TypeDependent = true; - if (Args[I]->isValueDependent()) - ExprBits.ValueDependent = true; - if (Args[I]->isInstantiationDependent()) - ExprBits.InstantiationDependent = true; - if (Args[I]->containsUnexpandedParameterPack()) - ExprBits.ContainsUnexpandedParameterPack = true; - - MyArgs[I] = Args[I]; - } - - SelLocsKind = SelLocsK; - if (!isImplicit()) { - if (SelLocsK == SelLoc_NonStandard) - std::copy(SelLocs.begin(), SelLocs.end(), getStoredSelLocs()); - } -} - -ObjCMessageExpr *ObjCMessageExpr::Create(const ASTContext &Context, QualType T, - ExprValueKind VK, - SourceLocation LBracLoc, - SourceLocation SuperLoc, - bool IsInstanceSuper, - QualType SuperType, - Selector Sel, - ArrayRef<SourceLocation> SelLocs, - ObjCMethodDecl *Method, - ArrayRef<Expr *> Args, - SourceLocation RBracLoc, - bool isImplicit) { - assert((!SelLocs.empty() || isImplicit) && - "No selector locs for non-implicit message"); - ObjCMessageExpr *Mem; - SelectorLocationsKind SelLocsK = SelectorLocationsKind(); - if (isImplicit) - Mem = alloc(Context, Args.size(), 0); - else - Mem = alloc(Context, Args, RBracLoc, SelLocs, Sel, SelLocsK); - return new (Mem) ObjCMessageExpr(T, VK, LBracLoc, SuperLoc, IsInstanceSuper, - SuperType, Sel, SelLocs, SelLocsK, - Method, Args, RBracLoc, isImplicit); -} - -ObjCMessageExpr *ObjCMessageExpr::Create(const ASTContext &Context, QualType T, - ExprValueKind VK, - SourceLocation LBracLoc, - TypeSourceInfo *Receiver, - Selector Sel, - ArrayRef<SourceLocation> SelLocs, - ObjCMethodDecl *Method, - ArrayRef<Expr *> Args, - SourceLocation RBracLoc, - bool isImplicit) { - assert((!SelLocs.empty() || isImplicit) && - "No selector locs for non-implicit message"); - ObjCMessageExpr *Mem; - SelectorLocationsKind SelLocsK = SelectorLocationsKind(); - if (isImplicit) - Mem = alloc(Context, Args.size(), 0); - else - Mem = alloc(Context, Args, RBracLoc, SelLocs, Sel, SelLocsK); - return new (Mem) ObjCMessageExpr(T, VK, LBracLoc, Receiver, Sel, - SelLocs, SelLocsK, Method, Args, RBracLoc, - isImplicit); -} - -ObjCMessageExpr *ObjCMessageExpr::Create(const ASTContext &Context, QualType T, - ExprValueKind VK, - SourceLocation LBracLoc, - Expr *Receiver, - Selector Sel, - ArrayRef<SourceLocation> SelLocs, - ObjCMethodDecl *Method, - ArrayRef<Expr *> Args, - SourceLocation RBracLoc, - bool isImplicit) { - assert((!SelLocs.empty() || isImplicit) && - "No selector locs for non-implicit message"); - ObjCMessageExpr *Mem; - SelectorLocationsKind SelLocsK = SelectorLocationsKind(); - if (isImplicit) - Mem = alloc(Context, Args.size(), 0); - else - Mem = alloc(Context, Args, RBracLoc, SelLocs, Sel, SelLocsK); - return new (Mem) ObjCMessageExpr(T, VK, LBracLoc, Receiver, Sel, - SelLocs, SelLocsK, Method, Args, RBracLoc, - isImplicit); -} - -ObjCMessageExpr *ObjCMessageExpr::CreateEmpty(const ASTContext &Context, - unsigned NumArgs, - unsigned NumStoredSelLocs) { - ObjCMessageExpr *Mem = alloc(Context, NumArgs, NumStoredSelLocs); - return new (Mem) ObjCMessageExpr(EmptyShell(), NumArgs); -} - -ObjCMessageExpr *ObjCMessageExpr::alloc(const ASTContext &C, - ArrayRef<Expr *> Args, - SourceLocation RBraceLoc, - ArrayRef<SourceLocation> SelLocs, - Selector Sel, - SelectorLocationsKind &SelLocsK) { - SelLocsK = hasStandardSelectorLocs(Sel, SelLocs, Args, RBraceLoc); - unsigned NumStoredSelLocs = (SelLocsK == SelLoc_NonStandard) ? SelLocs.size() - : 0; - return alloc(C, Args.size(), NumStoredSelLocs); -} - -ObjCMessageExpr *ObjCMessageExpr::alloc(const ASTContext &C, - unsigned NumArgs, - unsigned NumStoredSelLocs) { - unsigned Size = sizeof(ObjCMessageExpr) + sizeof(void *) + - NumArgs * sizeof(Expr *) + NumStoredSelLocs * sizeof(SourceLocation); - return (ObjCMessageExpr *)C.Allocate(Size, - llvm::AlignOf<ObjCMessageExpr>::Alignment); -} - -void ObjCMessageExpr::getSelectorLocs( - SmallVectorImpl<SourceLocation> &SelLocs) const { - for (unsigned i = 0, e = getNumSelectorLocs(); i != e; ++i) - SelLocs.push_back(getSelectorLoc(i)); -} - -SourceRange ObjCMessageExpr::getReceiverRange() const { - switch (getReceiverKind()) { - case Instance: - return getInstanceReceiver()->getSourceRange(); - - case Class: - return getClassReceiverTypeInfo()->getTypeLoc().getSourceRange(); - - case SuperInstance: - case SuperClass: - return getSuperLoc(); - } - - llvm_unreachable("Invalid ReceiverKind!"); -} - -Selector ObjCMessageExpr::getSelector() const { - if (HasMethod) - return reinterpret_cast<const ObjCMethodDecl *>(SelectorOrMethod) - ->getSelector(); - return Selector(SelectorOrMethod); -} - -QualType ObjCMessageExpr::getReceiverType() const { - switch (getReceiverKind()) { - case Instance: - return getInstanceReceiver()->getType(); - case Class: - return getClassReceiver(); - case SuperInstance: - case SuperClass: - return getSuperType(); - } - - llvm_unreachable("unexpected receiver kind"); -} - -ObjCInterfaceDecl *ObjCMessageExpr::getReceiverInterface() const { - QualType T = getReceiverType(); - - if (const ObjCObjectPointerType *Ptr = T->getAs<ObjCObjectPointerType>()) - return Ptr->getInterfaceDecl(); - - if (const ObjCObjectType *Ty = T->getAs<ObjCObjectType>()) - return Ty->getInterface(); - - return nullptr; -} - -QualType ObjCPropertyRefExpr::getReceiverType(const ASTContext &ctx) const { - if (isClassReceiver()) - return ctx.getObjCInterfaceType(getClassReceiver()); - - if (isSuperReceiver()) - return getSuperReceiverType(); - - return getBase()->getType(); -} - -StringRef ObjCBridgedCastExpr::getBridgeKindName() const { - switch (getBridgeKind()) { - case OBC_Bridge: - return "__bridge"; - case OBC_BridgeTransfer: - return "__bridge_transfer"; - case OBC_BridgeRetained: - return "__bridge_retained"; - } - - llvm_unreachable("Invalid BridgeKind!"); -} - ShuffleVectorExpr::ShuffleVectorExpr(const ASTContext &C, ArrayRef<Expr*> args, QualType Type, SourceLocation BLoc, SourceLocation RP) @@ -3883,7 +3656,7 @@ DesignatedInitExpr::DesignatedInitExpr(const ASTContext &C, QualType Ty, this->Designators = new (C) Designator[NumDesignators]; // Record the initializer itself. - child_range Child = children(); + child_iterator Child = child_begin(); *Child++ = Init; // Copy the designators and their subexpressions, computing @@ -3939,7 +3712,8 @@ DesignatedInitExpr::Create(const ASTContext &C, Designator *Designators, SourceLocation ColonOrEqualLoc, bool UsesColonSyntax, Expr *Init) { void *Mem = C.Allocate(sizeof(DesignatedInitExpr) + - sizeof(Stmt *) * (IndexExprs.size() + 1), 8); + sizeof(Stmt *) * (IndexExprs.size() + 1), + llvm::alignOf<DesignatedInitExpr>()); return new (Mem) DesignatedInitExpr(C, C.VoidTy, NumDesignators, Designators, ColonOrEqualLoc, UsesColonSyntax, IndexExprs, Init); @@ -4154,19 +3928,6 @@ PseudoObjectExpr::PseudoObjectExpr(QualType type, ExprValueKind VK, } //===----------------------------------------------------------------------===// -// ExprIterator. -//===----------------------------------------------------------------------===// - -Expr* ExprIterator::operator[](size_t idx) { return cast<Expr>(I[idx]); } -Expr* ExprIterator::operator*() const { return cast<Expr>(*I); } -Expr* ExprIterator::operator->() const { return cast<Expr>(*I); } -const Expr* ConstExprIterator::operator[](size_t idx) const { - return cast<Expr>(I[idx]); -} -const Expr* ConstExprIterator::operator*() const { return cast<Expr>(*I); } -const Expr* ConstExprIterator::operator->() const { return cast<Expr>(*I); } - -//===----------------------------------------------------------------------===// // Child Iterators for iterating over subexpressions/substatements //===----------------------------------------------------------------------===// @@ -4179,134 +3940,11 @@ Stmt::child_range UnaryExprOrTypeTraitExpr::children() { if (const VariableArrayType* T = dyn_cast<VariableArrayType>( getArgumentType().getTypePtr())) return child_range(child_iterator(T), child_iterator()); - return child_range(); + return child_range(child_iterator(), child_iterator()); } return child_range(&Argument.Ex, &Argument.Ex + 1); } -// ObjCMessageExpr -Stmt::child_range ObjCMessageExpr::children() { - Stmt **begin; - if (getReceiverKind() == Instance) - begin = reinterpret_cast<Stmt **>(this + 1); - else - begin = reinterpret_cast<Stmt **>(getArgs()); - return child_range(begin, - reinterpret_cast<Stmt **>(getArgs() + getNumArgs())); -} - -ObjCArrayLiteral::ObjCArrayLiteral(ArrayRef<Expr *> Elements, - QualType T, ObjCMethodDecl *Method, - SourceRange SR) - : Expr(ObjCArrayLiteralClass, T, VK_RValue, OK_Ordinary, - false, false, false, false), - NumElements(Elements.size()), Range(SR), ArrayWithObjectsMethod(Method) -{ - Expr **SaveElements = getElements(); - for (unsigned I = 0, N = Elements.size(); I != N; ++I) { - if (Elements[I]->isTypeDependent() || Elements[I]->isValueDependent()) - ExprBits.ValueDependent = true; - if (Elements[I]->isInstantiationDependent()) - ExprBits.InstantiationDependent = true; - if (Elements[I]->containsUnexpandedParameterPack()) - ExprBits.ContainsUnexpandedParameterPack = true; - - SaveElements[I] = Elements[I]; - } -} - -ObjCArrayLiteral *ObjCArrayLiteral::Create(const ASTContext &C, - ArrayRef<Expr *> Elements, - QualType T, ObjCMethodDecl * Method, - SourceRange SR) { - void *Mem = C.Allocate(sizeof(ObjCArrayLiteral) - + Elements.size() * sizeof(Expr *)); - return new (Mem) ObjCArrayLiteral(Elements, T, Method, SR); -} - -ObjCArrayLiteral *ObjCArrayLiteral::CreateEmpty(const ASTContext &C, - unsigned NumElements) { - - void *Mem = C.Allocate(sizeof(ObjCArrayLiteral) - + NumElements * sizeof(Expr *)); - return new (Mem) ObjCArrayLiteral(EmptyShell(), NumElements); -} - -ObjCDictionaryLiteral::ObjCDictionaryLiteral( - ArrayRef<ObjCDictionaryElement> VK, - bool HasPackExpansions, - QualType T, ObjCMethodDecl *method, - SourceRange SR) - : Expr(ObjCDictionaryLiteralClass, T, VK_RValue, OK_Ordinary, false, false, - false, false), - NumElements(VK.size()), HasPackExpansions(HasPackExpansions), Range(SR), - DictWithObjectsMethod(method) -{ - KeyValuePair *KeyValues = getKeyValues(); - ExpansionData *Expansions = getExpansionData(); - for (unsigned I = 0; I < NumElements; I++) { - if (VK[I].Key->isTypeDependent() || VK[I].Key->isValueDependent() || - VK[I].Value->isTypeDependent() || VK[I].Value->isValueDependent()) - ExprBits.ValueDependent = true; - if (VK[I].Key->isInstantiationDependent() || - VK[I].Value->isInstantiationDependent()) - ExprBits.InstantiationDependent = true; - if (VK[I].EllipsisLoc.isInvalid() && - (VK[I].Key->containsUnexpandedParameterPack() || - VK[I].Value->containsUnexpandedParameterPack())) - ExprBits.ContainsUnexpandedParameterPack = true; - - KeyValues[I].Key = VK[I].Key; - KeyValues[I].Value = VK[I].Value; - if (Expansions) { - Expansions[I].EllipsisLoc = VK[I].EllipsisLoc; - if (VK[I].NumExpansions) - Expansions[I].NumExpansionsPlusOne = *VK[I].NumExpansions + 1; - else - Expansions[I].NumExpansionsPlusOne = 0; - } - } -} - -ObjCDictionaryLiteral * -ObjCDictionaryLiteral::Create(const ASTContext &C, - ArrayRef<ObjCDictionaryElement> VK, - bool HasPackExpansions, - QualType T, ObjCMethodDecl *method, - SourceRange SR) { - unsigned ExpansionsSize = 0; - if (HasPackExpansions) - ExpansionsSize = sizeof(ExpansionData) * VK.size(); - - void *Mem = C.Allocate(sizeof(ObjCDictionaryLiteral) + - sizeof(KeyValuePair) * VK.size() + ExpansionsSize); - return new (Mem) ObjCDictionaryLiteral(VK, HasPackExpansions, T, method, SR); -} - -ObjCDictionaryLiteral * -ObjCDictionaryLiteral::CreateEmpty(const ASTContext &C, unsigned NumElements, - bool HasPackExpansions) { - unsigned ExpansionsSize = 0; - if (HasPackExpansions) - ExpansionsSize = sizeof(ExpansionData) * NumElements; - void *Mem = C.Allocate(sizeof(ObjCDictionaryLiteral) + - sizeof(KeyValuePair) * NumElements + ExpansionsSize); - return new (Mem) ObjCDictionaryLiteral(EmptyShell(), NumElements, - HasPackExpansions); -} - -ObjCSubscriptRefExpr *ObjCSubscriptRefExpr::Create(const ASTContext &C, - Expr *base, - Expr *key, QualType T, - ObjCMethodDecl *getMethod, - ObjCMethodDecl *setMethod, - SourceLocation RB) { - void *Mem = C.Allocate(sizeof(ObjCSubscriptRefExpr)); - return new (Mem) ObjCSubscriptRefExpr(base, key, T, VK_LValue, - OK_ObjCSubscript, - getMethod, setMethod, RB); -} - AtomicExpr::AtomicExpr(SourceLocation BLoc, ArrayRef<Expr*> args, QualType t, AtomicOp op, SourceLocation RP) : Expr(AtomicExprClass, t, VK_RValue, OK_Ordinary, @@ -4373,3 +4011,29 @@ unsigned AtomicExpr::getNumSubExprs(AtomicOp Op) { } llvm_unreachable("unknown atomic op"); } + +QualType OMPArraySectionExpr::getBaseOriginalType(Expr *Base) { + unsigned ArraySectionCount = 0; + while (auto *OASE = dyn_cast<OMPArraySectionExpr>(Base->IgnoreParens())) { + Base = OASE->getBase(); + ++ArraySectionCount; + } + while (auto *ASE = dyn_cast<ArraySubscriptExpr>(Base->IgnoreParens())) { + Base = ASE->getBase(); + ++ArraySectionCount; + } + auto OriginalTy = Base->getType(); + if (auto *DRE = dyn_cast<DeclRefExpr>(Base)) + if (auto *PVD = dyn_cast<ParmVarDecl>(DRE->getDecl())) + OriginalTy = PVD->getOriginalType().getNonReferenceType(); + + for (unsigned Cnt = 0; Cnt < ArraySectionCount; ++Cnt) { + if (OriginalTy->isAnyPointerType()) + OriginalTy = OriginalTy->getPointeeType(); + else { + assert (OriginalTy->isArrayType()); + OriginalTy = OriginalTy->castAsArrayTypeUnsafe()->getElementType(); + } + } + return OriginalTy; +} |