Sorry, I didn't see the failure yesterday. I'll get on it or revert it.
On Thu, Mar 22, 2018 at 11:51 AM, Galina Kistanova <gkistan...@gmail.com> wrote: > Hello Eric, > > One of added tests fails on the next builder: > http://lab.llvm.org:8011/builders/llvm-clang-x86_64- > expensive-checks-win/builds/8624 > > . . . > Failing Tests: > . . . > Clang :: SemaCXX/builtin-operator-new-delete.cpp > > Please have a look? > > It is not good idea to keep the bot red for too long. This hides new > problem which later hard to track down. > > Thanks > > Galina > > > On Wed, Mar 21, 2018 at 12:19 PM, Eric Fiselier via cfe-commits < > cfe-commits@lists.llvm.org> wrote: > >> Author: ericwf >> Date: Wed Mar 21 12:19:48 2018 >> New Revision: 328134 >> >> URL: http://llvm.org/viewvc/llvm-project?rev=328134&view=rev >> Log: >> [Builtins] Overload __builtin_operator_new/delete to allow forwarding to >> usual allocation/deallocation functions. >> >> Summary: >> Libc++'s default allocator uses `__builtin_operator_new` and >> `__builtin_operator_delete` in order to allow the calls to new/delete to be >> ellided. However, libc++ now needs to support over-aligned types in the >> default allocator. In order to support this without disabling the existing >> optimization Clang needs to support calling the aligned new overloads from >> the builtins. >> >> See llvm.org/PR22634 for more information about the libc++ bug. >> >> This patch changes `__builtin_operator_new`/`__builtin_operator_delete` >> to call any usual `operator new`/`operator delete` function. It does this >> by performing overload resolution with the arguments passed to the builtin >> to determine which allocation function to call. If the selected function is >> not a usual allocation function a diagnostic is issued. >> >> One open issue is if the `align_val_t` overloads should be considered >> "usual" when `LangOpts::AlignedAllocation` is disabled. >> >> >> In order to allow libc++ to detect this new behavior the value for >> `__has_builtin(__builtin_operator_new)` has been updated to `201802`. >> >> Reviewers: rsmith, majnemer, aaron.ballman, erik.pilkington, bogner, >> ahatanak >> >> Reviewed By: rsmith >> >> Subscribers: cfe-commits >> >> Differential Revision: https://reviews.llvm.org/D43047 >> >> Added: >> cfe/trunk/test/CodeGenCXX/builtin-operator-new-delete.cpp >> cfe/trunk/test/SemaCXX/builtin-operator-new-delete.cpp >> Modified: >> cfe/trunk/include/clang/Basic/Builtins.def >> cfe/trunk/include/clang/Basic/DiagnosticSemaKinds.td >> cfe/trunk/include/clang/Sema/Sema.h >> cfe/trunk/lib/CodeGen/CGBuiltin.cpp >> cfe/trunk/lib/CodeGen/CGExprCXX.cpp >> cfe/trunk/lib/CodeGen/CodeGenFunction.h >> cfe/trunk/lib/Lex/PPMacroExpansion.cpp >> cfe/trunk/lib/Sema/SemaChecking.cpp >> cfe/trunk/lib/Sema/SemaExprCXX.cpp >> >> Modified: cfe/trunk/include/clang/Basic/Builtins.def >> URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/include/clang/ >> Basic/Builtins.def?rev=328134&r1=328133&r2=328134&view=diff >> ============================================================ >> ================== >> --- cfe/trunk/include/clang/Basic/Builtins.def (original) >> +++ cfe/trunk/include/clang/Basic/Builtins.def Wed Mar 21 12:19:48 2018 >> @@ -1371,8 +1371,8 @@ BUILTIN(__builtin_smulll_overflow, "bSLL >> >> // Clang builtins (not available in GCC). >> BUILTIN(__builtin_addressof, "v*v&", "nct") >> -BUILTIN(__builtin_operator_new, "v*z", "c") >> -BUILTIN(__builtin_operator_delete, "vv*", "n") >> +BUILTIN(__builtin_operator_new, "v*z", "tc") >> +BUILTIN(__builtin_operator_delete, "vv*", "tn") >> BUILTIN(__builtin_char_memchr, "c*cC*iz", "n") >> >> // Safestack builtins >> >> Modified: cfe/trunk/include/clang/Basic/DiagnosticSemaKinds.td >> URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/include/clang/ >> Basic/DiagnosticSemaKinds.td?rev=328134&r1=328133&r2=328134&view=diff >> ============================================================ >> ================== >> --- cfe/trunk/include/clang/Basic/DiagnosticSemaKinds.td (original) >> +++ cfe/trunk/include/clang/Basic/DiagnosticSemaKinds.td Wed Mar 21 >> 12:19:48 2018 >> @@ -7627,6 +7627,11 @@ def err_destroying_operator_delete_not_u >> "alignment parameter">; >> def note_implicit_delete_this_in_destructor_here : Note< >> "while checking implicit 'delete this' for virtual destructor">; >> +def err_builtin_operator_new_delete_not_usual : Error< >> + "call to '%select{__builtin_operator_new|__builtin_operator_delete}0' >> " >> + "selects non-usual %select{allocation|deallocation}0 function">; >> +def note_non_usual_function_declared_here : Note< >> + "non-usual %0 declared here">; >> >> // C++ literal operators >> def err_literal_operator_outside_namespace : Error< >> >> Modified: cfe/trunk/include/clang/Sema/Sema.h >> URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/include/clang/ >> Sema/Sema.h?rev=328134&r1=328133&r2=328134&view=diff >> ============================================================ >> ================== >> --- cfe/trunk/include/clang/Sema/Sema.h (original) >> +++ cfe/trunk/include/clang/Sema/Sema.h Wed Mar 21 12:19:48 2018 >> @@ -10376,6 +10376,8 @@ private: >> ExprResult SemaBuiltinNontemporalOverloaded(ExprResult TheCallResult); >> ExprResult SemaAtomicOpsOverloaded(ExprResult TheCallResult, >> AtomicExpr::AtomicOp Op); >> + ExprResult SemaBuiltinOperatorNewDeleteOverloaded(ExprResult >> TheCallResult, >> + bool IsDelete); >> bool SemaBuiltinConstantArg(CallExpr *TheCall, int ArgNum, >> llvm::APSInt &Result); >> bool SemaBuiltinConstantArgRange(CallExpr *TheCall, int ArgNum, >> >> Modified: cfe/trunk/lib/CodeGen/CGBuiltin.cpp >> URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/CodeGen/CG >> Builtin.cpp?rev=328134&r1=328133&r2=328134&view=diff >> ============================================================ >> ================== >> --- cfe/trunk/lib/CodeGen/CGBuiltin.cpp (original) >> +++ cfe/trunk/lib/CodeGen/CGBuiltin.cpp Wed Mar 21 12:19:48 2018 >> @@ -2611,11 +2611,12 @@ RValue CodeGenFunction::EmitBuiltinExpr( >> case Builtin::BI__builtin_addressof: >> return RValue::get(EmitLValue(E->getArg(0)).getPointer()); >> case Builtin::BI__builtin_operator_new: >> - return EmitBuiltinNewDeleteCall(FD->getType()->castAs<FunctionProto >> Type>(), >> - E->getArg(0), false); >> + return EmitBuiltinNewDeleteCall( >> + E->getCallee()->getType()->castAs<FunctionProtoType>(), E, >> false); >> case Builtin::BI__builtin_operator_delete: >> - return EmitBuiltinNewDeleteCall(FD->getType()->castAs<FunctionProto >> Type>(), >> - E->getArg(0), true); >> + return EmitBuiltinNewDeleteCall( >> + E->getCallee()->getType()->castAs<FunctionProtoType>(), E, >> true); >> + >> case Builtin::BI__noop: >> // __noop always evaluates to an integer literal zero. >> return RValue::get(ConstantInt::get(IntTy, 0)); >> >> Modified: cfe/trunk/lib/CodeGen/CGExprCXX.cpp >> URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/CodeGen/CG >> ExprCXX.cpp?rev=328134&r1=328133&r2=328134&view=diff >> ============================================================ >> ================== >> --- cfe/trunk/lib/CodeGen/CGExprCXX.cpp (original) >> +++ cfe/trunk/lib/CodeGen/CGExprCXX.cpp Wed Mar 21 12:19:48 2018 >> @@ -1307,19 +1307,19 @@ static RValue EmitNewDeleteCall(CodeGenF >> } >> >> RValue CodeGenFunction::EmitBuiltinNewDeleteCall(const >> FunctionProtoType *Type, >> - const Expr *Arg, >> + const CallExpr *TheCall, >> bool IsDelete) { >> CallArgList Args; >> - const Stmt *ArgS = Arg; >> - EmitCallArgs(Args, *Type->param_type_begin(), >> llvm::makeArrayRef(ArgS)); >> + EmitCallArgs(Args, Type->getParamTypes(), TheCall->arguments()); >> // Find the allocation or deallocation function that we're calling. >> ASTContext &Ctx = getContext(); >> DeclarationName Name = Ctx.DeclarationNames >> .getCXXOperatorName(IsDelete ? OO_Delete : OO_New); >> + >> for (auto *Decl : Ctx.getTranslationUnitDecl()->lookup(Name)) >> if (auto *FD = dyn_cast<FunctionDecl>(Decl)) >> if (Ctx.hasSameType(FD->getType(), QualType(Type, 0))) >> - return EmitNewDeleteCall(*this, cast<FunctionDecl>(Decl), Type, >> Args); >> + return EmitNewDeleteCall(*this, FD, Type, Args); >> llvm_unreachable("predeclared global operator new/delete is missing"); >> } >> >> >> Modified: cfe/trunk/lib/CodeGen/CodeGenFunction.h >> URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/CodeGen/Co >> deGenFunction.h?rev=328134&r1=328133&r2=328134&view=diff >> ============================================================ >> ================== >> --- cfe/trunk/lib/CodeGen/CodeGenFunction.h (original) >> +++ cfe/trunk/lib/CodeGen/CodeGenFunction.h Wed Mar 21 12:19:48 2018 >> @@ -2356,7 +2356,7 @@ public: >> CharUnits CookieSize = CharUnits()); >> >> RValue EmitBuiltinNewDeleteCall(const FunctionProtoType *Type, >> - const Expr *Arg, bool IsDelete); >> + const CallExpr *TheCallExpr, bool >> IsDelete); >> >> llvm::Value *EmitCXXTypeidExpr(const CXXTypeidExpr *E); >> llvm::Value *EmitDynamicCast(Address V, const CXXDynamicCastExpr *DCE); >> >> Modified: cfe/trunk/lib/Lex/PPMacroExpansion.cpp >> URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/Lex/PPMacr >> oExpansion.cpp?rev=328134&r1=328133&r2=328134&view=diff >> ============================================================ >> ================== >> --- cfe/trunk/lib/Lex/PPMacroExpansion.cpp (original) >> +++ cfe/trunk/lib/Lex/PPMacroExpansion.cpp Wed Mar 21 12:19:48 2018 >> @@ -1801,12 +1801,21 @@ void Preprocessor::ExpandBuiltinMacro(To >> [this](Token &Tok, bool &HasLexedNextToken) -> int { >> IdentifierInfo *II = ExpectFeatureIdentifierInfo(Tok, *this, >> diag::err_feature_check_malfor >> med); >> + const LangOptions &LangOpts = getLangOpts(); >> if (!II) >> return false; >> - else if (II->getBuiltinID() != 0) >> + else if (II->getBuiltinID() != 0) { >> + switch (II->getBuiltinID()) { >> + case Builtin::BI__builtin_operator_new: >> + case Builtin::BI__builtin_operator_delete: >> + // denotes date of behavior change to support calling >> arbitrary >> + // usual allocation and deallocation functions. Required by >> libc++ >> + return 201802; >> + default: >> + return true; >> + } >> return true; >> - else { >> - const LangOptions &LangOpts = getLangOpts(); >> + } else { >> return llvm::StringSwitch<bool>(II->getName()) >> .Case("__make_integer_seq", LangOpts.CPlusPlus) >> .Case("__type_pack_element", LangOpts.CPlusPlus) >> >> Modified: cfe/trunk/lib/Sema/SemaChecking.cpp >> URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/Sema/SemaC >> hecking.cpp?rev=328134&r1=328133&r2=328134&view=diff >> ============================================================ >> ================== >> --- cfe/trunk/lib/Sema/SemaChecking.cpp (original) >> +++ cfe/trunk/lib/Sema/SemaChecking.cpp Wed Mar 21 12:19:48 2018 >> @@ -1097,20 +1097,14 @@ Sema::CheckBuiltinFunctionCall(FunctionD >> return ExprError(); >> break; >> case Builtin::BI__builtin_operator_new: >> - case Builtin::BI__builtin_operator_delete: >> - if (!getLangOpts().CPlusPlus) { >> - Diag(TheCall->getExprLoc(), diag::err_builtin_requires_language) >> - << (BuiltinID == Builtin::BI__builtin_operator_new >> - ? "__builtin_operator_new" >> - : "__builtin_operator_delete") >> - << "C++"; >> - return ExprError(); >> - } >> - // CodeGen assumes it can find the global new and delete to call, >> - // so ensure that they are declared. >> - DeclareGlobalNewDelete(); >> - break; >> - >> + case Builtin::BI__builtin_operator_delete: { >> + bool IsDelete = BuiltinID == Builtin::BI__builtin_operator_delete; >> + ExprResult Res = >> + SemaBuiltinOperatorNewDeleteOverloaded(TheCallResult, IsDelete); >> + if (Res.isInvalid()) >> + CorrectDelayedTyposInExpr(TheCallResult.get()); >> + return Res; >> + } >> // check secure string manipulation functions where overflows >> // are detectable at compile time >> case Builtin::BI__builtin___memcpy_chk: >> >> Modified: cfe/trunk/lib/Sema/SemaExprCXX.cpp >> URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/Sema/SemaE >> xprCXX.cpp?rev=328134&r1=328133&r2=328134&view=diff >> ============================================================ >> ================== >> --- cfe/trunk/lib/Sema/SemaExprCXX.cpp (original) >> +++ cfe/trunk/lib/Sema/SemaExprCXX.cpp Wed Mar 21 12:19:48 2018 >> @@ -1443,7 +1443,7 @@ namespace { >> CUDAPref = S.IdentifyCUDAPreference(Caller, FD); >> } >> >> - operator bool() const { return FD; } >> + explicit operator bool() const { return FD; } >> >> bool isBetterThan(const UsualDeallocFnInfo &Other, bool WantSize, >> bool WantAlign) const { >> @@ -2271,7 +2271,6 @@ static bool resolveAllocationOverload( >> llvm_unreachable("Unreachable, bad result from BestViableFunction"); >> } >> >> - >> /// FindAllocationFunctions - Finds the overloads of operator new and >> delete >> /// that are appropriate for the allocation. >> bool Sema::FindAllocationFunctions(SourceLocation StartLoc, SourceRange >> Range, >> @@ -3343,6 +3342,128 @@ Sema::ActOnCXXDelete(SourceLocation Star >> return Result; >> } >> >> +static bool resolveBuiltinNewDeleteOverload(Sema &S, CallExpr *TheCall, >> + bool IsDelete, >> + FunctionDecl *&Operator) { >> + >> + DeclarationName NewName = S.Context.DeclarationNames.get >> CXXOperatorName( >> + IsDelete ? OO_Delete : OO_New); >> + >> + LookupResult R(S, NewName, TheCall->getLocStart(), >> Sema::LookupOrdinaryName); >> + S.LookupQualifiedName(R, S.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(); >> + >> + SmallVector<Expr *, 8> Args(TheCall->arg_begin(), TheCall->arg_end()); >> + OverloadCandidateSet Candidates(R.getNameLoc(), >> + OverloadCandidateSet::CSK_Normal); >> + for (LookupResult::iterator FnOvl = R.begin(), FnOvlEnd = R.end(); >> + FnOvl != FnOvlEnd; ++FnOvl) { >> + // Even member operator new/delete are implicitly treated as >> + // static, so don't use AddMemberCandidate. >> + NamedDecl *D = (*FnOvl)->getUnderlyingDecl(); >> + >> + if (FunctionTemplateDecl *FnTemplate = >> dyn_cast<FunctionTemplateDecl>(D)) >> { >> + S.AddTemplateOverloadCandidate(FnTemplate, FnOvl.getPair(), >> + /*ExplicitTemplateArgs=*/nullptr, >> Args, >> + Candidates, >> + /*SuppressUserConversions=*/false); >> + continue; >> + } >> + >> + FunctionDecl *Fn = cast<FunctionDecl>(D); >> + S.AddOverloadCandidate(Fn, FnOvl.getPair(), Args, Candidates, >> + /*SuppressUserConversions=*/false); >> + } >> + >> + SourceRange Range = TheCall->getSourceRange(); >> + >> + // Do the resolution. >> + OverloadCandidateSet::iterator Best; >> + switch (Candidates.BestViableFunction(S, R.getNameLoc(), Best)) { >> + case OR_Success: { >> + // Got one! >> + FunctionDecl *FnDecl = Best->Function; >> + assert(R.getNamingClass() == nullptr && >> + "class members should not be considered"); >> + >> + if (!FnDecl->isReplaceableGlobalAllocationFunction()) { >> + S.Diag(R.getNameLoc(), diag::err_builtin_operator_new >> _delete_not_usual) >> + << (IsDelete ? 1 : 0) << Range; >> + S.Diag(FnDecl->getLocation(), diag::note_non_usual_function_ >> declared_here) >> + << R.getLookupName() << FnDecl->getSourceRange(); >> + return true; >> + } >> + >> + Operator = FnDecl; >> + return false; >> + } >> + >> + case OR_No_Viable_Function: >> + S.Diag(R.getNameLoc(), diag::err_ovl_no_viable_function_in_call) >> + << R.getLookupName() << Range; >> + Candidates.NoteCandidates(S, OCD_AllCandidates, Args); >> + return true; >> + >> + case OR_Ambiguous: >> + S.Diag(R.getNameLoc(), diag::err_ovl_ambiguous_call) >> + << R.getLookupName() << Range; >> + Candidates.NoteCandidates(S, OCD_ViableCandidates, Args); >> + 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"); >> +} >> + >> +ExprResult >> +Sema::SemaBuiltinOperatorNewDeleteOverloaded(ExprResult TheCallResult, >> + bool IsDelete) { >> + CallExpr *TheCall = cast<CallExpr>(TheCallResult.get()); >> + if (!getLangOpts().CPlusPlus) { >> + Diag(TheCall->getExprLoc(), diag::err_builtin_requires_language) >> + << (IsDelete ? "__builtin_operator_delete" : >> "__builtin_operator_new") >> + << "C++"; >> + return ExprError(); >> + } >> + // CodeGen assumes it can find the global new and delete to call, >> + // so ensure that they are declared. >> + DeclareGlobalNewDelete(); >> + >> + FunctionDecl *OperatorNewOrDelete = nullptr; >> + if (resolveBuiltinNewDeleteOverload(*this, TheCall, IsDelete, >> + OperatorNewOrDelete)) >> + return ExprError(); >> + assert(OperatorNewOrDelete && "should be found"); >> + >> + TheCall->setType(OperatorNewOrDelete->getReturnType()); >> + for (unsigned i = 0; i != TheCall->getNumArgs(); ++i) { >> + QualType ParamTy = OperatorNewOrDelete->getParamDecl(i)->getType(); >> + InitializedEntity Entity = >> + InitializedEntity::InitializeParameter(Context, ParamTy, false); >> + ExprResult Arg = PerformCopyInitialization( >> + Entity, TheCall->getArg(i)->getLocStart(), TheCall->getArg(i)); >> + if (Arg.isInvalid()) >> + return ExprError(); >> + TheCall->setArg(i, Arg.get()); >> + } >> + auto Callee = dyn_cast<ImplicitCastExpr>(TheCall->getCallee()); >> + assert(Callee && Callee->getCastKind() == CK_BuiltinFnToFnPtr && >> + "Callee expected to be implicit cast to a builtin function >> pointer"); >> + Callee->setType(OperatorNewOrDelete->getType()); >> + >> + return TheCallResult; >> +} >> + >> void Sema::CheckVirtualDtorCall(CXXDestructorDecl *dtor, SourceLocation >> Loc, >> bool IsDelete, bool CallCanBeVirtual, >> bool WarnOnNonAbstractTypes, >> >> Added: cfe/trunk/test/CodeGenCXX/builtin-operator-new-delete.cpp >> URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/test/CodeGenCX >> X/builtin-operator-new-delete.cpp?rev=328134&view=auto >> ============================================================ >> ================== >> --- cfe/trunk/test/CodeGenCXX/builtin-operator-new-delete.cpp (added) >> +++ cfe/trunk/test/CodeGenCXX/builtin-operator-new-delete.cpp Wed Mar 21 >> 12:19:48 2018 >> @@ -0,0 +1,71 @@ >> +// RUN: %clang_cc1 -triple x86_64-unknown-unknown %s \ >> +// RUN: -faligned-allocation -fsized-deallocation -emit-llvm -o - \ >> +// RUN: | FileCheck %s >> + >> +typedef __SIZE_TYPE__ size_t; >> + >> +// Declare an 'operator new' template to tickle a bug in >> __builtin_operator_new. >> +template<typename T> void *operator new(size_t, int (*)(T)); >> + >> +// Ensure that this declaration doesn't cause operator new to lose its >> +// 'noalias' attribute. >> +void *operator new(size_t); >> + >> +namespace std { >> + struct nothrow_t {}; >> + enum class align_val_t : size_t { __zero = 0, >> + __max = (size_t)-1 }; >> +} >> +std::nothrow_t nothrow; >> + >> +// Declare the reserved placement operators. >> +void *operator new(size_t, void*) throw(); >> +void operator delete(void*, void*) throw(); >> +void *operator new[](size_t, void*) throw(); >> +void operator delete[](void*, void*) throw(); >> + >> +// Declare the replaceable global allocation operators. >> +void *operator new(size_t, const std::nothrow_t &) throw(); >> +void *operator new[](size_t, const std::nothrow_t &) throw(); >> +void operator delete(void *, const std::nothrow_t &) throw(); >> +void operator delete[](void *, const std::nothrow_t &) throw(); >> + >> +// Declare some other placement operators. >> +void *operator new(size_t, void*, bool) throw(); >> +void *operator new[](size_t, void*, bool) throw(); >> + >> + >> +// CHECK-LABEL: define void @test_basic( >> +extern "C" void test_basic() { >> + // CHECK: call i8* @_Znwm(i64 4) [[ATTR_BUILTIN_NEW:#[^ ]*]] >> + // CHECK: call void @_ZdlPv({{.*}}) [[ATTR_BUILTIN_DELETE:#[^ ]*]] >> + // CHECK: ret void >> + __builtin_operator_delete(__builtin_operator_new(4)); >> +} >> +// CHECK: declare noalias i8* @_Znwm(i64) [[ATTR_NOBUILTIN:#[^ ]*]] >> +// CHECK: declare void @_ZdlPv(i8*) [[ATTR_NOBUILTIN_NOUNWIND:#[^ ]*]] >> + >> +// CHECK-LABEL: define void @test_aligned_alloc( >> +extern "C" void test_aligned_alloc() { >> + // CHECK: call i8* @_ZnwmSt11align_val_t(i64 4, i64 4) >> [[ATTR_BUILTIN_NEW:#[^ ]*]] >> + // CHECK: call void @_ZdlPvSt11align_val_t({{.*}}, i64 4) >> [[ATTR_BUILTIN_DELETE:#[^ ]*]] >> + __builtin_operator_delete(__builtin_operator_new(4, >> std::align_val_t(4)), std::align_val_t(4)); >> +} >> +// CHECK: declare noalias i8* @_ZnwmSt11align_val_t(i64, i64) >> [[ATTR_NOBUILTIN:#[^ ]*]] >> +// CHECK: declare void @_ZdlPvSt11align_val_t(i8*, i64) >> [[ATTR_NOBUILTIN_NOUNWIND:#[^ ]*]] >> + >> + >> +// CHECK-LABEL: define void @test_sized_delete( >> +extern "C" void test_sized_delete() { >> + // CHECK: call i8* @_Znwm(i64 4) [[ATTR_BUILTIN_NEW:#[^ ]*]] >> + // CHECK: call void @_ZdlPvm({{.*}}, i64 4) [[ATTR_BUILTIN_DELETE:#[^ >> ]*]] >> + __builtin_operator_delete(__builtin_operator_new(4), 4); >> +} >> +// CHECK: declare void @_ZdlPvm(i8*, i64) [[ATTR_NOBUILTIN_UNWIND:#[^ >> ]*]] >> + >> + >> +// CHECK-DAG: attributes [[ATTR_NOBUILTIN]] = {{[{].*}} nobuiltin >> {{.*[}]}} >> +// CHECK-DAG: attributes [[ATTR_NOBUILTIN_NOUNWIND]] = {{[{].*}} >> nobuiltin nounwind {{.*[}]}} >> + >> +// CHECK-DAG: attributes [[ATTR_BUILTIN_NEW]] = {{[{].*}} builtin >> {{.*[}]}} >> +// CHECK-DAG: attributes [[ATTR_BUILTIN_DELETE]] = {{[{].*}} builtin >> {{.*[}]}} >> >> Added: cfe/trunk/test/SemaCXX/builtin-operator-new-delete.cpp >> URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/test/SemaCXX/ >> builtin-operator-new-delete.cpp?rev=328134&view=auto >> ============================================================ >> ================== >> --- cfe/trunk/test/SemaCXX/builtin-operator-new-delete.cpp (added) >> +++ cfe/trunk/test/SemaCXX/builtin-operator-new-delete.cpp Wed Mar 21 >> 12:19:48 2018 >> @@ -0,0 +1,153 @@ >> +// RUN: %clang_cc1 -std=c++1z -fsyntax-only -verify %s >> +// RUN: %clang_cc1 -std=c++03 -fsyntax-only -verify %s >> +// RUN: %clang_cc1 -std=c++03 -faligned-allocation -fsyntax-only -verify >> %s >> +// RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify %s >> +// RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify -fsized-deallocation >> %s >> + >> +#if !__has_builtin(__builtin_operator_new) || >> !__has_builtin(__builtin_operator_delete) >> +#error builtins should always be available >> +#endif >> + >> +#if __has_builtin(__builtin_operator_new) != 201802L || \ >> + __has_builtin(__builtin_operator_delete) != 201802L >> +#error builtin should report updated value >> +#endif >> + >> +typedef __SIZE_TYPE__ size_t; >> +namespace std { >> + struct nothrow_t {}; >> +#if __cplusplus >= 201103L >> +enum class align_val_t : size_t {}; >> +#else >> + enum align_val_t { __zero = 0, >> + __max = (size_t)-1 }; >> +#endif >> +} >> +std::nothrow_t nothrow; >> + >> +void *operator new(size_t); // expected-note 1+ {{candidate function}} >> +void operator delete(void *); // expected-note 1+ {{candidate function}} >> + >> +// Declare the reserved placement operators. >> +void *operator new(size_t, void*) throw(); // expected-note 1+ >> {{candidate function}} >> +void operator delete(void *, void *)throw(); // expected-note 1+ >> {{candidate function}} >> +void *operator new[](size_t, void*) throw(); >> +void operator delete[](void*, void*) throw(); >> + >> +// Declare the replaceable global allocation operators. >> +void *operator new(size_t, const std::nothrow_t &) throw(); // >> expected-note 1+ {{candidate function}} >> +void *operator new[](size_t, const std::nothrow_t &) throw(); >> +void operator delete(void *, const std::nothrow_t &)throw(); // >> expected-note 1+ {{candidate function}} >> +void operator delete[](void *, const std::nothrow_t &) throw(); >> + >> +// aligned allocation and deallocation functions. >> +void* operator new ( size_t count, std::align_val_t al); // >> expected-note 1+ {{candidate function}} >> +void operator delete(void *, std::align_val_t); // expected-note 1+ >> {{candidate}} >> +#ifndef __cpp_aligned_new >> +// expected-note@-3 1+ {{non-usual 'operator new' declared here}} >> +// expected-note@-3 1+ {{non-usual 'operator delete' declared here}} >> +#endif >> +void *operator new[](size_t count, std::align_val_t al); >> +void operator delete[](void*, std::align_val_t); >> + >> +void operator delete(void *, size_t); // expected-note 1+ {{candidate}} >> +#ifndef __cpp_sized_deallocation >> +// expected-note@-2 1+ {{non-usual 'operator delete' declared here}} >> +#endif >> +void operator delete[](void*, size_t); >> + >> +// Declare some other placemenet operators. >> +void *operator new(size_t, void*, bool) throw(); // expected-note 1+ >> {{candidate function}} >> +void *operator new[](size_t, void*, bool) throw(); >> + >> +void *NP = 0; >> + >> +void test_typo_in_args() { >> + __builtin_operator_new(DNE); // expected-error {{undeclared >> identifier 'DNE'}} >> + __builtin_operator_new(DNE, DNE2); // expected-error {{undeclared >> identifier 'DNE'}} expected-error {{'DNE2'}} >> + __builtin_operator_delete(DNE); // expected-error {{'DNE'}} >> + __builtin_operator_delete(DNE, DNE2); // expected-error {{'DNE'}} >> expected-error {{'DNE2'}} >> +} >> + >> +void test_arg_types() { >> + __builtin_operator_new(NP); // expected-error >> {{no matching function for call to 'operator new'}} >> + __builtin_operator_new(NP, std::align_val_t(0)); // expected-error >> {{no matching function for call to 'operator new'}}} >> +} >> +void test_return_type() { >> + int w = __builtin_operator_new(42); // expected-error {{cannot >> initialize a variable of type 'int' with an rvalue of type 'void *'}} >> + int y = __builtin_operator_delete(NP); // expected-error {{cannot >> initialize a variable of type 'int' with an rvalue of type 'void'}} >> +} >> + >> +void test_aligned_new() { >> +#ifdef __cpp_aligned_new >> + void *p = __builtin_operator_new(42, std::align_val_t(2)); >> + __builtin_operator_delete(p, std::align_val_t(2)); >> +#else >> + // FIXME: We've manually declared the aligned new/delete overloads, >> + // but LangOpts::AlignedAllocation is false. Should our overloads be >> considered >> + // usual allocation/deallocation functions? >> + void *p = __builtin_operator_new(42, std::align_val_t(2)); // >> expected-error {{call to '__builtin_operator_new' selects non-usual >> allocation function}} >> + __builtin_operator_delete(p, std::align_val_t(2)); // >> expected-error {{call to '__builtin_operator_delete' selects non-usual >> deallocation function}} >> +#endif >> +} >> + >> +void test_sized_delete() { >> +#ifdef __cpp_sized_deallocation >> + __builtin_operator_delete(NP, 4); >> +#else >> + __builtin_operator_delete(NP, 4); // expected-error {{call to >> '__builtin_operator_delete' selects non-usual deallocation function}} >> +#endif >> +} >> + >> +void *operator new(size_t, bool); // expected-note 1+ {{candidate}} >> +// expected-note@-1 {{non-usual 'operator new' declared here}} >> +void operator delete(void *, bool); // expected-note 1+ {{candidate}} >> +// expected-note@-1 {{non-usual 'operator delete' declared here}} >> + >> +void test_non_usual() { >> + __builtin_operator_new(42, true); // expected-error {{call to >> '__builtin_operator_new' selects non-usual allocation function}} >> + __builtin_operator_delete(NP, false); // expected-error {{call to >> '__builtin_operator_delete' selects non-usual deallocation function}} >> +} >> + >> +template <int ID> >> +struct Tag {}; >> +struct ConvertsToTypes { >> + operator std::align_val_t() const; >> + operator Tag<0>() const; >> +}; >> + >> +void *operator new(size_t, Tag<0>); // expected-note 0+ {{candidate}} >> +void operator delete(void *, Tag<0>); // expected-note 0+ {{candidate}} >> + >> +void test_ambiguous() { >> +#ifdef __cpp_aligned_new >> + ConvertsToTypes cvt; >> + __builtin_operator_new(42, cvt); // expected-error {{call to >> 'operator new' is ambiguous}} >> + __builtin_operator_delete(NP, cvt); // expected-error {{call to >> 'operator delete' is ambiguous}} >> +#endif >> +} >> + >> +void test_no_args() { >> + __builtin_operator_new(); // expected-error {{no matching function >> for call to 'operator new'}} >> + __builtin_operator_delete(); // expected-error {{no matching function >> for call to 'operator delete'}} >> +} >> + >> +void test_no_matching_fn() { >> + Tag<1> tag; >> + __builtin_operator_new(42, tag); // expected-error {{no matching >> function for call to 'operator new'}} >> + __builtin_operator_delete(NP, tag); // expected-error {{no matching >> function for call to 'operator delete'}} >> +} >> + >> +template <class Tp, class Up, class RetT> >> +void test_dependent_call(Tp new_arg, Up delete_arg, RetT) { >> + RetT ret = __builtin_operator_new(new_arg); >> + __builtin_operator_delete(delete_arg); >> +} >> +template void test_dependent_call(int, int*, void*); >> + >> +void test_const_attribute() { >> + __builtin_operator_new(42); // expected-warning {{ignoring return >> value of function declared with const attribute}} >> +#ifdef __cpp_aligned_new >> + __builtin_operator_new(42, std::align_val_t(8)); // expected-warning >> {{ignoring return value of function declared with const attribute}} >> +#endif >> +} >> >> >> _______________________________________________ >> cfe-commits mailing list >> cfe-commits@lists.llvm.org >> http://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits >> > >
_______________________________________________ cfe-commits mailing list cfe-commits@lists.llvm.org http://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
