diff --git a/include/clang/AST/ASTContext.h b/include/clang/AST/ASTContext.h
index 507d98b797a4f7e9d80b9b424cd1df2dbc2e038d..7c0d19c56f9a3a304fb36067e589f5393b11fbb4 100644
--- a/include/clang/AST/ASTContext.h
+++ b/include/clang/AST/ASTContext.h
@@ -1881,11 +1881,6 @@ public:
unsigned getTypeAlign(QualType T) const { return getTypeInfo(T).Align; }
unsigned getTypeAlign(const Type *T) const { return getTypeInfo(T).Align; }
- /// \brief Return the ABI-specified alignment of a type, in bits, or 0 if
- /// the type is incomplete and we cannot determine the alignment (for
- /// example, from alignment attributes).
- unsigned getTypeAlignIfKnown(QualType T) const;
-
/// \brief Return the ABI-specified alignment of a (complete) type \p T, in
/// characters.
CharUnits getTypeAlignInChars(QualType T) const;
diff --git a/include/clang/AST/ExprCXX.h b/include/clang/AST/ExprCXX.h
index af45b161f6be1bee0d6138440e85e05dec4f72d0..3de5cc921aa8a873491a67f0a0a0ec62dbeb117a 100644
--- a/include/clang/AST/ExprCXX.h
+++ b/include/clang/AST/ExprCXX.h
@@ -1838,13 +1838,11 @@ class CXXNewExpr : public Expr {
unsigned GlobalNew : 1;
/// Do we allocate an array? If so, the first SubExpr is the size expression.
unsigned Array : 1;
- /// Should the alignment be passed to the allocation function?
- unsigned PassAlignment : 1;
/// If this is an array allocation, does the usual deallocation
/// function for the allocated type want to know the allocated size?
unsigned UsualArrayDeleteWantsSize : 1;
/// The number of placement new arguments.
- unsigned NumPlacementArgs : 26;
+ unsigned NumPlacementArgs : 13;
/// What kind of initializer do we have? Could be none, parens, or braces.
/// In storage, we distinguish between "none, and no initializer expr", and
/// "none, but an implicit initializer expr".
@@ -1860,8 +1858,8 @@ public:
};
CXXNewExpr(const ASTContext &C, bool globalNew, FunctionDecl *operatorNew,
- FunctionDecl *operatorDelete, bool PassAlignment,
- bool usualArrayDeleteWantsSize, ArrayRef<Expr*> placementArgs,
+ FunctionDecl *operatorDelete, bool usualArrayDeleteWantsSize,
+ ArrayRef<Expr*> placementArgs,
SourceRange typeIdParens, Expr *arraySize,
InitializationStyle initializationStyle, Expr *initializer,
QualType ty, TypeSourceInfo *AllocatedTypeInfo,
@@ -1949,16 +1947,10 @@ public:
}
/// \brief Returns the CXXConstructExpr from this new-expression, or null.
- const CXXConstructExpr *getConstructExpr() const {
+ const CXXConstructExpr* getConstructExpr() const {
return dyn_cast_or_null<CXXConstructExpr>(getInitializer());
}
- /// Indicates whether the required alignment should be implicitly passed to
- /// the allocation function.
- bool passAlignment() const {
- return PassAlignment;
- }
-
/// Answers whether the usual array deallocation function for the
/// allocated type expects the size of the allocation as a
/// parameter.
diff --git a/include/clang/AST/Type.h b/include/clang/AST/Type.h
index fb1b50f7aac714d28838bc9b3f359b4532776f43..54435502c256b5319aa6b38d77d903bfc0091dd1 100644
--- a/include/clang/AST/Type.h
+++ b/include/clang/AST/Type.h
@@ -1729,8 +1729,7 @@ public:
bool isObjCARCBridgableType() const;
bool isCARCBridgableType() const;
bool isTemplateTypeParmType() const; // C++ template type parameter
- bool isNullPtrType() const; // C++11 std::nullptr_t
- bool isAlignValT() const; // C++17 std::align_val_t
+ bool isNullPtrType() const; // C++0x nullptr_t
bool isAtomicType() const; // C11 _Atomic()
#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
diff --git a/include/clang/Basic/DiagnosticSemaKinds.td b/include/clang/Basic/DiagnosticSemaKinds.td
index 59199aea7b8573ea8d6c6bd386949a8705b6cd7c..bd634a6b3aca51dc2112aa892b06abca45e6a73e 100644
--- a/include/clang/Basic/DiagnosticSemaKinds.td
+++ b/include/clang/Basic/DiagnosticSemaKinds.td
@@ -6025,10 +6025,6 @@ def err_no_suitable_delete_member_function_found : Error<
"no suitable member %0 in %1">;
def err_ambiguous_suitable_delete_member_function_found : Error<
"multiple suitable %0 functions in %1">;
-def warn_ambiguous_suitable_delete_function_found : Warning<
- "multiple suitable %0 functions for %1; no 'operator delete' function "
- "will be invoked if initialization throws an exception">,
- InGroup<DiagGroup<"ambiguous-delete">>;
def note_member_declared_here : Note<
"member %0 declared here">;
def err_decrement_bool : Error<"cannot decrement expression of type bool">;
diff --git a/include/clang/Sema/Overload.h b/include/clang/Sema/Overload.h
index 1c2eb927895c5e90eee13d3aad4a6737727bf7e4..3bcd327df9469c4cc133dd7cded10cab306d6707 100644
--- a/include/clang/Sema/Overload.h
+++ b/include/clang/Sema/Overload.h
@@ -795,9 +795,7 @@ namespace clang {
OverloadCandidateDisplayKind OCD,
ArrayRef<Expr *> Args,
StringRef Opc = "",
- SourceLocation Loc = SourceLocation(),
- llvm::function_ref<bool(OverloadCandidate&)> Filter =
- [](OverloadCandidate&) { return true; });
+ SourceLocation Loc = SourceLocation());
};
bool isBetterOverloadCandidate(Sema &S,
diff --git a/include/clang/Sema/Sema.h b/include/clang/Sema/Sema.h
index adf7b07f14b93caa4e79d2904665fd03f699ed6b..8bd3916e0d87fe87ada061abd1ce8599ee2100a9 100644
--- a/include/clang/Sema/Sema.h
+++ b/include/clang/Sema/Sema.h
@@ -4855,9 +4855,14 @@ public:
SourceRange R);
bool FindAllocationFunctions(SourceLocation StartLoc, SourceRange Range,
bool UseGlobal, QualType AllocType, bool IsArray,
- bool &PassAlignment, MultiExprArg PlaceArgs,
+ MultiExprArg PlaceArgs,
FunctionDecl *&OperatorNew,
FunctionDecl *&OperatorDelete);
+ bool FindAllocationOverload(SourceLocation StartLoc, SourceRange Range,
+ DeclarationName Name, MultiExprArg Args,
+ DeclContext *Ctx,
+ bool AllowMissing, FunctionDecl *&Operator,
+ bool Diagnose = true);
void DeclareGlobalNewDelete();
void DeclareGlobalAllocationFunction(DeclarationName Name, QualType Return,
ArrayRef<QualType> Params);
@@ -4867,10 +4872,7 @@ public:
bool Diagnose = true);
FunctionDecl *FindUsualDeallocationFunction(SourceLocation StartLoc,
bool CanProvideSize,
- bool Overaligned,
DeclarationName Name);
- FunctionDecl *FindDeallocationFunctionForDestructor(SourceLocation StartLoc,
- CXXRecordDecl *RD);
/// ActOnCXXDelete - Parsed a C++ 'delete' expression
ExprResult ActOnCXXDelete(SourceLocation StartLoc,
@@ -9335,7 +9337,6 @@ public:
void EraseUnwantedCUDAMatches(
const FunctionDecl *Caller,
SmallVectorImpl<std::pair<DeclAccessPair, FunctionDecl *>> &Matches);
- void EraseUnwantedCUDAMatches(const FunctionDecl *Caller, LookupResult &R);
/// Given a implicit special member, infer its CUDA target from the
/// calls it needs to make to underlying base/field special members.
diff --git a/lib/AST/ASTContext.cpp b/lib/AST/ASTContext.cpp
index 6b840b9e47595e3ec5198100df7e06e4ff291e0c..dc99d4dabd437d4371b10eead3842c1abed7e678 100644
--- a/lib/AST/ASTContext.cpp
+++ b/lib/AST/ASTContext.cpp
@@ -1572,30 +1572,6 @@ bool ASTContext::isAlignmentRequired(QualType T) const {
return isAlignmentRequired(T.getTypePtr());
}
-unsigned ASTContext::getTypeAlignIfKnown(QualType T) const {
- // An alignment on a typedef overrides anything else.
- if (auto *TT = T->getAs<TypedefType>())
- if (unsigned Align = TT->getDecl()->getMaxAlignment())
- return Align;
-
- // If we have an (array of) complete type, we're done.
- T = getBaseElementType(T);
- if (!T->isIncompleteType())
- return getTypeAlign(T);
-
- // If we had an array type, its element type might be a typedef
- // type with an alignment attribute.
- if (auto *TT = T->getAs<TypedefType>())
- if (unsigned Align = TT->getDecl()->getMaxAlignment())
- return Align;
-
- // Otherwise, see if the declaration of the type had an attribute.
- if (auto *TT = T->getAs<TagType>())
- return TT->getDecl()->getMaxAlignment();
-
- return 0;
-}
-
TypeInfo ASTContext::getTypeInfo(const Type *T) const {
TypeInfoMap::iterator I = MemoizedTypeInfo.find(T);
if (I != MemoizedTypeInfo.end())
diff --git a/lib/AST/ASTImporter.cpp b/lib/AST/ASTImporter.cpp
index 9e17c0c3de58d2a177fb24cf00323c82d48a5e3b..d03de30d1b49e94d6231253d1c809294f2900237 100644
--- a/lib/AST/ASTImporter.cpp
+++ b/lib/AST/ASTImporter.cpp
@@ -6330,7 +6330,6 @@ Expr *ASTNodeImporter::VisitCXXNewExpr(CXXNewExpr *CE) {
Importer.getToContext(),
CE->isGlobalNew(),
OperatorNewDecl, OperatorDeleteDecl,
- CE->passAlignment(),
CE->doesUsualArrayDeleteWantSize(),
PlacementArgs,
Importer.Import(CE->getTypeIdParens()),
diff --git a/lib/AST/Decl.cpp b/lib/AST/Decl.cpp
index e330e31d47feb6cf570afd548946510211290bd1..fec7df0ffb7328c951c278c7337dc5fcbff4d95c 100644
--- a/lib/AST/Decl.cpp
+++ b/lib/AST/Decl.cpp
@@ -2596,7 +2596,7 @@ bool FunctionDecl::isReplaceableGlobalAllocationFunction() const {
return false;
const auto *FPT = getType()->castAs<FunctionProtoType>();
- if (FPT->getNumParams() == 0 || FPT->getNumParams() > 3 || FPT->isVariadic())
+ if (FPT->getNumParams() == 0 || FPT->getNumParams() > 2 || FPT->isVariadic())
return false;
// If this is a single-parameter function, it must be a replaceable global
@@ -2604,42 +2604,20 @@ bool FunctionDecl::isReplaceableGlobalAllocationFunction() const {
if (FPT->getNumParams() == 1)
return true;
- unsigned Params = 1;
- QualType Ty = FPT->getParamType(Params);
+ // Otherwise, we're looking for a second parameter whose type is
+ // 'const std::nothrow_t &', or, in C++1y, 'std::size_t'.
+ QualType Ty = FPT->getParamType(1);
ASTContext &Ctx = getASTContext();
-
- auto Consume = [&] {
- ++Params;
- Ty = Params < FPT->getNumParams() ? FPT->getParamType(Params) : QualType();
- };
-
- // In C++14, the next parameter can be a 'std::size_t' for sized delete.
- bool IsSizedDelete = false;
if (Ctx.getLangOpts().SizedDeallocation &&
- (getDeclName().getCXXOverloadedOperator() == OO_Delete ||
- getDeclName().getCXXOverloadedOperator() == OO_Array_Delete) &&
- Ctx.hasSameType(Ty, Ctx.getSizeType())) {
- IsSizedDelete = true;
- Consume();
- }
-
- // In C++17, the next parameter can be a 'std::align_val_t' for aligned
- // new/delete.
- if (Ctx.getLangOpts().AlignedAllocation && !Ty.isNull() && Ty->isAlignValT())
- Consume();
-
- // Finally, if this is not a sized delete, the final parameter can
- // be a 'const std::nothrow_t&'.
- if (!IsSizedDelete && !Ty.isNull() && Ty->isReferenceType()) {
- Ty = Ty->getPointeeType();
- if (Ty.getCVRQualifiers() != Qualifiers::Const)
- return false;
- const CXXRecordDecl *RD = Ty->getAsCXXRecordDecl();
- if (RD && isNamed(RD, "nothrow_t") && RD->isInStdNamespace())
- Consume();
- }
-
- return Params == FPT->getNumParams();
+ Ctx.hasSameType(Ty, Ctx.getSizeType()))
+ return true;
+ if (!Ty->isReferenceType())
+ return false;
+ Ty = Ty->getPointeeType();
+ if (Ty.getCVRQualifiers() != Qualifiers::Const)
+ return false;
+ const CXXRecordDecl *RD = Ty->getAsCXXRecordDecl();
+ return RD && isNamed(RD, "nothrow_t") && RD->isInStdNamespace();
}
LanguageLinkage FunctionDecl::getLanguageLinkage() const {
diff --git a/lib/AST/DeclCXX.cpp b/lib/AST/DeclCXX.cpp
index 97f75a02052a685a952e3703f9da28ffe5bfed2a..d7472fcc358cbdcbf6fb877c65574e244bf5466b 100644
--- a/lib/AST/DeclCXX.cpp
+++ b/lib/AST/DeclCXX.cpp
@@ -1577,35 +1577,17 @@ bool CXXMethodDecl::isUsualDeallocationFunction() const {
// deallocation function. [...]
if (getNumParams() == 1)
return true;
- unsigned UsualParams = 1;
- // C++ <=14 [basic.stc.dynamic.deallocation]p2:
+ // C++ [basic.stc.dynamic.deallocation]p2:
// [...] If class T does not declare such an operator delete but does
// declare a member deallocation function named operator delete with
// exactly two parameters, the second of which has type std::size_t (18.1),
// then this function is a usual deallocation function.
- //
- // C++17 says a usual deallocation function is one with the signature
- // (void* [, size_t] [, std::align_val_t] [, ...])
- // and all such functions are usual deallocation functions. It's not clear
- // that allowing varargs functions was intentional.
ASTContext &Context = getASTContext();
- if (UsualParams < getNumParams() &&
- Context.hasSameUnqualifiedType(getParamDecl(UsualParams)->getType(),
- Context.getSizeType()))
- ++UsualParams;
-
- if (UsualParams < getNumParams() &&
- getParamDecl(UsualParams)->getType()->isAlignValT())
- ++UsualParams;
-
- if (UsualParams != getNumParams())
+ if (getNumParams() != 2 ||
+ !Context.hasSameUnqualifiedType(getParamDecl(1)->getType(),
+ Context.getSizeType()))
return false;
-
- // In C++17 onwards, all potential usual deallocation functions are actual
- // usual deallocation functions.
- if (Context.getLangOpts().AlignedAllocation)
- return true;
// This function is a usual deallocation function if there are no
// single-parameter deallocation functions of the same kind.
diff --git a/lib/AST/ExprCXX.cpp b/lib/AST/ExprCXX.cpp
index 3efb5b1cbc15e851828eefa10a27e21ec40f0e02..a13033d47467f73d3f92130337707e4a0bc06b6b 100644
--- a/lib/AST/ExprCXX.cpp
+++ b/lib/AST/ExprCXX.cpp
@@ -62,7 +62,7 @@ SourceLocation CXXScalarValueInitExpr::getLocStart() const {
// CXXNewExpr
CXXNewExpr::CXXNewExpr(const ASTContext &C, bool globalNew,
FunctionDecl *operatorNew, FunctionDecl *operatorDelete,
- bool PassAlignment, bool usualArrayDeleteWantsSize,
+ bool usualArrayDeleteWantsSize,
ArrayRef<Expr*> placementArgs,
SourceRange typeIdParens, Expr *arraySize,
InitializationStyle initializationStyle,
@@ -76,8 +76,7 @@ CXXNewExpr::CXXNewExpr(const ASTContext &C, bool globalNew,
SubExprs(nullptr), OperatorNew(operatorNew), OperatorDelete(operatorDelete),
AllocatedTypeInfo(allocatedTypeInfo), TypeIdParens(typeIdParens),
Range(Range), DirectInitRange(directInitRange),
- GlobalNew(globalNew), PassAlignment(PassAlignment),
- UsualArrayDeleteWantsSize(usualArrayDeleteWantsSize) {
+ GlobalNew(globalNew), UsualArrayDeleteWantsSize(usualArrayDeleteWantsSize) {
assert((initializer != nullptr || initializationStyle == NoInit) &&
"Only NoInit can have no initializer.");
StoredInitializationStyle = initializer ? initializationStyle + 1 : 0;
diff --git a/lib/AST/Type.cpp b/lib/AST/Type.cpp
index 113974c4b60f87a64b6bf94eb0f7d1c42123c3ac..4aa07568dc71076d7573868a5b6a5e2036d7714a 100644
--- a/lib/AST/Type.cpp
+++ b/lib/AST/Type.cpp
@@ -2337,15 +2337,6 @@ bool QualType::isCXX11PODType(const ASTContext &Context) const {
return false;
}
-bool Type::isAlignValT() const {
- if (auto *ET = getAs<EnumType>()) {
- auto *II = ET->getDecl()->getIdentifier();
- if (II && II->isStr("align_val_t") && ET->getDecl()->isInStdNamespace())
- return true;
- }
- return false;
-}
-
bool Type::isPromotableIntegerType() const {
if (const BuiltinType *BT = getAs<BuiltinType>())
switch (BT->getKind()) {
diff --git a/lib/CodeGen/CGExprCXX.cpp b/lib/CodeGen/CGExprCXX.cpp
index ccab9f08d63fa91278e2f6239251f28343e6d393..e022663788a07db7280ee8f9921575a3045c67d4 100644
--- a/lib/CodeGen/CGExprCXX.cpp
+++ b/lib/CodeGen/CGExprCXX.cpp
@@ -1219,116 +1219,111 @@ RValue CodeGenFunction::EmitBuiltinNewDeleteCall(const FunctionProtoType *Type,
llvm_unreachable("predeclared global operator new/delete is missing");
}
-static std::pair<bool, bool>
-shouldPassSizeAndAlignToUsualDelete(const FunctionProtoType *FPT) {
- auto AI = FPT->param_type_begin(), AE = FPT->param_type_end();
+namespace {
+ /// A cleanup to call the given 'operator delete' function upon
+ /// abnormal exit from a new expression.
+ class CallDeleteDuringNew final : public EHScopeStack::Cleanup {
+ size_t NumPlacementArgs;
+ const FunctionDecl *OperatorDelete;
+ llvm::Value *Ptr;
+ llvm::Value *AllocSize;
- // The first argument is always a void*.
- ++AI;
+ RValue *getPlacementArgs() { return reinterpret_cast<RValue*>(this+1); }
- // Figure out what other parameters we should be implicitly passing.
- bool PassSize = false;
- bool PassAlignment = false;
+ public:
+ static size_t getExtraSize(size_t NumPlacementArgs) {
+ return NumPlacementArgs * sizeof(RValue);
+ }
- if (AI != AE && (*AI)->isIntegerType()) {
- PassSize = true;
- ++AI;
- }
+ CallDeleteDuringNew(size_t NumPlacementArgs,
+ const FunctionDecl *OperatorDelete,
+ llvm::Value *Ptr,
+ llvm::Value *AllocSize)
+ : NumPlacementArgs(NumPlacementArgs), OperatorDelete(OperatorDelete),
+ Ptr(Ptr), AllocSize(AllocSize) {}
- if (AI != AE && (*AI)->isAlignValT()) {
- PassAlignment = true;
- ++AI;
- }
+ void setPlacementArg(unsigned I, RValue Arg) {
+ assert(I < NumPlacementArgs && "index out of range");
+ getPlacementArgs()[I] = Arg;
+ }
- assert(AI == AE && "unexpected usual deallocation function parameter");
- return {PassSize, PassAlignment};
-}
+ void Emit(CodeGenFunction &CGF, Flags flags) override {
+ const FunctionProtoType *FPT
+ = OperatorDelete->getType()->getAs<FunctionProtoType>();
+ assert(FPT->getNumParams() == NumPlacementArgs + 1 ||
+ (FPT->getNumParams() == 2 && NumPlacementArgs == 0));
-namespace {
- /// A cleanup to call the given 'operator delete' function upon abnormal
- /// exit from a new expression. Templated on a traits type that deals with
- /// ensuring that the arguments dominate the cleanup if necessary.
- template<typename Traits>
- class CallDeleteDuringNew final : public EHScopeStack::Cleanup {
- /// Type used to hold llvm::Value*s.
- typedef typename Traits::ValueTy ValueTy;
- /// Type used to hold RValues.
- typedef typename Traits::RValueTy RValueTy;
- struct PlacementArg {
- RValueTy ArgValue;
- QualType ArgType;
- };
-
- unsigned NumPlacementArgs : 31;
- unsigned PassAlignmentToPlacementDelete : 1;
+ CallArgList DeleteArgs;
+
+ // The first argument is always a void*.
+ FunctionProtoType::param_type_iterator AI = FPT->param_type_begin();
+ DeleteArgs.add(RValue::get(Ptr), *AI++);
+
+ // A member 'operator delete' can take an extra 'size_t' argument.
+ if (FPT->getNumParams() == NumPlacementArgs + 2)
+ DeleteArgs.add(RValue::get(AllocSize), *AI++);
+
+ // Pass the rest of the arguments, which must match exactly.
+ for (unsigned I = 0; I != NumPlacementArgs; ++I)
+ DeleteArgs.add(getPlacementArgs()[I], *AI++);
+
+ // Call 'operator delete'.
+ EmitNewDeleteCall(CGF, OperatorDelete, FPT, DeleteArgs);
+ }
+ };
+
+ /// A cleanup to call the given 'operator delete' function upon
+ /// abnormal exit from a new expression when the new expression is
+ /// conditional.
+ class CallDeleteDuringConditionalNew final : public EHScopeStack::Cleanup {
+ size_t NumPlacementArgs;
const FunctionDecl *OperatorDelete;
- ValueTy Ptr;
- ValueTy AllocSize;
- CharUnits AllocAlign;
+ DominatingValue<RValue>::saved_type Ptr;
+ DominatingValue<RValue>::saved_type AllocSize;
- PlacementArg *getPlacementArgs() {
- return reinterpret_cast<PlacementArg *>(this + 1);
+ DominatingValue<RValue>::saved_type *getPlacementArgs() {
+ return reinterpret_cast<DominatingValue<RValue>::saved_type*>(this+1);
}
public:
static size_t getExtraSize(size_t NumPlacementArgs) {
- return NumPlacementArgs * sizeof(PlacementArg);
+ return NumPlacementArgs * sizeof(DominatingValue<RValue>::saved_type);
}
- CallDeleteDuringNew(size_t NumPlacementArgs,
- const FunctionDecl *OperatorDelete, ValueTy Ptr,
- ValueTy AllocSize, bool PassAlignmentToPlacementDelete,
- CharUnits AllocAlign)
- : NumPlacementArgs(NumPlacementArgs),
- PassAlignmentToPlacementDelete(PassAlignmentToPlacementDelete),
- OperatorDelete(OperatorDelete), Ptr(Ptr), AllocSize(AllocSize),
- AllocAlign(AllocAlign) {}
-
- void setPlacementArg(unsigned I, RValueTy Arg, QualType Type) {
+ CallDeleteDuringConditionalNew(size_t NumPlacementArgs,
+ const FunctionDecl *OperatorDelete,
+ DominatingValue<RValue>::saved_type Ptr,
+ DominatingValue<RValue>::saved_type AllocSize)
+ : NumPlacementArgs(NumPlacementArgs), OperatorDelete(OperatorDelete),
+ Ptr(Ptr), AllocSize(AllocSize) {}
+
+ void setPlacementArg(unsigned I, DominatingValue<RValue>::saved_type Arg) {
assert(I < NumPlacementArgs && "index out of range");
- getPlacementArgs()[I] = {Arg, Type};
+ getPlacementArgs()[I] = Arg;
}
void Emit(CodeGenFunction &CGF, Flags flags) override {
- const FunctionProtoType *FPT =
- OperatorDelete->getType()->getAs<FunctionProtoType>();
+ const FunctionProtoType *FPT
+ = OperatorDelete->getType()->getAs<FunctionProtoType>();
+ assert(FPT->getNumParams() == NumPlacementArgs + 1 ||
+ (FPT->getNumParams() == 2 && NumPlacementArgs == 0));
+
CallArgList DeleteArgs;
// The first argument is always a void*.
- DeleteArgs.add(Traits::get(CGF, Ptr), FPT->getParamType(0));
-
- // Figure out what other parameters we should be implicitly passing.
- bool PassSize = false;
- bool PassAlignment = false;
- if (NumPlacementArgs) {
- // A placement deallocation function is implicitly passed an alignment
- // if the placement allocation function was, but is never passed a size.
- PassAlignment = PassAlignmentToPlacementDelete;
- } else {
- // For a non-placement new-expression, 'operator delete' can take a
- // size and/or an alignment if it has the right parameters.
- std::tie(PassSize, PassAlignment) =
- shouldPassSizeAndAlignToUsualDelete(FPT);
- }
-
- // The second argument can be a std::size_t (for non-placement delete).
- if (PassSize)
- DeleteArgs.add(Traits::get(CGF, AllocSize),
- CGF.getContext().getSizeType());
+ FunctionProtoType::param_type_iterator AI = FPT->param_type_begin();
+ DeleteArgs.add(Ptr.restore(CGF), *AI++);
- // The next (second or third) argument can be a std::align_val_t, which
- // is an enum whose underlying type is std::size_t.
- // FIXME: Use the right type as the parameter type. Note that in a call
- // to operator delete(size_t, ...), we may not have it available.
- if (PassAlignment)
- DeleteArgs.add(RValue::get(llvm::ConstantInt::get(
- CGF.SizeTy, AllocAlign.getQuantity())),
- CGF.getContext().getSizeType());
+ // A member 'operator delete' can take an extra 'size_t' argument.
+ if (FPT->getNumParams() == NumPlacementArgs + 2) {
+ RValue RV = AllocSize.restore(CGF);
+ DeleteArgs.add(RV, *AI++);
+ }
// Pass the rest of the arguments, which must match exactly.
for (unsigned I = 0; I != NumPlacementArgs; ++I) {
- auto Arg = getPlacementArgs()[I];
- DeleteArgs.add(Traits::get(CGF, Arg.ArgValue), Arg.ArgType);
+ RValue RV = getPlacementArgs()[I].restore(CGF);
+ DeleteArgs.add(RV, *AI++);
}
// Call 'operator delete'.
@@ -1343,34 +1338,18 @@ static void EnterNewDeleteCleanup(CodeGenFunction &CGF,
const CXXNewExpr *E,
Address NewPtr,
llvm::Value *AllocSize,
- CharUnits AllocAlign,
const CallArgList &NewArgs) {
- unsigned NumNonPlacementArgs = E->passAlignment() ? 2 : 1;
-
// If we're not inside a conditional branch, then the cleanup will
// dominate and we can do the easier (and more efficient) thing.
if (!CGF.isInConditionalBranch()) {
- struct DirectCleanupTraits {
- typedef llvm::Value *ValueTy;
- typedef RValue RValueTy;
- static RValue get(CodeGenFunction &, ValueTy V) { return RValue::get(V); }
- static RValue get(CodeGenFunction &, RValueTy V) { return V; }
- };
-
- typedef CallDeleteDuringNew<DirectCleanupTraits> DirectCleanup;
-
- DirectCleanup *Cleanup = CGF.EHStack
- .pushCleanupWithExtra<DirectCleanup>(EHCleanup,
- E->getNumPlacementArgs(),
- E->getOperatorDelete(),
- NewPtr.getPointer(),
- AllocSize,
- E->passAlignment(),
- AllocAlign);
- for (unsigned I = 0, N = E->getNumPlacementArgs(); I != N; ++I) {
- auto &Arg = NewArgs[I + NumNonPlacementArgs];
- Cleanup->setPlacementArg(I, Arg.RV, Arg.Ty);
- }
+ CallDeleteDuringNew *Cleanup = CGF.EHStack
+ .pushCleanupWithExtra<CallDeleteDuringNew>(EHCleanup,
+ E->getNumPlacementArgs(),
+ E->getOperatorDelete(),
+ NewPtr.getPointer(),
+ AllocSize);
+ for (unsigned I = 0, N = E->getNumPlacementArgs(); I != N; ++I)
+ Cleanup->setPlacementArg(I, NewArgs[I+1].RV);
return;
}
@@ -1381,28 +1360,15 @@ static void EnterNewDeleteCleanup(CodeGenFunction &CGF,
DominatingValue<RValue>::saved_type SavedAllocSize =
DominatingValue<RValue>::save(CGF, RValue::get(AllocSize));
- struct ConditionalCleanupTraits {
- typedef DominatingValue<RValue>::saved_type ValueTy;
- typedef DominatingValue<RValue>::saved_type RValueTy;
- static RValue get(CodeGenFunction &CGF, ValueTy V) {
- return V.restore(CGF);
- }
- };
- typedef CallDeleteDuringNew<ConditionalCleanupTraits> ConditionalCleanup;
-
- ConditionalCleanup *Cleanup = CGF.EHStack
- .pushCleanupWithExtra<ConditionalCleanup>(EHCleanup,
- E->getNumPlacementArgs(),
- E->getOperatorDelete(),
- SavedNewPtr,
- SavedAllocSize,
- E->passAlignment(),
- AllocAlign);
- for (unsigned I = 0, N = E->getNumPlacementArgs(); I != N; ++I) {
- auto &Arg = NewArgs[I + NumNonPlacementArgs];
- Cleanup->setPlacementArg(I, DominatingValue<RValue>::save(CGF, Arg.RV),
- Arg.Ty);
- }
+ CallDeleteDuringConditionalNew *Cleanup = CGF.EHStack
+ .pushCleanupWithExtra<CallDeleteDuringConditionalNew>(EHCleanup,
+ E->getNumPlacementArgs(),
+ E->getOperatorDelete(),
+ SavedNewPtr,
+ SavedAllocSize);
+ for (unsigned I = 0, N = E->getNumPlacementArgs(); I != N; ++I)
+ Cleanup->setPlacementArg(I,
+ DominatingValue<RValue>::save(CGF, NewArgs[I+1].RV));
CGF.initFullExprCleanup();
}
@@ -1431,7 +1397,6 @@ llvm::Value *CodeGenFunction::EmitCXXNewExpr(const CXXNewExpr *E) {
llvm::Value *allocSize =
EmitCXXNewAllocSize(*this, E, minElements, numElements,
allocSizeWithoutCookie);
- CharUnits allocAlign = getContext().getTypeAlignInChars(allocType);
// Emit the allocation call. If the allocator is a global placement
// operator, just "inline" it directly.
@@ -1447,8 +1412,10 @@ llvm::Value *CodeGenFunction::EmitCXXNewExpr(const CXXNewExpr *E) {
// The pointer expression will, in many cases, be an opaque void*.
// In these cases, discard the computed alignment and use the
// formal alignment of the allocated type.
- if (alignSource != AlignmentSource::Decl)
- allocation = Address(allocation.getPointer(), allocAlign);
+ if (alignSource != AlignmentSource::Decl) {
+ allocation = Address(allocation.getPointer(),
+ getContext().getTypeAlignInChars(allocType));
+ }
// Set up allocatorArgs for the call to operator delete if it's not
// the reserved global operator.
@@ -1461,55 +1428,28 @@ llvm::Value *CodeGenFunction::EmitCXXNewExpr(const CXXNewExpr *E) {
} else {
const FunctionProtoType *allocatorType =
allocator->getType()->castAs<FunctionProtoType>();
- unsigned ParamsToSkip = 0;
// The allocation size is the first argument.
QualType sizeType = getContext().getSizeType();
allocatorArgs.add(RValue::get(allocSize), sizeType);
- ++ParamsToSkip;
-
- if (allocSize != allocSizeWithoutCookie) {
- CharUnits cookieAlign = getSizeAlign(); // FIXME: Ask the ABI.
- allocAlign = std::max(allocAlign, cookieAlign);
- }
-
- // The allocation alignment may be passed as the second argument.
- if (E->passAlignment()) {
- QualType AlignValT = sizeType;
- if (allocatorType->getNumParams() > 1) {
- AlignValT = allocatorType->getParamType(1);
- assert(getContext().hasSameUnqualifiedType(
- AlignValT->castAs<EnumType>()->getDecl()->getIntegerType(),
- sizeType) &&
- "wrong type for alignment parameter");
- ++ParamsToSkip;
- } else {
- // Corner case, passing alignment to 'operator new(size_t, ...)'.
- assert(allocator->isVariadic() && "can't pass alignment to allocator");
- }
- allocatorArgs.add(
- RValue::get(llvm::ConstantInt::get(SizeTy, allocAlign.getQuantity())),
- AlignValT);
- }
- // FIXME: Why do we not pass a CalleeDecl here?
+ // We start at 1 here because the first argument (the allocation size)
+ // has already been emitted.
EmitCallArgs(allocatorArgs, allocatorType, E->placement_arguments(),
- /*CalleeDecl*/nullptr, /*ParamsToSkip*/ParamsToSkip);
+ /* CalleeDecl */ nullptr,
+ /*ParamsToSkip*/ 1);
RValue RV =
EmitNewDeleteCall(*this, allocator, allocatorType, allocatorArgs);
- // If this was a call to a global replaceable allocation function that does
- // not take an alignment argument, the allocator is known to produce
- // storage that's suitably aligned for any object that fits, up to a known
- // threshold. Otherwise assume it's suitably aligned for the allocated type.
- CharUnits allocationAlign = allocAlign;
- if (!E->passAlignment() &&
- allocator->isReplaceableGlobalAllocationFunction()) {
- unsigned AllocatorAlign = llvm::PowerOf2Floor(std::min<uint64_t>(
- Target.getNewAlign(), getContext().getTypeSize(allocType)));
- allocationAlign = std::max(
- allocationAlign, getContext().toCharUnitsFromBits(AllocatorAlign));
+ // For now, only assume that the allocation function returns
+ // something satisfactorily aligned for the element type, plus
+ // the cookie if we have one.
+ CharUnits allocationAlign =
+ getContext().getTypeAlignInChars(allocType);
+ if (allocSize != allocSizeWithoutCookie) {
+ CharUnits cookieAlign = getSizeAlign(); // FIXME?
+ allocationAlign = std::max(allocationAlign, cookieAlign);
}
allocation = Address(RV.getScalarVal(), allocationAlign);
@@ -1548,8 +1488,7 @@ llvm::Value *CodeGenFunction::EmitCXXNewExpr(const CXXNewExpr *E) {
llvm::Instruction *cleanupDominator = nullptr;
if (E->getOperatorDelete() &&
!E->getOperatorDelete()->isReservedGlobalPlacementOperator()) {
- EnterNewDeleteCleanup(*this, E, allocation, allocSize, allocAlign,
- allocatorArgs);
+ EnterNewDeleteCleanup(*this, E, allocation, allocSize, allocatorArgs);
operatorDeleteCleanup = EHStack.stable_begin();
cleanupDominator = Builder.CreateUnreachable();
}
@@ -1611,58 +1550,31 @@ llvm::Value *CodeGenFunction::EmitCXXNewExpr(const CXXNewExpr *E) {
}
void CodeGenFunction::EmitDeleteCall(const FunctionDecl *DeleteFD,
- llvm::Value *Ptr, QualType DeleteTy,
- llvm::Value *NumElements,
- CharUnits CookieSize) {
- assert((!NumElements && CookieSize.isZero()) ||
- DeleteFD->getOverloadedOperator() == OO_Array_Delete);
+ llvm::Value *Ptr,
+ QualType DeleteTy) {
+ assert(DeleteFD->getOverloadedOperator() == OO_Delete);
const FunctionProtoType *DeleteFTy =
DeleteFD->getType()->getAs<FunctionProtoType>();
CallArgList DeleteArgs;
- std::pair<bool, bool> PassSizeAndAlign =
- shouldPassSizeAndAlignToUsualDelete(DeleteFTy);
-
- auto ParamTypeIt = DeleteFTy->param_type_begin();
-
- // Pass the pointer itself.
- QualType ArgTy = *ParamTypeIt++;
- llvm::Value *DeletePtr = Builder.CreateBitCast(Ptr, ConvertType(ArgTy));
- DeleteArgs.add(RValue::get(DeletePtr), ArgTy);
-
- // Pass the size if the delete function has a size_t parameter.
- if (PassSizeAndAlign.first) {
- QualType SizeType = *ParamTypeIt++;
+ // Check if we need to pass the size to the delete operator.
+ llvm::Value *Size = nullptr;
+ QualType SizeTy;
+ if (DeleteFTy->getNumParams() == 2) {
+ SizeTy = DeleteFTy->getParamType(1);
CharUnits DeleteTypeSize = getContext().getTypeSizeInChars(DeleteTy);
- llvm::Value *Size = llvm::ConstantInt::get(ConvertType(SizeType),
- DeleteTypeSize.getQuantity());
-
- // For array new, multiply by the number of elements.
- if (NumElements)
- Size = Builder.CreateMul(Size, NumElements);
-
- // If there is a cookie, add the cookie size.
- if (!CookieSize.isZero())
- Size = Builder.CreateAdd(
- Size, llvm::ConstantInt::get(SizeTy, CookieSize.getQuantity()));
-
- DeleteArgs.add(RValue::get(Size), SizeType);
+ Size = llvm::ConstantInt::get(ConvertType(SizeTy),
+ DeleteTypeSize.getQuantity());
}
- // Pass the alignment if the delete function has an align_val_t parameter.
- if (PassSizeAndAlign.second) {
- QualType AlignValType = *ParamTypeIt++;
- CharUnits DeleteTypeAlign = getContext().toCharUnitsFromBits(
- getContext().getTypeAlignIfKnown(DeleteTy));
- llvm::Value *Align = llvm::ConstantInt::get(ConvertType(AlignValType),
- DeleteTypeAlign.getQuantity());
- DeleteArgs.add(RValue::get(Align), AlignValType);
- }
+ QualType ArgTy = DeleteFTy->getParamType(0);
+ llvm::Value *DeletePtr = Builder.CreateBitCast(Ptr, ConvertType(ArgTy));
+ DeleteArgs.add(RValue::get(DeletePtr), ArgTy);
- assert(ParamTypeIt == DeleteFTy->param_type_end() &&
- "unknown parameter to usual delete function");
+ if (Size)
+ DeleteArgs.add(RValue::get(Size), SizeTy);
// Emit the call to delete.
EmitNewDeleteCall(*this, DeleteFD, DeleteFTy, DeleteArgs);
@@ -1766,8 +1678,45 @@ namespace {
ElementType(ElementType), CookieSize(CookieSize) {}
void Emit(CodeGenFunction &CGF, Flags flags) override {
- CGF.EmitDeleteCall(OperatorDelete, Ptr, ElementType, NumElements,
- CookieSize);
+ const FunctionProtoType *DeleteFTy =
+ OperatorDelete->getType()->getAs<FunctionProtoType>();
+ assert(DeleteFTy->getNumParams() == 1 || DeleteFTy->getNumParams() == 2);
+
+ CallArgList Args;
+
+ // Pass the pointer as the first argument.
+ QualType VoidPtrTy = DeleteFTy->getParamType(0);
+ llvm::Value *DeletePtr
+ = CGF.Builder.CreateBitCast(Ptr, CGF.ConvertType(VoidPtrTy));
+ Args.add(RValue::get(DeletePtr), VoidPtrTy);
+
+ // Pass the original requested size as the second argument.
+ if (DeleteFTy->getNumParams() == 2) {
+ QualType size_t = DeleteFTy->getParamType(1);
+ llvm::IntegerType *SizeTy
+ = cast<llvm::IntegerType>(CGF.ConvertType(size_t));
+
+ CharUnits ElementTypeSize =
+ CGF.CGM.getContext().getTypeSizeInChars(ElementType);
+
+ // The size of an element, multiplied by the number of elements.
+ llvm::Value *Size
+ = llvm::ConstantInt::get(SizeTy, ElementTypeSize.getQuantity());
+ if (NumElements)
+ Size = CGF.Builder.CreateMul(Size, NumElements);
+
+ // Plus the size of the cookie if applicable.
+ if (!CookieSize.isZero()) {
+ llvm::Value *CookieSizeV
+ = llvm::ConstantInt::get(SizeTy, CookieSize.getQuantity());
+ Size = CGF.Builder.CreateAdd(Size, CookieSizeV);
+ }
+
+ Args.add(RValue::get(Size), size_t);
+ }
+
+ // Emit the call to delete.
+ EmitNewDeleteCall(CGF, OperatorDelete, DeleteFTy, Args);
}
};
}
diff --git a/lib/CodeGen/CodeGenFunction.h b/lib/CodeGen/CodeGenFunction.h
index eac759fc8264f605ba6ce9424fafa8e303fc5e54..4e149e65dcda397d33556efda8752cb31303d32a 100644
--- a/lib/CodeGen/CodeGenFunction.h
+++ b/lib/CodeGen/CodeGenFunction.h
@@ -2033,8 +2033,7 @@ public:
void EmitCXXDeleteExpr(const CXXDeleteExpr *E);
void EmitDeleteCall(const FunctionDecl *DeleteFD, llvm::Value *Ptr,
- QualType DeleteTy, llvm::Value *NumElements = nullptr,
- CharUnits CookieSize = CharUnits());
+ QualType DeleteTy);
RValue EmitBuiltinNewDeleteCall(const FunctionProtoType *Type,
const Expr *Arg, bool IsDelete);
diff --git a/lib/Sema/SemaCUDA.cpp b/lib/Sema/SemaCUDA.cpp
index 827eb02bcd65a87f3cf404ca3274669c3f1a593b..d6c0606674ea61bae349ce3150e0fa0828634def 100644
--- a/lib/Sema/SemaCUDA.cpp
+++ b/lib/Sema/SemaCUDA.cpp
@@ -158,34 +158,6 @@ Sema::IdentifyCUDAPreference(const FunctionDecl *Caller,
llvm_unreachable("All cases should've been handled by now.");
}
-void Sema::EraseUnwantedCUDAMatches(const FunctionDecl *Caller,
- LookupResult &R) {
- if (R.isSingleResult())
- return;
-
- // Gets the CUDA function preference for a call from Caller to Match.
- auto GetCFP = [&](const NamedDecl *D) {
- if (auto *Callee = dyn_cast<FunctionDecl>(D->getUnderlyingDecl()))
- return IdentifyCUDAPreference(Caller, Callee);
- return CFP_Never;
- };
-
- // Find the best call preference among the functions in R.
- CUDAFunctionPreference BestCFP = GetCFP(*std::max_element(
- R.begin(), R.end(), [&](const NamedDecl *D1, const NamedDecl *D2) {
- return GetCFP(D1) < GetCFP(D2);
- }));
-
- // Erase all functions with lower priority.
- auto Filter = R.makeFilter();
- while (Filter.hasNext()) {
- auto *Callee = dyn_cast<FunctionDecl>(Filter.next()->getUnderlyingDecl());
- if (Callee && GetCFP(Callee) < BestCFP)
- Filter.erase();
- }
- Filter.done();
-}
-
template <typename T>
static void EraseUnwantedCUDAMatchesImpl(
Sema &S, const FunctionDecl *Caller, llvm::SmallVectorImpl<T> &Matches,
diff --git a/lib/Sema/SemaDecl.cpp b/lib/Sema/SemaDecl.cpp
index 7baa85a6464cab467631fd1dc6f04df2be2ceeb0..32201c99d3df552587c6d94bd0ceef905b169005 100644
--- a/lib/Sema/SemaDecl.cpp
+++ b/lib/Sema/SemaDecl.cpp
@@ -14368,14 +14368,6 @@ void Sema::ActOnFields(Scope *S, SourceLocation RecLoc, Decl *EnclosingDecl,
if (!Completed)
Record->completeDefinition();
- // We may have deferred checking for a deleted destructor. Check now.
- if (CXXRecordDecl *CXXRecord = dyn_cast<CXXRecordDecl>(Record)) {
- auto *Dtor = CXXRecord->getDestructor();
- if (Dtor && Dtor->isImplicit() &&
- ShouldDeleteSpecialMember(Dtor, CXXDestructor))
- SetDeclDeleted(Dtor, CXXRecord->getLocation());
- }
-
if (Record->hasAttrs()) {
CheckAlignasUnderalignment(Record);
diff --git a/lib/Sema/SemaDeclCXX.cpp b/lib/Sema/SemaDeclCXX.cpp
index 36a0338d4aec09140e0bc5fc427cc25c69acb53f..0f7f0ffa75afa09a8b03f4dad69862c4950c1194 100644
--- a/lib/Sema/SemaDeclCXX.cpp
+++ b/lib/Sema/SemaDeclCXX.cpp
@@ -6755,7 +6755,7 @@ bool Sema::ShouldDeleteSpecialMember(CXXMethodDecl *MD, CXXSpecialMember CSM,
DeclarationName Name =
Context.DeclarationNames.getCXXOperatorName(OO_Delete);
if (FindDeallocationFunction(MD->getLocation(), MD->getParent(), Name,
- OperatorDelete, /*Diagnose*/false)) {
+ OperatorDelete, false)) {
if (Diagnose)
Diag(RD->getLocation(), diag::note_deleted_dtor_no_operator_delete);
return true;
@@ -7695,11 +7695,19 @@ bool Sema::CheckDestructor(CXXDestructorDecl *Destructor) {
Loc = RD->getLocation();
// If we have a virtual destructor, look up the deallocation function
- if (FunctionDecl *OperatorDelete =
- FindDeallocationFunctionForDestructor(Loc, RD)) {
- MarkFunctionReferenced(Loc, OperatorDelete);
- Destructor->setOperatorDelete(OperatorDelete);
- }
+ FunctionDecl *OperatorDelete = nullptr;
+ DeclarationName Name =
+ Context.DeclarationNames.getCXXOperatorName(OO_Delete);
+ if (FindDeallocationFunction(Loc, RD, Name, OperatorDelete))
+ return true;
+ // If there's no class-specific operator delete, look up the global
+ // non-array delete.
+ if (!OperatorDelete)
+ OperatorDelete = FindUsualDeallocationFunction(Loc, true, Name);
+
+ MarkFunctionReferenced(Loc, OperatorDelete);
+
+ Destructor->setOperatorDelete(OperatorDelete);
}
return false;
@@ -10272,11 +10280,7 @@ CXXDestructorDecl *Sema::DeclareImplicitDestructor(CXXRecordDecl *ClassDecl) {
Scope *S = getScopeForContext(ClassDecl);
CheckImplicitSpecialMemberDeclaration(S, Destructor);
- // We can't check whether an implicit destructor is deleted before we complete
- // the definition of the class, because its validity depends on the alignment
- // of the class. We'll check this from ActOnFields once the class is complete.
- if (ClassDecl->isCompleteDefinition() &&
- ShouldDeleteSpecialMember(Destructor, CXXDestructor))
+ if (ShouldDeleteSpecialMember(Destructor, CXXDestructor))
SetDeclDeleted(Destructor, ClassLoc);
// Introduce this destructor into its scope.
diff --git a/lib/Sema/SemaExprCXX.cpp b/lib/Sema/SemaExprCXX.cpp
index 9c5dba5a38a1c272ec4d67f46546158b4171eac8..ad102f8d203211b55a267969247762d9758677b6 100644
--- a/lib/Sema/SemaExprCXX.cpp
+++ b/lib/Sema/SemaExprCXX.cpp
@@ -1321,126 +1321,8 @@ Sema::BuildCXXTypeConstructExpr(TypeSourceInfo *TInfo,
return Result;
}
-/// \brief Determine whether the given function is a non-placement
-/// deallocation function.
-static bool isNonPlacementDeallocationFunction(Sema &S, FunctionDecl *FD) {
- if (FD->isInvalidDecl())
- return false;
-
- if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(FD))
- return Method->isUsualDeallocationFunction();
-
- if (FD->getOverloadedOperator() != OO_Delete &&
- FD->getOverloadedOperator() != OO_Array_Delete)
- return false;
-
- unsigned UsualParams = 1;
-
- if (S.getLangOpts().SizedDeallocation && UsualParams < FD->getNumParams() &&
- S.Context.hasSameUnqualifiedType(
- FD->getParamDecl(UsualParams)->getType(),
- S.Context.getSizeType()))
- ++UsualParams;
-
- if (S.getLangOpts().AlignedAllocation && UsualParams < FD->getNumParams() &&
- S.Context.hasSameUnqualifiedType(
- FD->getParamDecl(UsualParams)->getType(),
- S.Context.getTypeDeclType(S.getStdAlignValT())))
- ++UsualParams;
-
- return UsualParams == FD->getNumParams();
-}
-
-namespace {
- struct UsualDeallocFnInfo {
- UsualDeallocFnInfo() : Found(), FD(nullptr) {}
- UsualDeallocFnInfo(DeclAccessPair Found)
- : Found(Found), FD(dyn_cast<FunctionDecl>(Found->getUnderlyingDecl())),
- HasSizeT(false), HasAlignValT(false) {
- // A function template declaration is never a usual deallocation function.
- if (!FD)
- return;
- if (FD->getNumParams() == 3)
- HasAlignValT = HasSizeT = true;
- else if (FD->getNumParams() == 2) {
- HasSizeT = FD->getParamDecl(1)->getType()->isIntegerType();
- HasAlignValT = !HasSizeT;
- }
- }
-
- operator bool() const { return FD; }
-
- DeclAccessPair Found;
- FunctionDecl *FD;
- bool HasSizeT, HasAlignValT;
- };
-}
-
-/// Determine whether a type has new-extended alignment. This may be called when
-/// the type is incomplete (for a delete-expression with an incomplete pointee
-/// type), in which case it will conservatively return false if the alignment is
-/// not known.
-static bool hasNewExtendedAlignment(Sema &S, QualType AllocType) {
- return S.getLangOpts().AlignedAllocation &&
- S.getASTContext().getTypeAlignIfKnown(AllocType) >
- S.getASTContext().getTargetInfo().getNewAlign();
-}
-
-/// Select the correct "usual" deallocation function to use from a selection of
-/// deallocation functions (either global or class-scope).
-static UsualDeallocFnInfo resolveDeallocationOverload(
- Sema &S, LookupResult &R, bool WantSize, bool WantAlign,
- llvm::SmallVectorImpl<UsualDeallocFnInfo> *BestFns = nullptr) {
- UsualDeallocFnInfo Best;
-
- // For CUDA, rank callability above anything else when ordering usual
- // deallocation functions.
- // FIXME: We should probably instead rank this between alignment (which
- // affects correctness) and size (which is just an optimization).
- if (S.getLangOpts().CUDA)
- S.EraseUnwantedCUDAMatches(dyn_cast<FunctionDecl>(S.CurContext), R);
-
- for (auto I = R.begin(), E = R.end(); I != E; ++I) {
- UsualDeallocFnInfo Info(I.getPair());
- if (!Info || !isNonPlacementDeallocationFunction(S, Info.FD))
- continue;
-
- if (!Best) {
- Best = Info;
- if (BestFns)
- BestFns->push_back(Info);
- continue;
- }
-
- // C++17 [expr.delete]p10:
- // If the type has new-extended alignment, a function with a parameter of
- // type std::align_val_t is preferred; otherwise a function without such a
- // parameter is preferred
- if (Best.HasAlignValT == WantAlign && Info.HasAlignValT != WantAlign)
- continue;
-
- if (Best.HasAlignValT == Info.HasAlignValT &&
- Best.HasSizeT == WantSize && Info.HasSizeT != WantSize)
- continue;
-
- // If more than one preferred function is found, all non-preferred
- // functions are eliminated from further consideration.
- if (BestFns && (Best.HasAlignValT != Info.HasAlignValT ||
- Best.HasSizeT != Info.HasSizeT))
- BestFns->clear();
-
- Best = Info;
- if (BestFns)
- BestFns->push_back(Info);
- }
-
- return Best;
-}
-
-/// Determine whether a given type is a class for which 'delete[]' would call
-/// a member 'operator delete[]' with a 'size_t' parameter. This implies that
-/// we need to store the array size (even if the type is
-/// trivially-destructible).
+/// doesUsualArrayDeleteWantSize - Answers whether the usual
+/// operator delete[] for the given type has a size_t parameter.
static bool doesUsualArrayDeleteWantSize(Sema &S, SourceLocation loc,
QualType allocType) {
const RecordType *record =
@@ -1464,13 +1346,35 @@ static bool doesUsualArrayDeleteWantSize(Sema &S, SourceLocation loc,
// on this thing, so it doesn't matter if we allocate extra space or not.
if (ops.isAmbiguous()) return false;
- // C++17 [expr.delete]p10:
- // If the deallocation functions have class scope, the one without a
- // parameter of type std::size_t is selected.
- auto Best = resolveDeallocationOverload(
- S, ops, /*WantSize*/false,
- /*WantAlign*/hasNewExtendedAlignment(S, allocType));
- return Best && Best.HasSizeT;
+ LookupResult::Filter filter = ops.makeFilter();
+ while (filter.hasNext()) {
+ NamedDecl *del = filter.next()->getUnderlyingDecl();
+
+ // C++0x [basic.stc.dynamic.deallocation]p2:
+ // A template instance is never a usual deallocation function,
+ // regardless of its signature.
+ if (isa<FunctionTemplateDecl>(del)) {
+ filter.erase();
+ continue;
+ }
+
+ // C++0x [basic.stc.dynamic.deallocation]p2:
+ // If class T does not declare [an operator delete[] with one
+ // parameter] but does declare a member deallocation function
+ // named operator delete[] with exactly two parameters, the
+ // second of which has type std::size_t, then this function
+ // is a usual deallocation function.
+ if (!cast<CXXMethodDecl>(del)->isUsualDeallocationFunction()) {
+ filter.erase();
+ continue;
+ }
+ }
+ filter.done();
+
+ if (!ops.isSingleResult()) return false;
+
+ const FunctionDecl *del = cast<FunctionDecl>(ops.getFoundDecl());
+ return (del->getNumParams() == 2);
}
/// \brief Parsed a C++ 'new' expression (C++ 5.3.4).
@@ -1826,26 +1730,21 @@ Sema::BuildCXXNew(SourceRange Range, bool UseGlobal,
FunctionDecl *OperatorNew = nullptr;
FunctionDecl *OperatorDelete = nullptr;
- unsigned Alignment =
- AllocType->isDependentType() ? 0 : Context.getTypeAlign(AllocType);
- unsigned NewAlignment = Context.getTargetInfo().getNewAlign();
- bool PassAlignment = getLangOpts().AlignedAllocation &&
- Alignment > NewAlignment;
if (!AllocType->isDependentType() &&
!Expr::hasAnyTypeDependentArguments(PlacementArgs) &&
FindAllocationFunctions(StartLoc,
SourceRange(PlacementLParen, PlacementRParen),
- UseGlobal, AllocType, ArraySize, PassAlignment,
- PlacementArgs, OperatorNew, OperatorDelete))
+ UseGlobal, AllocType, ArraySize, PlacementArgs,
+ OperatorNew, OperatorDelete))
return ExprError();
// If this is an array allocation, compute whether the usual array
// deallocation function for the type has a size_t parameter.
bool UsualArrayDeleteWantsSize = false;
if (ArraySize && !AllocType->isDependentType())
- UsualArrayDeleteWantsSize =
- doesUsualArrayDeleteWantSize(*this, StartLoc, AllocType);
+ UsualArrayDeleteWantsSize
+ = doesUsualArrayDeleteWantSize(*this, StartLoc, AllocType);
SmallVector<Expr *, 8> AllPlaceArgs;
if (OperatorNew) {
@@ -1856,11 +1755,9 @@ Sema::BuildCXXNew(SourceRange Range, bool UseGlobal,
// We've already converted the placement args, just fill in any default
// arguments. Skip the first parameter because we don't have a corresponding
- // argument. Skip the second parameter too if we're passing in the
- // alignment; we've already filled it in.
- if (GatherArgumentsForCall(PlacementLParen, OperatorNew, Proto,
- PassAlignment ? 2 : 1, PlacementArgs,
- AllPlaceArgs, CallType))
+ // argument.
+ if (GatherArgumentsForCall(PlacementLParen, OperatorNew, Proto, 1,
+ PlacementArgs, AllPlaceArgs, CallType))
return ExprError();
if (!AllPlaceArgs.empty())
@@ -1870,18 +1767,21 @@ Sema::BuildCXXNew(SourceRange Range, bool UseGlobal,
DiagnoseSentinelCalls(OperatorNew, PlacementLParen, PlacementArgs);
// FIXME: Missing call to CheckFunctionCall or equivalent
+ }
- // Warn if the type is over-aligned and is being allocated by (unaligned)
- // global operator new.
- if (PlacementArgs.empty() && !PassAlignment &&
- (OperatorNew->isImplicit() ||
- (OperatorNew->getLocStart().isValid() &&
- getSourceManager().isInSystemHeader(OperatorNew->getLocStart())))) {
- if (Alignment > NewAlignment)
+ // Warn if the type is over-aligned and is being allocated by global operator
+ // new.
+ if (PlacementArgs.empty() && OperatorNew &&
+ (OperatorNew->isImplicit() ||
+ (OperatorNew->getLocStart().isValid() &&
+ getSourceManager().isInSystemHeader(OperatorNew->getLocStart())))) {
+ if (unsigned Align = Context.getPreferredTypeAlign(AllocType.getTypePtr())){
+ unsigned SuitableAlign = Context.getTargetInfo().getSuitableAlign();
+ if (Align > SuitableAlign)
Diag(StartLoc, diag::warn_overaligned_type)
<< AllocType
- << unsigned(Alignment / Context.getCharWidth())
- << unsigned(NewAlignment / Context.getCharWidth());
+ << unsigned(Align / Context.getCharWidth())
+ << unsigned(SuitableAlign / Context.getCharWidth());
}
}
@@ -1980,7 +1880,7 @@ Sema::BuildCXXNew(SourceRange Range, bool UseGlobal,
}
return new (Context)
- CXXNewExpr(Context, UseGlobal, OperatorNew, OperatorDelete, PassAlignment,
+ CXXNewExpr(Context, UseGlobal, OperatorNew, OperatorDelete,
UsualArrayDeleteWantsSize, PlacementArgs, TypeIdParens,
ArraySize, initStyle, Initializer, ResultType, AllocTypeInfo,
Range, DirectInitRange);
@@ -2023,128 +1923,32 @@ bool Sema::CheckAllocatedType(QualType AllocType, SourceLocation Loc,
return false;
}
-static bool
-resolveAllocationOverload(Sema &S, LookupResult &R, SourceRange Range,
- SmallVectorImpl<Expr *> &Args, bool &PassAlignment,
- FunctionDecl *&Operator,
- OverloadCandidateSet *AlignedCandidates = nullptr,
- Expr *AlignArg = nullptr) {
- OverloadCandidateSet Candidates(R.getNameLoc(),
- OverloadCandidateSet::CSK_Normal);
- for (LookupResult::iterator Alloc = R.begin(), AllocEnd = R.end();
- Alloc != AllocEnd; ++Alloc) {
- // Even member operator new/delete are implicitly treated as
- // static, so don't use AddMemberCandidate.
- NamedDecl *D = (*Alloc)->getUnderlyingDecl();
-
- if (FunctionTemplateDecl *FnTemplate = dyn_cast<FunctionTemplateDecl>(D)) {
- S.AddTemplateOverloadCandidate(FnTemplate, Alloc.getPair(),
- /*ExplicitTemplateArgs=*/nullptr, Args,
- Candidates,
- /*SuppressUserConversions=*/false);
- continue;
- }
-
- FunctionDecl *Fn = cast<FunctionDecl>(D);
- S.AddOverloadCandidate(Fn, Alloc.getPair(), Args, Candidates,
- /*SuppressUserConversions=*/false);
- }
-
- // Do the resolution.
- OverloadCandidateSet::iterator Best;
- switch (Candidates.BestViableFunction(S, R.getNameLoc(), Best)) {
- case OR_Success: {
- // Got one!
- FunctionDecl *FnDecl = Best->Function;
- if (S.CheckAllocationAccess(R.getNameLoc(), Range, R.getNamingClass(),
- Best->FoundDecl) == Sema::AR_inaccessible)
- return true;
-
- Operator = FnDecl;
+/// \brief Determine whether the given function is a non-placement
+/// deallocation function.
+static bool isNonPlacementDeallocationFunction(Sema &S, FunctionDecl *FD) {
+ if (FD->isInvalidDecl())
return false;
- }
- case OR_No_Viable_Function:
- // C++17 [expr.new]p13:
- // If no matching function is found and the allocated object type has
- // new-extended alignment, the alignment argument is removed from the
- // argument list, and overload resolution is performed again.
- if (PassAlignment) {
- PassAlignment = false;
- AlignArg = Args[1];
- Args.erase(Args.begin() + 1);
- return resolveAllocationOverload(S, R, Range, Args, PassAlignment,
- Operator, &Candidates, AlignArg);
- }
-
- // MSVC will fall back on trying to find a matching global operator new
- // if operator new[] cannot be found. Also, MSVC will leak by not
- // generating a call to operator delete or operator delete[], but we
- // will not replicate that bug.
- // FIXME: Find out how this interacts with the std::align_val_t fallback
- // once MSVC implements it.
- if (R.getLookupName().getCXXOverloadedOperator() == OO_Array_New &&
- S.Context.getLangOpts().MSVCCompat) {
- R.clear();
- R.setLookupName(S.Context.DeclarationNames.getCXXOperatorName(OO_New));
- S.LookupQualifiedName(R, S.Context.getTranslationUnitDecl());
- // FIXME: This will give bad diagnostics pointing at the wrong functions.
- return resolveAllocationOverload(S, R, Range, Args, PassAlignment,
- Operator, nullptr);
- }
+ if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(FD))
+ return Method->isUsualDeallocationFunction();
- S.Diag(R.getNameLoc(), diag::err_ovl_no_viable_function_in_call)
- << R.getLookupName() << Range;
-
- // If we have aligned candidates, only note the align_val_t candidates
- // from AlignedCandidates and the non-align_val_t candidates from
- // Candidates.
- if (AlignedCandidates) {
- auto IsAligned = [](OverloadCandidate &C) {
- return C.Function->getNumParams() > 1 &&
- C.Function->getParamDecl(1)->getType()->isAlignValT();
- };
- auto IsUnaligned = [&](OverloadCandidate &C) { return !IsAligned(C); };
-
- // This was an overaligned allocation, so list the aligned candidates
- // first.
- Args.insert(Args.begin() + 1, AlignArg);
- AlignedCandidates->NoteCandidates(S, OCD_AllCandidates, Args, "",
- R.getNameLoc(), IsAligned);
- Args.erase(Args.begin() + 1);
- Candidates.NoteCandidates(S, OCD_AllCandidates, Args, "", R.getNameLoc(),
- IsUnaligned);
- } else {
- Candidates.NoteCandidates(S, OCD_AllCandidates, Args);
- }
- return true;
+ if (FD->getOverloadedOperator() != OO_Delete &&
+ FD->getOverloadedOperator() != OO_Array_Delete)
+ return false;
- case OR_Ambiguous:
- S.Diag(R.getNameLoc(), diag::err_ovl_ambiguous_call)
- << R.getLookupName() << Range;
- Candidates.NoteCandidates(S, OCD_ViableCandidates, Args);
+ if (FD->getNumParams() == 1)
return true;
- case OR_Deleted: {
- S.Diag(R.getNameLoc(), diag::err_ovl_deleted_call)
- << Best->Function->isDeleted()
- << R.getLookupName()
- << S.getDeletedOrUnavailableSuffix(Best->Function)
- << Range;
- Candidates.NoteCandidates(S, OCD_AllCandidates, Args);
- return true;
- }
- }
- llvm_unreachable("Unreachable, bad result from BestViableFunction");
+ return S.getLangOpts().SizedDeallocation && FD->getNumParams() == 2 &&
+ S.Context.hasSameUnqualifiedType(FD->getParamDecl(1)->getType(),
+ S.Context.getSizeType());
}
-
/// FindAllocationFunctions - Finds the overloads of operator new and delete
/// that are appropriate for the allocation.
bool Sema::FindAllocationFunctions(SourceLocation StartLoc, SourceRange Range,
bool UseGlobal, QualType AllocType,
- bool IsArray, bool &PassAlignment,
- MultiExprArg PlaceArgs,
+ bool IsArray, MultiExprArg PlaceArgs,
FunctionDecl *&OperatorNew,
FunctionDecl *&OperatorDelete) {
// --- Choosing an allocation function ---
@@ -2156,29 +1960,16 @@ bool Sema::FindAllocationFunctions(SourceLocation StartLoc, SourceRange Range,
// 3) The first argument is always size_t. Append the arguments from the
// placement form.
- SmallVector<Expr*, 8> AllocArgs;
- AllocArgs.reserve((PassAlignment ? 2 : 1) + PlaceArgs.size());
-
- // We don't care about the actual value of these arguments.
+ SmallVector<Expr*, 8> AllocArgs(1 + PlaceArgs.size());
+ // We don't care about the actual value of this argument.
// FIXME: Should the Sema create the expression and embed it in the syntax
// tree? Or should the consumer just recalculate the value?
- // FIXME: Using a dummy value will interact poorly with attribute enable_if.
IntegerLiteral Size(Context, llvm::APInt::getNullValue(
Context.getTargetInfo().getPointerWidth(0)),
Context.getSizeType(),
SourceLocation());
- AllocArgs.push_back(&Size);
-
- QualType AlignValT = Context.VoidTy;
- if (PassAlignment) {
- DeclareGlobalNewDelete();
- AlignValT = Context.getTypeDeclType(getStdAlignValT());
- }
- CXXScalarValueInitExpr Align(AlignValT, nullptr, SourceLocation());
- if (PassAlignment)
- AllocArgs.push_back(&Align);
-
- AllocArgs.insert(AllocArgs.end(), PlaceArgs.begin(), PlaceArgs.end());
+ AllocArgs[0] = &Size;
+ std::copy(PlaceArgs.begin(), PlaceArgs.end(), AllocArgs.begin() + 1);
// C++ [expr.new]p8:
// If the allocated type is a non-array type, the allocation
@@ -2187,57 +1978,50 @@ bool Sema::FindAllocationFunctions(SourceLocation StartLoc, SourceRange Range,
// type, the allocation function's name is operator new[] and the
// deallocation function's name is operator delete[].
DeclarationName NewName = Context.DeclarationNames.getCXXOperatorName(
- IsArray ? OO_Array_New : OO_New);
+ IsArray ? OO_Array_New : OO_New);
+ DeclarationName DeleteName = Context.DeclarationNames.getCXXOperatorName(
+ IsArray ? OO_Array_Delete : OO_Delete);
QualType AllocElemType = Context.getBaseElementType(AllocType);
- // Find the allocation function.
- {
- LookupResult R(*this, NewName, StartLoc, LookupOrdinaryName);
-
- // C++1z [expr.new]p9:
- // If the new-expression begins with a unary :: operator, the allocation
- // function's name is looked up in the global scope. Otherwise, if the
- // allocated type is a class type T or array thereof, the allocation
- // function's name is looked up in the scope of T.
- if (AllocElemType->isRecordType() && !UseGlobal)
- LookupQualifiedName(R, AllocElemType->getAsCXXRecordDecl());
-
- // We can see ambiguity here if the allocation function is found in
- // multiple base classes.
- if (R.isAmbiguous())
+ if (AllocElemType->isRecordType() && !UseGlobal) {
+ CXXRecordDecl *Record
+ = cast<CXXRecordDecl>(AllocElemType->getAs<RecordType>()->getDecl());
+ if (FindAllocationOverload(StartLoc, Range, NewName, AllocArgs, Record,
+ /*AllowMissing=*/true, OperatorNew))
return true;
+ }
- // If this lookup fails to find the name, or if the allocated type is not
- // a class type, the allocation function's name is looked up in the
- // global scope.
- if (R.empty())
- LookupQualifiedName(R, Context.getTranslationUnitDecl());
-
- assert(!R.empty() && "implicitly declared allocation functions not found");
- assert(!R.isAmbiguous() && "global allocation functions are ambiguous");
-
- // We do our own custom access checks below.
- R.suppressDiagnostics();
+ if (!OperatorNew) {
+ // Didn't find a member overload. Look for a global one.
+ DeclareGlobalNewDelete();
+ DeclContext *TUDecl = Context.getTranslationUnitDecl();
+ bool FallbackEnabled = IsArray && Context.getLangOpts().MSVCCompat;
+ if (FindAllocationOverload(StartLoc, Range, NewName, AllocArgs, TUDecl,
+ /*AllowMissing=*/FallbackEnabled, OperatorNew,
+ /*Diagnose=*/!FallbackEnabled)) {
+ if (!FallbackEnabled)
+ return true;
- if (resolveAllocationOverload(*this, R, Range, AllocArgs, PassAlignment,
- OperatorNew))
+ // MSVC will fall back on trying to find a matching global operator new
+ // if operator new[] cannot be found. Also, MSVC will leak by not
+ // generating a call to operator delete or operator delete[], but we
+ // will not replicate that bug.
+ NewName = Context.DeclarationNames.getCXXOperatorName(OO_New);
+ DeleteName = Context.DeclarationNames.getCXXOperatorName(OO_Delete);
+ if (FindAllocationOverload(StartLoc, Range, NewName, AllocArgs, TUDecl,
+ /*AllowMissing=*/false, OperatorNew))
return true;
+ }
}
- // We don't need an operator delete if we're running under -fno-exceptions.
+ // We don't need an operator delete if we're running under
+ // -fno-exceptions.
if (!getLangOpts().Exceptions) {
OperatorDelete = nullptr;
return false;
}
- // Note, the name of OperatorNew might have been changed from array to
- // non-array by resolveAllocationOverload.
- DeclarationName DeleteName = Context.DeclarationNames.getCXXOperatorName(
- OperatorNew->getDeclName().getCXXOverloadedOperator() == OO_Array_New
- ? OO_Array_Delete
- : OO_Delete);
-
// C++ [expr.new]p19:
//
// If the new-expression begins with a unary :: operator, the
@@ -2256,7 +2040,6 @@ bool Sema::FindAllocationFunctions(SourceLocation StartLoc, SourceRange Range,
if (FoundDelete.isAmbiguous())
return true; // FIXME: clean up expressions?
- bool FoundGlobalDelete = FoundDelete.empty();
if (FoundDelete.empty()) {
DeclareGlobalNewDelete();
LookupQualifiedName(FoundDelete, Context.getTranslationUnitDecl());
@@ -2271,16 +2054,7 @@ bool Sema::FindAllocationFunctions(SourceLocation StartLoc, SourceRange Range,
// we had explicit placement arguments. This matters for things like
// struct A { void *operator new(size_t, int = 0); ... };
// A *a = new A()
- //
- // We don't have any definition for what a "placement allocation function"
- // is, but we assume it's any allocation function whose
- // parameter-declaration-clause is anything other than (size_t).
- //
- // FIXME: Should (size_t, std::align_val_t) also be considered non-placement?
- // This affects whether an exception from the constructor of an overaligned
- // type uses the sized or non-sized form of aligned operator delete.
- bool isPlacementNew = !PlaceArgs.empty() || OperatorNew->param_size() != 1 ||
- OperatorNew->isVariadic();
+ bool isPlacementNew = (!PlaceArgs.empty() || OperatorNew->param_size() != 1);
if (isPlacementNew) {
// C++ [expr.new]p20:
@@ -2306,9 +2080,7 @@ bool Sema::FindAllocationFunctions(SourceLocation StartLoc, SourceRange Range,
ArgTypes.push_back(Proto->getParamType(I));
FunctionProtoType::ExtProtoInfo EPI;
- // FIXME: This is not part of the standard's rule.
EPI.Variadic = Proto->isVariadic();
- EPI.ExceptionSpec.Type = EST_BasicNoexcept;
ExpectedFunctionType
= Context.getFunctionType(Context.VoidTy, ArgTypes, EPI);
@@ -2332,29 +2104,35 @@ bool Sema::FindAllocationFunctions(SourceLocation StartLoc, SourceRange Range,
if (Context.hasSameType(Fn->getType(), ExpectedFunctionType))
Matches.push_back(std::make_pair(D.getPair(), Fn));
}
-
- if (getLangOpts().CUDA)
- EraseUnwantedCUDAMatches(dyn_cast<FunctionDecl>(CurContext), Matches);
} else {
+ // C++ [expr.new]p20:
+ // [...] Any non-placement deallocation function matches a
+ // non-placement allocation function. [...]
+ for (LookupResult::iterator D = FoundDelete.begin(),
+ DEnd = FoundDelete.end();
+ D != DEnd; ++D) {
+ if (FunctionDecl *Fn = dyn_cast<FunctionDecl>((*D)->getUnderlyingDecl()))
+ if (isNonPlacementDeallocationFunction(*this, Fn))
+ Matches.push_back(std::make_pair(D.getPair(), Fn));
+ }
+
// C++1y [expr.new]p22:
// For a non-placement allocation function, the normal deallocation
// function lookup is used
- //
- // Per [expr.delete]p10, this lookup prefers a member operator delete
- // without a size_t argument, but prefers a non-member operator delete
- // with a size_t where possible (which it always is in this case).
- llvm::SmallVector<UsualDeallocFnInfo, 4> BestDeallocFns;
- UsualDeallocFnInfo Selected = resolveDeallocationOverload(
- *this, FoundDelete, /*WantSize*/ FoundGlobalDelete,
- /*WantAlign*/ hasNewExtendedAlignment(*this, AllocElemType),
- &BestDeallocFns);
- if (Selected)
- Matches.push_back(std::make_pair(Selected.Found, Selected.FD));
- else {
- // If we failed to select an operator, all remaining functions are viable
- // but ambiguous.
- for (auto Fn : BestDeallocFns)
- Matches.push_back(std::make_pair(Fn.Found, Fn.FD));
+ // C++1y [expr.delete]p?:
+ // If [...] deallocation function lookup finds both a usual deallocation
+ // function with only a pointer parameter and a usual deallocation
+ // function with both a pointer parameter and a size parameter, then the
+ // selected deallocation function shall be the one with two parameters.
+ // Otherwise, the selected deallocation function shall be the function
+ // with one parameter.
+ if (getLangOpts().SizedDeallocation && Matches.size() == 2) {
+ if (Matches[0].second->getNumParams() == 1)
+ Matches.erase(Matches.begin());
+ else
+ Matches.erase(Matches.begin() + 1);
+ assert(Matches[0].second->getNumParams() == 2 &&
+ "found an unexpected usual deallocation function");
}
}
@@ -2365,58 +2143,130 @@ bool Sema::FindAllocationFunctions(SourceLocation StartLoc, SourceRange Range,
if (Matches.size() == 1) {
OperatorDelete = Matches[0].second;
- // C++1z [expr.new]p23:
- // If the lookup finds a usual deallocation function (3.7.4.2)
- // with a parameter of type std::size_t and that function, considered
+ // C++0x [expr.new]p20:
+ // If the lookup finds the two-parameter form of a usual
+ // deallocation function (3.7.4.2) and that function, considered
// as a placement deallocation function, would have been
// selected as a match for the allocation function, the program
// is ill-formed.
- if (getLangOpts().CPlusPlus11 && isPlacementNew &&
+ if (!PlaceArgs.empty() && getLangOpts().CPlusPlus11 &&
isNonPlacementDeallocationFunction(*this, OperatorDelete)) {
- UsualDeallocFnInfo Info(DeclAccessPair::make(OperatorDelete, AS_public));
- // Core issue, per mail to core reflector, 2016-10-09:
- // If this is a member operator delete, and there is a corresponding
- // non-sized member operator delete, this isn't /really/ a sized
- // deallocation function, it just happens to have a size_t parameter.
- bool IsSizedDelete = Info.HasSizeT;
- if (IsSizedDelete && !FoundGlobalDelete) {
- auto NonSizedDelete =
- resolveDeallocationOverload(*this, FoundDelete, /*WantSize*/false,
- /*WantAlign*/Info.HasAlignValT);
- if (NonSizedDelete && !NonSizedDelete.HasSizeT &&
- NonSizedDelete.HasAlignValT == Info.HasAlignValT)
- IsSizedDelete = false;
- }
+ Diag(StartLoc, diag::err_placement_new_non_placement_delete)
+ << SourceRange(PlaceArgs.front()->getLocStart(),
+ PlaceArgs.back()->getLocEnd());
+ if (!OperatorDelete->isImplicit())
+ Diag(OperatorDelete->getLocation(), diag::note_previous_decl)
+ << DeleteName;
+ } else {
+ CheckAllocationAccess(StartLoc, Range, FoundDelete.getNamingClass(),
+ Matches[0].first);
+ }
+ }
- if (IsSizedDelete) {
- SourceRange R = PlaceArgs.empty()
- ? SourceRange()
- : SourceRange(PlaceArgs.front()->getLocStart(),
- PlaceArgs.back()->getLocEnd());
- Diag(StartLoc, diag::err_placement_new_non_placement_delete) << R;
- if (!OperatorDelete->isImplicit())
- Diag(OperatorDelete->getLocation(), diag::note_previous_decl)
- << DeleteName;
- }
+ return false;
+}
+
+/// \brief Find an fitting overload for the allocation function
+/// in the specified scope.
+///
+/// \param StartLoc The location of the 'new' token.
+/// \param Range The range of the placement arguments.
+/// \param Name The name of the function ('operator new' or 'operator new[]').
+/// \param Args The placement arguments specified.
+/// \param Ctx The scope in which we should search; either a class scope or the
+/// translation unit.
+/// \param AllowMissing If \c true, report an error if we can't find any
+/// allocation functions. Otherwise, succeed but don't fill in \p
+/// Operator.
+/// \param Operator Filled in with the found allocation function. Unchanged if
+/// no allocation function was found.
+/// \param Diagnose If \c true, issue errors if the allocation function is not
+/// usable.
+bool Sema::FindAllocationOverload(SourceLocation StartLoc, SourceRange Range,
+ DeclarationName Name, MultiExprArg Args,
+ DeclContext *Ctx,
+ bool AllowMissing, FunctionDecl *&Operator,
+ bool Diagnose) {
+ LookupResult R(*this, Name, StartLoc, LookupOrdinaryName);
+ LookupQualifiedName(R, Ctx);
+ if (R.empty()) {
+ if (AllowMissing || !Diagnose)
+ return false;
+ return Diag(StartLoc, diag::err_ovl_no_viable_function_in_call)
+ << Name << Range;
+ }
+
+ if (R.isAmbiguous())
+ return true;
+
+ R.suppressDiagnostics();
+
+ OverloadCandidateSet Candidates(StartLoc, OverloadCandidateSet::CSK_Normal);
+ for (LookupResult::iterator Alloc = R.begin(), AllocEnd = R.end();
+ Alloc != AllocEnd; ++Alloc) {
+ // Even member operator new/delete are implicitly treated as
+ // static, so don't use AddMemberCandidate.
+ NamedDecl *D = (*Alloc)->getUnderlyingDecl();
+
+ if (FunctionTemplateDecl *FnTemplate = dyn_cast<FunctionTemplateDecl>(D)) {
+ AddTemplateOverloadCandidate(FnTemplate, Alloc.getPair(),
+ /*ExplicitTemplateArgs=*/nullptr,
+ Args, Candidates,
+ /*SuppressUserConversions=*/false);
+ continue;
}
- CheckAllocationAccess(StartLoc, Range, FoundDelete.getNamingClass(),
- Matches[0].first);
- } else if (!Matches.empty()) {
- // We found multiple suitable operators. Per [expr.new]p20, that means we
- // call no 'operator delete' function, but we should at least warn the user.
- // FIXME: Suppress this warning if the construction cannot throw.
- Diag(StartLoc, diag::warn_ambiguous_suitable_delete_function_found)
- << DeleteName << AllocElemType;
+ FunctionDecl *Fn = cast<FunctionDecl>(D);
+ AddOverloadCandidate(Fn, Alloc.getPair(), Args, Candidates,
+ /*SuppressUserConversions=*/false);
+ }
- for (auto &Match : Matches)
- Diag(Match.second->getLocation(),
- diag::note_member_declared_here) << DeleteName;
+ // Do the resolution.
+ OverloadCandidateSet::iterator Best;
+ switch (Candidates.BestViableFunction(*this, StartLoc, Best)) {
+ case OR_Success: {
+ // Got one!
+ FunctionDecl *FnDecl = Best->Function;
+ if (CheckAllocationAccess(StartLoc, Range, R.getNamingClass(),
+ Best->FoundDecl, Diagnose) == AR_inaccessible)
+ return true;
+
+ Operator = FnDecl;
+ return false;
}
- return false;
+ case OR_No_Viable_Function:
+ if (Diagnose) {
+ Diag(StartLoc, diag::err_ovl_no_viable_function_in_call)
+ << Name << Range;
+ Candidates.NoteCandidates(*this, OCD_AllCandidates, Args);
+ }
+ return true;
+
+ case OR_Ambiguous:
+ if (Diagnose) {
+ Diag(StartLoc, diag::err_ovl_ambiguous_call)
+ << Name << Range;
+ Candidates.NoteCandidates(*this, OCD_ViableCandidates, Args);
+ }
+ return true;
+
+ case OR_Deleted: {
+ if (Diagnose) {
+ Diag(StartLoc, diag::err_ovl_deleted_call)
+ << Best->Function->isDeleted()
+ << Name
+ << getDeletedOrUnavailableSuffix(Best->Function)
+ << Range;
+ Candidates.NoteCandidates(*this, OCD_AllCandidates, Args);
+ }
+ return true;
+ }
+ }
+ llvm_unreachable("Unreachable, bad result from BestViableFunction");
}
+
/// DeclareGlobalNewDelete - Declare the global forms of operator new and
/// delete. These are:
/// @code
@@ -2610,43 +2460,52 @@ void Sema::DeclareGlobalAllocationFunction(DeclarationName Name,
FunctionDecl *Sema::FindUsualDeallocationFunction(SourceLocation StartLoc,
bool CanProvideSize,
- bool Overaligned,
DeclarationName Name) {
DeclareGlobalNewDelete();
LookupResult FoundDelete(*this, Name, StartLoc, LookupOrdinaryName);
LookupQualifiedName(FoundDelete, Context.getTranslationUnitDecl());
- // FIXME: It's possible for this to result in ambiguity, through a
- // user-declared variadic operator delete or the enable_if attribute. We
- // should probably not consider those cases to be usual deallocation
- // functions. But for now we just make an arbitrary choice in that case.
- auto Result = resolveDeallocationOverload(*this, FoundDelete, CanProvideSize,
- Overaligned);
- assert(Result.FD && "operator delete missing from global scope?");
- return Result.FD;
-}
+ // C++ [expr.new]p20:
+ // [...] Any non-placement deallocation function matches a
+ // non-placement allocation function. [...]
+ llvm::SmallVector<FunctionDecl*, 2> Matches;
+ for (LookupResult::iterator D = FoundDelete.begin(),
+ DEnd = FoundDelete.end();
+ D != DEnd; ++D) {
+ if (FunctionDecl *Fn = dyn_cast<FunctionDecl>(*D))
+ if (isNonPlacementDeallocationFunction(*this, Fn))
+ Matches.push_back(Fn);
+ }
+
+ // C++1y [expr.delete]p?:
+ // If the type is complete and deallocation function lookup finds both a
+ // usual deallocation function with only a pointer parameter and a usual
+ // deallocation function with both a pointer parameter and a size
+ // parameter, then the selected deallocation function shall be the one
+ // with two parameters. Otherwise, the selected deallocation function
+ // shall be the function with one parameter.
+ if (getLangOpts().SizedDeallocation && Matches.size() == 2) {
+ unsigned NumArgs = CanProvideSize ? 2 : 1;
+ if (Matches[0]->getNumParams() != NumArgs)
+ Matches.erase(Matches.begin());
+ else
+ Matches.erase(Matches.begin() + 1);
+ assert(Matches[0]->getNumParams() == NumArgs &&
+ "found an unexpected usual deallocation function");
+ }
-FunctionDecl *Sema::FindDeallocationFunctionForDestructor(SourceLocation Loc,
- CXXRecordDecl *RD) {
- DeclarationName Name = Context.DeclarationNames.getCXXOperatorName(OO_Delete);
+ if (getLangOpts().CUDA)
+ EraseUnwantedCUDAMatches(dyn_cast<FunctionDecl>(CurContext), Matches);
- FunctionDecl *OperatorDelete = nullptr;
- if (FindDeallocationFunction(Loc, RD, Name, OperatorDelete))
- return nullptr;
- if (OperatorDelete)
- return OperatorDelete;
-
- // If there's no class-specific operator delete, look up the global
- // non-array delete.
- return FindUsualDeallocationFunction(
- Loc, true, hasNewExtendedAlignment(*this, Context.getRecordType(RD)),
- Name);
+ assert(Matches.size() == 1 &&
+ "unexpectedly have multiple usual deallocation functions");
+ return Matches.front();
}
bool Sema::FindDeallocationFunction(SourceLocation StartLoc, CXXRecordDecl *RD,
DeclarationName Name,
- FunctionDecl *&Operator, bool Diagnose) {
+ FunctionDecl* &Operator, bool Diagnose) {
LookupResult Found(*this, Name, StartLoc, LookupOrdinaryName);
// Try to find operator delete/operator delete[] in class scope.
LookupQualifiedName(Found, RD);
@@ -2656,20 +2515,27 @@ bool Sema::FindDeallocationFunction(SourceLocation StartLoc, CXXRecordDecl *RD,
Found.suppressDiagnostics();
- bool Overaligned = hasNewExtendedAlignment(*this, Context.getRecordType(RD));
+ SmallVector<DeclAccessPair,4> Matches;
+ for (LookupResult::iterator F = Found.begin(), FEnd = Found.end();
+ F != FEnd; ++F) {
+ NamedDecl *ND = (*F)->getUnderlyingDecl();
- // C++17 [expr.delete]p10:
- // If the deallocation functions have class scope, the one without a
- // parameter of type std::size_t is selected.
- llvm::SmallVector<UsualDeallocFnInfo, 4> Matches;
- resolveDeallocationOverload(*this, Found, /*WantSize*/ false,
- /*WantAlign*/ Overaligned, &Matches);
+ // Ignore template operator delete members from the check for a usual
+ // deallocation function.
+ if (isa<FunctionTemplateDecl>(ND))
+ continue;
+
+ if (cast<CXXMethodDecl>(ND)->isUsualDeallocationFunction())
+ Matches.push_back(F.getPair());
+ }
- // If we could find an overload, use it.
+ if (getLangOpts().CUDA)
+ EraseUnwantedCUDAMatches(dyn_cast<FunctionDecl>(CurContext), Matches);
+
+ // There's exactly one suitable operator; pick it.
if (Matches.size() == 1) {
- Operator = cast<CXXMethodDecl>(Matches[0].FD);
+ Operator = cast<CXXMethodDecl>(Matches[0]->getUnderlyingDecl());
- // FIXME: DiagnoseUseOfDecl?
if (Operator->isDeleted()) {
if (Diagnose) {
Diag(StartLoc, diag::err_deleted_function_use);
@@ -2679,21 +2545,21 @@ bool Sema::FindDeallocationFunction(SourceLocation StartLoc, CXXRecordDecl *RD,
}
if (CheckAllocationAccess(StartLoc, SourceRange(), Found.getNamingClass(),
- Matches[0].Found, Diagnose) == AR_inaccessible)
+ Matches[0], Diagnose) == AR_inaccessible)
return true;
return false;
- }
- // We found multiple suitable operators; complain about the ambiguity.
- // FIXME: The standard doesn't say to do this; it appears that the intent
- // is that this should never happen.
- if (!Matches.empty()) {
+ // We found multiple suitable operators; complain about the ambiguity.
+ } else if (!Matches.empty()) {
if (Diagnose) {
Diag(StartLoc, diag::err_ambiguous_suitable_delete_member_function_found)
<< Name << RD;
- for (auto &Match : Matches)
- Diag(Match.FD->getLocation(), diag::note_member_declared_here) << Name;
+
+ for (SmallVectorImpl<DeclAccessPair>::iterator
+ F = Matches.begin(), FEnd = Matches.end(); F != FEnd; ++F)
+ Diag((*F)->getUnderlyingDecl()->getLocation(),
+ diag::note_member_declared_here) << Name;
}
return true;
}
@@ -2705,8 +2571,9 @@ bool Sema::FindDeallocationFunction(SourceLocation StartLoc, CXXRecordDecl *RD,
Diag(StartLoc, diag::err_no_suitable_delete_member_function_found)
<< Name << RD;
- for (NamedDecl *D : Found)
- Diag(D->getUnderlyingDecl()->getLocation(),
+ for (LookupResult::iterator F = Found.begin(), FEnd = Found.end();
+ F != FEnd; ++F)
+ Diag((*F)->getUnderlyingDecl()->getLocation(),
diag::note_member_declared_here) << Name;
}
return true;
@@ -3117,10 +2984,7 @@ Sema::ActOnCXXDelete(SourceLocation StartLoc, bool UseGlobal,
// Otherwise, the usual operator delete[] should be the
// function we just found.
else if (OperatorDelete && isa<CXXMethodDecl>(OperatorDelete))
- UsualArrayDeleteWantsSize =
- UsualDeallocFnInfo(
- DeclAccessPair::make(OperatorDelete, AS_public))
- .HasSizeT;
+ UsualArrayDeleteWantsSize = (OperatorDelete->getNumParams() == 2);
}
if (!PointeeRD->hasIrrelevantDestructor())
@@ -3137,17 +3001,13 @@ Sema::ActOnCXXDelete(SourceLocation StartLoc, bool UseGlobal,
SourceLocation());
}
- if (!OperatorDelete) {
- bool IsComplete = isCompleteType(StartLoc, Pointee);
- bool CanProvideSize =
- IsComplete && (!ArrayForm || UsualArrayDeleteWantsSize ||
- Pointee.isDestructedType());
- bool Overaligned = hasNewExtendedAlignment(*this, Pointee);
-
+ if (!OperatorDelete)
// Look for a global declaration.
- OperatorDelete = FindUsualDeallocationFunction(StartLoc, CanProvideSize,
- Overaligned, DeleteName);
- }
+ OperatorDelete = FindUsualDeallocationFunction(
+ StartLoc, isCompleteType(StartLoc, Pointee) &&
+ (!ArrayForm || UsualArrayDeleteWantsSize ||
+ Pointee.isDestructedType()),
+ DeleteName);
MarkFunctionReferenced(StartLoc, OperatorDelete);
diff --git a/lib/Sema/SemaOverload.cpp b/lib/Sema/SemaOverload.cpp
index 082a6f98ef25c4114c9fe92aae18949bdd90a7c0..7ca85a907ead8ac284d80ecfc706a13a081601f9 100644
--- a/lib/Sema/SemaOverload.cpp
+++ b/lib/Sema/SemaOverload.cpp
@@ -10142,17 +10142,16 @@ static void CompleteNonViableCandidate(Sema &S, OverloadCandidate *Cand,
/// PrintOverloadCandidates - When overload resolution fails, prints
/// diagnostic messages containing the candidates in the candidate
/// set.
-void OverloadCandidateSet::NoteCandidates(
- Sema &S, OverloadCandidateDisplayKind OCD, ArrayRef<Expr *> Args,
- StringRef Opc, SourceLocation OpLoc,
- llvm::function_ref<bool(OverloadCandidate &)> Filter) {
+void OverloadCandidateSet::NoteCandidates(Sema &S,
+ OverloadCandidateDisplayKind OCD,
+ ArrayRef<Expr *> Args,
+ StringRef Opc,
+ SourceLocation OpLoc) {
// Sort the candidates by viability and position. Sorting directly would
// be prohibitive, so we make a set of pointers and sort those.
SmallVector<OverloadCandidate*, 32> Cands;
if (OCD == OCD_AllCandidates) Cands.reserve(size());
for (iterator Cand = begin(), LastCand = end(); Cand != LastCand; ++Cand) {
- if (!Filter(*Cand))
- continue;
if (Cand->Viable)
Cands.push_back(Cand);
else if (OCD == OCD_AllCandidates) {
diff --git a/lib/Serialization/ASTReaderStmt.cpp b/lib/Serialization/ASTReaderStmt.cpp
index a87a054f1168dac95b9e0bd4a14313c568cfe57b..28d83c7e81f4b3f2a6ec6795defb9fa5e78af023 100644
--- a/lib/Serialization/ASTReaderStmt.cpp
+++ b/lib/Serialization/ASTReaderStmt.cpp
@@ -1410,7 +1410,6 @@ void ASTStmtReader::VisitCXXNewExpr(CXXNewExpr *E) {
VisitExpr(E);
E->GlobalNew = Record[Idx++];
bool isArray = Record[Idx++];
- E->PassAlignment = Record[Idx++];
E->UsualArrayDeleteWantsSize = Record[Idx++];
unsigned NumPlacementArgs = Record[Idx++];
E->StoredInitializationStyle = Record[Idx++];
diff --git a/lib/Serialization/ASTWriterStmt.cpp b/lib/Serialization/ASTWriterStmt.cpp
index ddb69d966a7fb01bb0d4d80106d65ca566871c47..8e7cb64e50a7ad097e4f1dc07a8616d0681a11f5 100644
--- a/lib/Serialization/ASTWriterStmt.cpp
+++ b/lib/Serialization/ASTWriterStmt.cpp
@@ -1392,7 +1392,6 @@ void ASTStmtWriter::VisitCXXNewExpr(CXXNewExpr *E) {
VisitExpr(E);
Record.push_back(E->isGlobalNew());
Record.push_back(E->isArray());
- Record.push_back(E->passAlignment());
Record.push_back(E->doesUsualArrayDeleteWantSize());
Record.push_back(E->getNumPlacementArgs());
Record.push_back(E->StoredInitializationStyle);
diff --git a/test/CXX/basic/basic.stc/basic.stc.dynamic/basic.stc.dynamic.deallocation/p2.cpp b/test/CXX/basic/basic.stc/basic.stc.dynamic/basic.stc.dynamic.deallocation/p2.cpp
deleted file mode 100644
index 9e3210c6650f7b61a363d662021b98ca3781db14..0000000000000000000000000000000000000000
--- a/test/CXX/basic/basic.stc/basic.stc.dynamic/basic.stc.dynamic.deallocation/p2.cpp
+++ /dev/null
@@ -1,19 +0,0 @@
-// RUN: %clang_cc1 -std=c++1z -fsized-deallocation -fexceptions -verify %s
-
-using size_t = decltype(sizeof(0));
-
-namespace std { enum class align_val_t : size_t {}; }
-
-// p2 says "A template instance is never a usual deallocation function,
-// regardless of its signature." We (and every other implementation) assume
-// this means "A function template specialization [...]"
-template<typename...Ts> struct A {
- void *operator new(size_t);
- void operator delete(void*, Ts...) = delete; // expected-note 4{{deleted}}
-};
-
-auto *a1 = new A<>; // expected-error {{deleted}}
-auto *a2 = new A<size_t>; // expected-error {{deleted}}
-auto *a3 = new A<std::align_val_t>; // expected-error {{deleted}}
-auto *a4 = new A<size_t, std::align_val_t>; // expected-error {{deleted}}
-auto *a5 = new A<std::align_val_t, size_t>; // ok, not usual
diff --git a/test/CXX/expr/expr.unary/expr.delete/p10.cpp b/test/CXX/expr/expr.unary/expr.delete/p10.cpp
deleted file mode 100644
index aad2747dd32f24aa0961f4d8d3253eca3fc96c72..0000000000000000000000000000000000000000
--- a/test/CXX/expr/expr.unary/expr.delete/p10.cpp
+++ /dev/null
@@ -1,25 +0,0 @@
-// RUN: %clang_cc1 -std=c++1z -verify %s
-
-using size_t = decltype(sizeof(0));
-namespace std { enum class align_val_t : size_t {}; }
-
-// Aligned version is preferred over unaligned version,
-// unsized version is preferred over sized version.
-template<unsigned Align>
-struct alignas(Align) A {
- void operator delete(void*);
- void operator delete(void*, std::align_val_t) = delete; // expected-note {{here}}
-
- void operator delete(void*, size_t) = delete;
- void operator delete(void*, size_t, std::align_val_t) = delete;
-};
-void f(A<__STDCPP_DEFAULT_NEW_ALIGNMENT__> *p) { delete p; }
-void f(A<__STDCPP_DEFAULT_NEW_ALIGNMENT__ * 2> *p) { delete p; } // expected-error {{deleted}}
-
-template<unsigned Align>
-struct alignas(Align) B {
- void operator delete(void*, size_t);
- void operator delete(void*, size_t, std::align_val_t) = delete; // expected-note {{here}}
-};
-void f(B<__STDCPP_DEFAULT_NEW_ALIGNMENT__> *p) { delete p; }
-void f(B<__STDCPP_DEFAULT_NEW_ALIGNMENT__ * 2> *p) { delete p; } // expected-error {{deleted}}
diff --git a/test/CXX/expr/expr.unary/expr.new/p14.cpp b/test/CXX/expr/expr.unary/expr.new/p14.cpp
deleted file mode 100644
index 6537cdcfeafa049fc4693c1016f9694ed36b61cd..0000000000000000000000000000000000000000
--- a/test/CXX/expr/expr.unary/expr.new/p14.cpp
+++ /dev/null
@@ -1,69 +0,0 @@
-// RUN: %clang_cc1 -std=c++1z -fsized-deallocation -fexceptions %s -verify
-
-using size_t = decltype(sizeof(0));
-namespace std { enum class align_val_t : size_t {}; }
-
-struct Arg {} arg;
-
-// If the type is aligned, first try with an alignment argument and then
-// without. If not, never consider supplying an alignment.
-
-template<unsigned Align, typename ...Ts>
-struct alignas(Align) Unaligned {
- void *operator new(size_t, Ts...) = delete; // expected-note 4{{deleted}}
-};
-auto *ua = new Unaligned<__STDCPP_DEFAULT_NEW_ALIGNMENT__>; // expected-error {{deleted}}
-auto *ub = new Unaligned<__STDCPP_DEFAULT_NEW_ALIGNMENT__ * 2>; // expected-error {{deleted}}
-auto *uap = new (arg) Unaligned<__STDCPP_DEFAULT_NEW_ALIGNMENT__, Arg>; // expected-error {{deleted}}
-auto *ubp = new (arg) Unaligned<__STDCPP_DEFAULT_NEW_ALIGNMENT__ * 2, Arg>; // expected-error {{deleted}}
-
-template<unsigned Align, typename ...Ts>
-struct alignas(Align) Aligned {
- void *operator new(size_t, std::align_val_t, Ts...) = delete; // expected-note 2{{deleted}} expected-note 2{{not viable}}
-};
-auto *aa = new Aligned<__STDCPP_DEFAULT_NEW_ALIGNMENT__>; // expected-error {{no matching}}
-auto *ab = new Aligned<__STDCPP_DEFAULT_NEW_ALIGNMENT__ * 2>; // expected-error {{deleted}}
-auto *aap = new (arg) Aligned<__STDCPP_DEFAULT_NEW_ALIGNMENT__, Arg>; // expected-error {{no matching}}
-auto *abp = new (arg) Aligned<__STDCPP_DEFAULT_NEW_ALIGNMENT__ * 2, Arg>; // expected-error {{deleted}}
-
-// If both are available, we prefer the aligned version for an overaligned
-// type, and only use the unaligned version for a non-overaligned type.
-
-template<unsigned Align, typename ...Ts>
-struct alignas(Align) Both1 {
- void *operator new(size_t, Ts...); // expected-note 2{{not viable}}
- void *operator new(size_t, std::align_val_t, Ts...) = delete; // expected-note 2{{deleted}}
-};
-template<unsigned Align, typename ...Ts>
-struct alignas(Align) Both2 {
- void *operator new(size_t, Ts...) = delete; // expected-note 2{{deleted}}
- void *operator new(size_t, std::align_val_t, Ts...); // expected-note 2{{not viable}}
-};
-auto *b1a = new Both1<__STDCPP_DEFAULT_NEW_ALIGNMENT__>;
-auto *b1b = new Both1<__STDCPP_DEFAULT_NEW_ALIGNMENT__ * 2>; // expected-error {{deleted}}
-auto *b2a = new Both2<__STDCPP_DEFAULT_NEW_ALIGNMENT__>; // expected-error {{deleted}}
-auto *b2b = new Both2<__STDCPP_DEFAULT_NEW_ALIGNMENT__ * 2>;
-auto *b1ap = new (arg) Both1<__STDCPP_DEFAULT_NEW_ALIGNMENT__, Arg>;
-auto *b1bp = new (arg) Both1<__STDCPP_DEFAULT_NEW_ALIGNMENT__ * 2, Arg>; // expected-error {{deleted}}
-auto *b2ap = new (arg) Both2<__STDCPP_DEFAULT_NEW_ALIGNMENT__, Arg>; // expected-error {{deleted}}
-auto *b2bp = new (arg) Both2<__STDCPP_DEFAULT_NEW_ALIGNMENT__ * 2, Arg>;
-
-// Note that the aligned form can select a function with a parameter different
-// from std::align_val_t.
-
-struct alignas(__STDCPP_DEFAULT_NEW_ALIGNMENT__ * 2) WeirdAlignedAlloc1 {
- void *operator new(size_t, ...) = delete; // expected-note 2{{deleted}}
-};
-auto *waa1 = new WeirdAlignedAlloc1; // expected-error {{deleted}}
-auto *waa1p = new (arg) WeirdAlignedAlloc1; // expected-error {{deleted}}
-
-struct alignas(__STDCPP_DEFAULT_NEW_ALIGNMENT__ * 2) WeirdAlignedAlloc2 {
- template<typename ...T>
- void *operator new(size_t, T...) {
- using U = void(T...); // expected-note 2{{previous}}
- using U = void; // expected-error {{different types ('void' vs 'void (std::align_val_t)')}} \
- expected-error {{different types ('void' vs 'void (std::align_val_t, Arg)')}}
- }
-};
-auto *waa2 = new WeirdAlignedAlloc2; // expected-note {{instantiation of}}
-auto *waa2p = new (arg) WeirdAlignedAlloc2; // expected-note {{instantiation of}}
diff --git a/test/CXX/expr/expr.unary/expr.new/p20-0x.cpp b/test/CXX/expr/expr.unary/expr.new/p20-0x.cpp
index 13676a8a07cec3f23353a25661a7c21452b770eb..eca1ec7901999294f36ca9c742609f9426c86ee8 100644
--- a/test/CXX/expr/expr.unary/expr.new/p20-0x.cpp
+++ b/test/CXX/expr/expr.unary/expr.new/p20-0x.cpp
@@ -1,10 +1,6 @@
// RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 -fexceptions %s
-// RUN: %clang_cc1 -fsyntax-only -verify -std=c++14 -fexceptions %s
-// RUN: %clang_cc1 -fsyntax-only -verify -std=c++1z -fexceptions %s
typedef __SIZE_TYPE__ size_t;
-namespace std { enum class align_val_t : size_t {}; }
-
struct S {
// Placement allocation function:
static void* operator new(size_t, size_t);
@@ -13,56 +9,5 @@ struct S {
};
void testS() {
- S* p = new (0) S; // expected-error{{'new' expression with placement arguments refers to non-placement 'operator delete'}}
-}
-
-struct T {
- // Placement allocation function:
- static void* operator new(size_t, size_t);
- // Usual (non-placement) deallocation function:
- static void operator delete(void*);
- // Placement deallocation function:
- static void operator delete(void*, size_t);
-};
-
-void testT() {
- T* p = new (0) T; // ok
-}
-
-#if __cplusplus > 201402L
-struct U {
- // Placement allocation function:
- static void* operator new(size_t, size_t, std::align_val_t);
- // Placement deallocation function:
- static void operator delete(void*, size_t, std::align_val_t); // expected-note{{declared here}}
-};
-
-void testU() {
- U* p = new (0, std::align_val_t(0)) U; // expected-error{{'new' expression with placement arguments refers to non-placement 'operator delete'}}
-}
-
-struct V {
- // Placement allocation function:
- static void* operator new(size_t, size_t, std::align_val_t);
- // Usual (non-placement) deallocation function:
- static void operator delete(void*, std::align_val_t);
- // Placement deallocation function:
- static void operator delete(void*, size_t, std::align_val_t);
-};
-
-void testV() {
- V* p = new (0, std::align_val_t(0)) V;
-}
-
-struct W {
- // Placement allocation function:
- static void* operator new(size_t, size_t, std::align_val_t);
- // Usual (non-placement) deallocation functions:
- static void operator delete(void*);
- static void operator delete(void*, size_t, std::align_val_t); // expected-note {{declared here}}
-};
-
-void testW() {
- W* p = new (0, std::align_val_t(0)) W; // expected-error{{'new' expression with placement arguments refers to non-placement 'operator delete'}}
+ S* p = new (0) S; // expected-error{{'new' expression with placement arguments refers to non-placement 'operator delete'}}
}
-#endif
diff --git a/test/CXX/special/class.dtor/p9.cpp b/test/CXX/special/class.dtor/p9.cpp
index 4c6fbf43437a139fc50e30be2f92035b01ff853a..cfde48b0aabc352b777f00bc51c5c681f7a2865a 100644
--- a/test/CXX/special/class.dtor/p9.cpp
+++ b/test/CXX/special/class.dtor/p9.cpp
@@ -31,13 +31,13 @@ namespace test0 {
namespace test1 {
class A {
public:
- static void operator delete(void *p) {};
+ static void operator delete(void *p) {}; // expected-note {{member 'operator delete' declared here}}
virtual ~A();
};
class B : protected A {
public:
- static void operator delete(void *, size_t) {};
+ static void operator delete(void *, size_t) {}; // expected-note {{member 'operator delete' declared here}}
~B();
};
@@ -49,20 +49,7 @@ namespace test1 {
~C();
};
- // We assume that the intent is to treat C::operator delete(void*, size_t) as
- // /not/ being a usual deallocation function, as it would be if it were
- // declared with in C directly.
- C::~C() {}
-
- struct D {
- void operator delete(void*); // expected-note {{member 'operator delete' declared here}}
- void operator delete(void*, ...); // expected-note {{member 'operator delete' declared here}}
- virtual ~D();
- };
- // FIXME: The standard doesn't say this is ill-formed, but presumably either
- // it should be or the variadic operator delete should not be a usual
- // deallocation function.
- D::~D() {} // expected-error {{multiple suitable 'operator delete' functions in 'D'}}
+ C::~C() {} // expected-error {{multiple suitable 'operator delete' functions in 'C'}}
}
// ...at the point of definition of a virtual destructor...
diff --git a/test/CodeGenCXX/cxx1z-aligned-allocation.cpp b/test/CodeGenCXX/cxx1z-aligned-allocation.cpp
deleted file mode 100644
index 437597d963b077c2fdb6960e63b9fe1ac0dee161..0000000000000000000000000000000000000000
--- a/test/CodeGenCXX/cxx1z-aligned-allocation.cpp
+++ /dev/null
@@ -1,206 +0,0 @@
-// Check that delete exprs call aligned (de)allocation functions if
-// -faligned-allocation is passed in both C++11 and C++14.
-// RUN: %clang_cc1 -std=c++11 -fexceptions -fsized-deallocation -faligned-allocation %s -emit-llvm -triple x86_64-linux-gnu -o - | FileCheck %s
-// RUN: %clang_cc1 -std=c++14 -fexceptions -fsized-deallocation -faligned-allocation %s -emit-llvm -triple x86_64-linux-gnu -o - | FileCheck %s
-// RUN: %clang_cc1 -std=c++1z -fexceptions -fsized-deallocation %s -emit-llvm -triple x86_64-linux-gnu -o - | FileCheck %s
-
-// Check that we don't used aligned (de)allocation without -faligned-allocation or C++1z.
-// RUN: %clang_cc1 -std=c++14 -DUNALIGNED -fexceptions %s -emit-llvm -triple x86_64-linux-gnu -o - | FileCheck %s --check-prefix=CHECK-UNALIGNED
-// RUN: %clang_cc1 -std=c++1z -DUNALIGNED -fexceptions -fno-aligned-allocation %s -emit-llvm -triple x86_64-linux-gnu -o - | FileCheck %s --check-prefix=CHECK-UNALIGNED
-
-// CHECK-UNALIGNED-NOT: _Znwm_St11align_val_t
-// CHECK-UNALIGNED-NOT: _Znam_St11align_val_t
-// CHECK-UNALIGNED-NOT: _ZdlPv_St11align_val_t
-// CHECK-UNALIGNED-NOT: _ZdaPv_St11align_val_t
-// CHECK-UNALIGNED-NOT: _ZdlPvm_St11align_val_t
-// CHECK-UNALIGNED-NOT: _ZdaPvm_St11align_val_t
-
-typedef decltype(sizeof(0)) size_t;
-namespace std { enum class align_val_t : size_t {}; }
-
-#define OVERALIGNED alignas(__STDCPP_DEFAULT_NEW_ALIGNMENT__ * 2)
-
-// Global new and delete.
-// ======================
-struct OVERALIGNED A { A(); int n[128]; };
-
-// CHECK-LABEL: define {{.*}} @_Z2a0v()
-// CHECK: %[[ALLOC:.*]] = call i8* @_ZnwmSt11align_val_t(i64 512, i64 32)
-// CHECK: call void @_ZdlPvSt11align_val_t(i8* %[[ALLOC]], i64 32)
-void *a0() { return new A; }
-
-// CHECK-LABEL: define {{.*}} @_Z2a1l(
-// CHECK: %[[ALLOC:.*]] = call i8* @_ZnamSt11align_val_t(i64 %{{.*}}, i64 32)
-// No array cookie.
-// CHECK-NOT: store
-// CHECK: invoke void @_ZN1AC1Ev(
-// CHECK: call void @_ZdaPvSt11align_val_t(i8* %[[ALLOC]], i64 32)
-void *a1(long n) { return new A[n]; }
-
-// CHECK-LABEL: define {{.*}} @_Z2a2P1A(
-// CHECK: call void @_ZdlPvmSt11align_val_t(i8* %{{.*}}, i64 512, i64 32) #9
-void a2(A *p) { delete p; }
-
-// CHECK-LABEL: define {{.*}} @_Z2a3P1A(
-// CHECK: call void @_ZdaPvSt11align_val_t(i8* %{{.*}}, i64 32) #9
-void a3(A *p) { delete[] p; }
-
-
-// Class-specific usual new and delete.
-// ====================================
-struct OVERALIGNED B {
- B();
- // These are just a distraction. We should ignore them.
- void *operator new(size_t);
- void operator delete(void*, size_t);
- void operator delete[](void*, size_t);
-
- void *operator new(size_t, std::align_val_t);
- void operator delete(void*, std::align_val_t);
- void operator delete[](void*, std::align_val_t);
-
- int n[128];
-};
-
-// CHECK-LABEL: define {{.*}} @_Z2b0v()
-// CHECK: %[[ALLOC:.*]] = call i8* @_ZN1BnwEmSt11align_val_t(i64 512, i64 32)
-// CHECK: call void @_ZN1BdlEPvSt11align_val_t(i8* %[[ALLOC]], i64 32)
-void *b0() { return new B; }
-
-// CHECK-LABEL: define {{.*}} @_Z2b1l(
-// CHECK: %[[ALLOC:.*]] = call i8* @_ZnamSt11align_val_t(i64 %{{.*}}, i64 32)
-// No array cookie.
-// CHECK-NOT: store
-// CHECK: invoke void @_ZN1BC1Ev(
-// CHECK: call void @_ZN1BdaEPvSt11align_val_t(i8* %[[ALLOC]], i64 32)
-void *b1(long n) { return new B[n]; }
-
-// CHECK-LABEL: define {{.*}} @_Z2b2P1B(
-// CHECK: call void @_ZN1BdlEPvSt11align_val_t(i8* %{{.*}}, i64 32)
-void b2(B *p) { delete p; }
-
-// CHECK-LABEL: define {{.*}} @_Z2b3P1B(
-// CHECK: call void @_ZN1BdaEPvSt11align_val_t(i8* %{{.*}}, i64 32)
-void b3(B *p) { delete[] p; }
-
-struct OVERALIGNED C {
- C();
- void *operator new[](size_t, std::align_val_t);
- void operator delete[](void*, size_t, std::align_val_t);
-
- // It doesn't matter that we have an unaligned operator delete[] that doesn't
- // want the size. What matters is that the aligned one does.
- void operator delete[](void*);
-};
-
-// This one has an array cookie.
-// CHECK-LABEL: define {{.*}} @_Z2b4l(
-// CHECK: call {{.*}} @llvm.umul.with.overflow{{.*}}i64 32
-// CHECK: call {{.*}} @llvm.uadd.with.overflow{{.*}}i64 32
-// CHECK: %[[ALLOC:.*]] = call i8* @_ZN1CnaEmSt11align_val_t(i64 %{{.*}}, i64 32)
-// CHECK: store
-// CHECK: call void @_ZN1CC1Ev(
-//
-// Note, we're still calling a placement allocation function, and there is no
-// matching placement operator delete. =(
-// FIXME: This seems broken.
-// CHECK-NOT: call void @_ZN1CdaEPvmSt11align_val_t(
-#ifndef UNALIGNED
-void *b4(long n) { return new C[n]; }
-#endif
-
-// CHECK-LABEL: define {{.*}} @_Z2b5P1C(
-// CHECK: mul i64{{.*}} 32
-// CHECK: add i64{{.*}} 32
-// CHECK: call void @_ZN1CdaEPvmSt11align_val_t(
-void b5(C *p) { delete[] p; }
-
-
-// Global placement new.
-// =====================
-
-struct Q { int n; } q;
-void *operator new(size_t, Q);
-void *operator new(size_t, std::align_val_t, Q);
-void operator delete(void*, Q);
-void operator delete(void*, std::align_val_t, Q);
-
-// CHECK-LABEL: define {{.*}} @_Z2c0v(
-// CHECK: %[[ALLOC:.*]] = call i8* @_ZnwmSt11align_val_t1Q(i64 512, i64 32, i32 %
-// CHECK: call void @_ZdlPvSt11align_val_t1Q(i8* %[[ALLOC]], i64 32, i32 %
-void *c0() { return new (q) A; }
-
-
-// Class-specific placement new.
-// =============================
-
-struct OVERALIGNED D {
- D();
- void *operator new(size_t, Q);
- void *operator new(size_t, std::align_val_t, Q);
- void operator delete(void*, Q);
- void operator delete(void*, std::align_val_t, Q);
-};
-
-// CHECK-LABEL: define {{.*}} @_Z2d0v(
-// CHECK: %[[ALLOC:.*]] = call i8* @_ZN1DnwEmSt11align_val_t1Q(i64 32, i64 32, i32 %
-// CHECK: call void @_ZN1DdlEPvSt11align_val_t1Q(i8* %[[ALLOC]], i64 32, i32 %
-void *d0() { return new (q) D; }
-
-
-// Calling aligned new with placement syntax.
-// ==========================================
-
-#ifndef UNALIGNED
-// CHECK-LABEL: define {{.*}} @_Z2e0v(
-// CHECK: %[[ALLOC:.*]] = call i8* @_ZnwmSt11align_val_t(i64 512, i64 5)
-// CHECK: call void @_ZdlPvSt11align_val_t(i8* %[[ALLOC]], i64 5)
-void *e0() { return new (std::align_val_t(5)) A; }
-
-// CHECK-LABEL: define {{.*}} @_Z2e1v(
-// CHECK: %[[ALLOC:.*]] = call i8* @_ZN1BnwEmSt11align_val_t(i64 512, i64 5)
-// CHECK: call void @_ZN1BdlEPvSt11align_val_t(i8* %[[ALLOC]], i64 5)
-void *e1() { return new (std::align_val_t(5)) B; }
-#endif
-
-// Variadic placement/non-placement allocation functions.
-// ======================================================
-
-struct OVERALIGNED F {
- F();
- void *operator new(size_t, ...);
- void operator delete(void*, ...);
- int n[128];
-};
-
-// CHECK-LABEL: define {{.*}} @_Z2f0v(
-// CHECK: %[[ALLOC:.*]] = call i8* (i64, ...) @_ZN1FnwEmz(i64 512, i64 32)
-// Non-placement allocation function, uses normal deallocation lookup which
-// cares about whether a parameter has type std::align_val_t.
-// CHECK: call void (i8*, ...) @_ZN1FdlEPvz(i8* %[[ALLOC]])
-void *f0() { return new F; }
-
-// CHECK-LABEL: define {{.*}} @_Z2f1v(
-// CHECK: %[[ALLOC:.*]] = call i8* (i64, ...) @_ZN1FnwEmz(i64 512, i64 32, i32 %
-// Placement allocation function, uses placement deallocation matching, which
-// passes same arguments and therefore includes alignment.
-// CHECK: call void (i8*, ...) @_ZN1FdlEPvz(i8* %[[ALLOC]], i64 32, i32 %
-void *f1() { return new (q) F; }
-
-struct OVERALIGNED G {
- G();
- void *operator new(size_t, std::align_val_t, ...);
- void operator delete(void*, std::align_val_t, ...);
- int n[128];
-};
-#ifndef UNALIGNED
-// CHECK-LABEL: define {{.*}} @_Z2g0v
-// CHECK: %[[ALLOC:.*]] = call i8* (i64, i64, ...) @_ZN1GnwEmSt11align_val_tz(i64 512, i64 32)
-// CHECK: call void (i8*, i64, ...) @_ZN1GdlEPvSt11align_val_tz(i8* %[[ALLOC]], i64 32)
-void *g0() { return new G; }
-
-// CHECK-LABEL: define {{.*}} @_Z2g1v
-// CHECK: %[[ALLOC:.*]] = call i8* (i64, i64, ...) @_ZN1GnwEmSt11align_val_tz(i64 512, i64 32, i32 %
-// CHECK: call void (i8*, i64, ...) @_ZN1GdlEPvSt11align_val_tz(i8* %[[ALLOC]], i64 32, i32 %
-void *g1() { return new (q) G; }
-#endif