C++14: Disable sized deallocation by default due to ABI breakage

[rnk]

Summary

There are no widely deployed standard libraries providing sized
deallocation functions, so we have to punt and ask the user if they want
us to use sized deallocation. In the future, when such libraries are
deployed, we can teach the driver to detect them and enable this
feature.

N3536 claimed that a weak thunk from sized to unsized deallocation could
be emitted to avoid breaking backwards compatibility with standard
libraries not providing sized deallocation. However, this approach and
other variations don't work in practice.

With the weak function approach, the thunk has to have default
visibility in order to ensure that it is overridden by other DSOs
providing sized deallocation. Weak, default visibility symbols are
particularly expensive on MachO, so John McCall was considering
disabling this feature by default on Darwin. It also changes behavior
ELF linking behavior, causing certain otherwise unreferenced object
files from an archive to be pulled into the link.

Our second approach was to use an extern_weak function declaration and
do an inline conditional branch at the deletion call site. This doesn't
work because extern_weak only works on MachO if you have some archive
providing the default value of the extern_weak symbol. Arranging to
provide such an archive has the same challenges as providing the symbol
in the standard library. Not to mention that extern_weak doesn't really
work on COFF.

[rsmith]

I have one general concern: we used to provide sized deallocation outside of C++14 mode via -Xclang -fiszed-deallocation. With this patch, that no longer works, because -fsized-deallocation doesn't cause the sized deallocation functions to get implicitly declared any more.

Given that the implicit declarations are not really useful unless a sized deallocation function is known to be available, and that it seems overkill to have two flags for this feature, perhaps we should keep the implicit declarations and the usage thereof tied together under the same flag?

[rsmith]

Please also update www/cxx_status.html and the release notes.

[rnk]

In D8467#143810, @rsmith wrote:

I have one general concern: we used to provide sized deallocation outside of C++14 mode via -Xclang -fiszed-deallocation. With this patch, that no longer works, because -fsized-deallocation doesn't cause the sized deallocation functions to get implicitly declared any more.

Given that the implicit declarations are not really useful unless a sized deallocation function is known to be available, and that it seems overkill to have two flags for this feature, perhaps we should keep the implicit declarations and the usage thereof tied together under the same flag?

Makes sense. Doing that actually requires less change. :)

[rnk]

• Update cxx_status.html
• Only provide sized operator delete with -fsized-deallocation

[rsmith]

LGTM, please update the release notes to mention this.

[zixuan-wu]

Hi, I am wondering could -fsized-deallocation this be enabled by default nowadays in 2021?

[rnk]

In D8467#3095610, @zixuan-wu wrote:

Hi, I am wondering could -fsized-deallocation this be enabled by default nowadays in 2021?

Yes, I think so. This should be a matter of adjusting the default in the driver. We should not bring back the code that defines the sized deallocation thunk, so a straight revert of this patch doesn't make sense.

I don't have time to work on this at the moment, but I would approve a patch.

[tstellar]

In D8467#3095610, @zixuan-wu wrote:

Hi, I am wondering could -fsized-deallocation this be enabled by default nowadays in 2021?

Were you planning to work on this?

[rjmccall]

Conceptually, this is (and will always be) a platform decision. On Apple platforms, we have a formalized concept of deployment target, where specific minimum OS versions support sized deallocation and others do not. On most other platforms, this is much vaguer — basically down to what C++ libraries you've got installed — and probably has to be controlled by a flag. Enabling that flag by default on any particular Linux distribution release is something I'm not sure we can do unconditionally.

[rnk]

In D8467#3125386, @rjmccall wrote:

Conceptually, this is (and will always be) a platform decision. On Apple platforms, we have a formalized concept of deployment target, where specific minimum OS versions support sized deallocation and others do not. On most other platforms, this is much vaguer — basically down to what C++ libraries you've got installed — and probably has to be controlled by a flag. Enabling that flag by default on any particular Linux distribution release is something I'm not sure we can do unconditionally.

It is already a flag, -fsized-deallocation. On some level, whatever default we choose is just a guess about the C++ library support level. Clang tries to encode all kinds of Linux distro-specific knowledge, and it's often wrong anyway. After all that logic, there will be some default. I think at this point the feature should default to being enabled.

[rjmccall]

In D8467#3125471, @rnk wrote:

In D8467#3125386, @rjmccall wrote:

Conceptually, this is (and will always be) a platform decision. On Apple platforms, we have a formalized concept of deployment target, where specific minimum OS versions support sized deallocation and others do not. On most other platforms, this is much vaguer — basically down to what C++ libraries you've got installed — and probably has to be controlled by a flag. Enabling that flag by default on any particular Linux distribution release is something I'm not sure we can do unconditionally.

It is already a flag, -fsized-deallocation. On some level, whatever default we choose is just a guess about the C++ library support level. Clang tries to encode all kinds of Linux distro-specific knowledge, and it's often wrong anyway. After all that logic, there will be some default. I think at this point the feature should default to being enabled.

Okay. I think that's fine for most platforms. Apple would like this to only be enabled conditionally based on deployment target.

[zixuan-wu]

In D8467#3125313, @tstellar wrote:

In D8467#3095610, @zixuan-wu wrote:

Hi, I am wondering could -fsized-deallocation this be enabled by default nowadays in 2021?

Were you planning to work on this?

It's been working on at https://reviews.llvm.org/D112921

include/clang/AST/Decl.h

public:
   ///    void operator delete[](void *) noexcept;
   ///    void operator delete[](void *, std::size_t) noexcept;    [C++1y]
   ///    void operator delete[](void *, const std::nothrow_t &) noexcept;
   /// These functions have special behavior under C++1y [expr.new]:
   ///    An implementation is allowed to omit a call to a replaceable global
   ///    allocation function. [...]
   bool isReplaceableGlobalAllocationFunction() const;
 
-  /// \brief Determine whether this function is a sized global deallocation
-  /// function in C++1y. If so, find and return the corresponding unsized
-  /// deallocation function.
-  FunctionDecl *getCorrespondingUnsizedGlobalDeallocationFunction() const;
-
   /// Compute the language linkage.
   LanguageLinkage getLanguageLinkage() const;
 
   /// \brief Determines whether this function is a function with
   /// external, C linkage.
   bool isExternC() const;
 
   /// \brief Determines whether this function's context is, or is nested within,

include/clang/Basic/LangOptions.def

 LANGOPT(HalfArgsAndReturns, 1, 0, "half args and returns")
 LANGOPT(CUDA              , 1, 0, "CUDA")
 LANGOPT(OpenMP            , 1, 0, "OpenMP support")
 LANGOPT(CUDAIsDevice      , 1, 0, "Compiling for CUDA device")
 LANGOPT(CUDAAllowHostCallsFromHostDevice, 1, 0, "Allow host device functions to call host functions")
 
 LANGOPT(AssumeSaneOperatorNew , 1, 1, "implicit __attribute__((malloc)) for C++'s new operators")
 LANGOPT(SizedDeallocation , 1, 0, "enable sized deallocation functions")
-LANGOPT(DefineSizedDeallocation , 1, 0, "generate weak definitions of sized delete")
 BENIGN_LANGOPT(ElideConstructors , 1, 1, "C++ copy constructor elision")
 BENIGN_LANGOPT(DumpRecordLayouts , 1, 0, "dumping the layout of IRgen'd records")
 BENIGN_LANGOPT(DumpRecordLayoutsSimple , 1, 0, "dumping the layout of IRgen'd records in a simple form")
 BENIGN_LANGOPT(DumpVTableLayouts , 1, 0, "dumping the layouts of emitted vtables")
 LANGOPT(NoConstantCFStrings , 1, 0, "no constant CoreFoundation strings")
 BENIGN_LANGOPT(InlineVisibilityHidden , 1, 0, "hidden default visibility for inline C++ methods")
 BENIGN_LANGOPT(ParseUnknownAnytype, 1, 0, "__unknown_anytype")
 BENIGN_LANGOPT(DebuggerSupport , 1, 0, "debugger support")

include/clang/Driver/CC1Options.td

 def fdebugger_cast_result_to_id : Flag<["-"], "fdebugger-cast-result-to-id">,
   HelpText<"Enable casting unknown expression results to id">;
 def fdebugger_objc_literal : Flag<["-"], "fdebugger-objc-literal">,
   HelpText<"Enable special debugger support for Objective-C subscripting and literals">;
 def fdeprecated_macro : Flag<["-"], "fdeprecated-macro">,
   HelpText<"Defines the __DEPRECATED macro">;
 def fno_deprecated_macro : Flag<["-"], "fno-deprecated-macro">,
   HelpText<"Undefines the __DEPRECATED macro">;
-def fsized_deallocation : Flag<["-"], "fsized-deallocation">,
-  HelpText<"Enable C++14 sized global deallocation functions">;
-def fno_sized_deallocation: Flag<["-"], "fno-sized-deallocation">,
-  HelpText<"Disable sized deallocation functions">;
-def fdefine_sized_deallocation: Flag<["-"], "fdefine-sized-deallocation">,
-  HelpText<"Allow compiler-generated definition of sized deallocation functions">;
 def fobjc_subscripting_legacy_runtime : Flag<["-"], "fobjc-subscripting-legacy-runtime">,
   HelpText<"Allow Objective-C array and dictionary subscripting in legacy runtime">;
 def vtordisp_mode_EQ : Joined<["-"], "vtordisp-mode=">,
   HelpText<"Control vtordisp placement on win32 targets">;
 def fno_rtti_data : Flag<["-"], "fno-rtti-data">,
   HelpText<"Control emission of RTTI data">;
 def fallow_half_arguments_and_returns : Flag<["-"], "fallow-half-arguments-and-returns">,
   HelpText<"Allow function arguments and returns of type half">;

include/clang/Driver/Options.td

 def fobjc_call_cxx_cdtors : Flag<["-"], "fobjc-call-cxx-cdtors">, Group<clang_ignored_f_Group>;
 def fobjc_exceptions: Flag<["-"], "fobjc-exceptions">, Group<f_Group>,
   HelpText<"Enable Objective-C exceptions">, Flags<[CC1Option]>;
 def fapplication_extension : Flag<["-"], "fapplication-extension">,
   Group<f_Group>, Flags<[CC1Option]>,
   HelpText<"Restrict code to those available for App Extensions">;
 def fno_application_extension : Flag<["-"], "fno-application-extension">,
   Group<f_Group>;
+def fsized_deallocation : Flag<["-"], "fsized-deallocation">, Flags<[CC1Option]>,
+  HelpText<"Enable C++14 sized global deallocation functions">, Group<f_Group>;
+def fno_sized_deallocation: Flag<["-"], "fno-sized-deallocation">, Group<f_Group>;
 
 def fobjc_gc_only : Flag<["-"], "fobjc-gc-only">, Group<f_Group>, Flags<[CC1Option]>,
   HelpText<"Use GC exclusively for Objective-C related memory management">;
 def fobjc_gc : Flag<["-"], "fobjc-gc">, Group<f_Group>, Flags<[CC1Option]>,
   HelpText<"Enable Objective-C garbage collection">;
 def fobjc_legacy_dispatch : Flag<["-"], "fobjc-legacy-dispatch">, Group<f_Group>;
 def fobjc_new_property : Flag<["-"], "fobjc-new-property">, Group<clang_ignored_f_Group>;
 def fobjc_infer_related_result_type : Flag<["-"], "fobjc-infer-related-result-type">, 

lib/AST/Decl.cpp

bool FunctionDecl::isReplaceableGlobalAllocationFunction() const {
   // allocation or deallocation function.
   if (FPT->getNumParams() == 1)
     return true;
 
   // 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();
-  if (Ctx.getLangOpts().SizedDeallocation &&
+  if (Ctx.getLangOpts().CPlusPlus14 &&
       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();
 }
 
-FunctionDecl *
-FunctionDecl::getCorrespondingUnsizedGlobalDeallocationFunction() const {
-  ASTContext &Ctx = getASTContext();
-  if (!Ctx.getLangOpts().SizedDeallocation)
-    return nullptr;
-
-  if (getDeclName().getNameKind() != DeclarationName::CXXOperatorName)
-    return nullptr;
-  if (getDeclName().getCXXOverloadedOperator() != OO_Delete &&
-      getDeclName().getCXXOverloadedOperator() != OO_Array_Delete)
-    return nullptr;
-  if (isa<CXXRecordDecl>(getDeclContext()))
-    return nullptr;
-
-  if (!getDeclContext()->getRedeclContext()->isTranslationUnit())
-    return nullptr;
-
-  if (getNumParams() != 2 || isVariadic() ||
-      !Ctx.hasSameType(getType()->castAs<FunctionProtoType>()->getParamType(1),
-                       Ctx.getSizeType()))
-    return nullptr;
-
-  // This is a sized deallocation function. Find the corresponding unsized
-  // deallocation function.
-  lookup_result R = getDeclContext()->lookup(getDeclName());
-  for (lookup_result::iterator RI = R.begin(), RE = R.end(); RI != RE;
-       ++RI)
-    if (FunctionDecl *FD = dyn_cast<FunctionDecl>(*RI))
-      if (FD->getNumParams() == 1 && !FD->isVariadic())
-        return FD;
-  return nullptr;
-}
-
 LanguageLinkage FunctionDecl::getLanguageLinkage() const {
   return getDeclLanguageLinkage(*this);
 }
 
 bool FunctionDecl::isExternC() const {
   return isDeclExternC(*this);
 }
 

lib/CodeGen/CodeGenFunction.cpp

for (llvm::BasicBlock::iterator
         if (!Call->doesNotThrow())
           return;
       } else if (isa<llvm::ResumeInst>(&*BI)) {
         return;
       }
   F->setDoesNotThrow();
 }
 
-static void EmitSizedDeallocationFunction(CodeGenFunction &CGF,
-                                          const FunctionDecl *UnsizedDealloc) {
-  // This is a weak discardable definition of the sized deallocation function.
-  CGF.CurFn->setLinkage(llvm::Function::LinkOnceAnyLinkage);
-  if (CGF.CGM.supportsCOMDAT())
-    CGF.CurFn->setComdat(
-        CGF.CGM.getModule().getOrInsertComdat(CGF.CurFn->getName()));
-
-  // Call the unsized deallocation function and forward the first argument
-  // unchanged.
-  llvm::Constant *Unsized = CGF.CGM.GetAddrOfFunction(UnsizedDealloc);
-  CGF.Builder.CreateCall(Unsized, &*CGF.CurFn->arg_begin());
-}
-
 void CodeGenFunction::GenerateCode(GlobalDecl GD, llvm::Function *Fn,
                                    const CGFunctionInfo &FnInfo) {
   const FunctionDecl *FD = cast<FunctionDecl>(GD.getDecl());
 
   // Check if we should generate debug info for this function.
   if (FD->hasAttr<NoDebugAttr>())
     DebugInfo = nullptr; // disable debug info indefinitely for this function
 
void CodeGenFunction::GenerateCode(GlobalDecl GD, llvm::Function *Fn,
   } else if (FD->isDefaulted() && isa<CXXMethodDecl>(FD) &&
              (cast<CXXMethodDecl>(FD)->isCopyAssignmentOperator() ||
               cast<CXXMethodDecl>(FD)->isMoveAssignmentOperator())) {
     // Implicit copy-assignment gets the same special treatment as implicit
     // copy-constructors.
     emitImplicitAssignmentOperatorBody(Args);
   } else if (Stmt *Body = FD->getBody()) {
     EmitFunctionBody(Args, Body);
-  } else if (FunctionDecl *UnsizedDealloc =
-                 FD->getCorrespondingUnsizedGlobalDeallocationFunction()) {
-    // Global sized deallocation functions get an implicit weak definition if
-    // they don't have an explicit definition, if allowed.
-    assert(getLangOpts().DefineSizedDeallocation &&
-           "Can't emit unallowed definition.");
-    EmitSizedDeallocationFunction(*this, UnsizedDealloc);
-
   } else
     llvm_unreachable("no definition for emitted function");
 
   // C++11 [stmt.return]p2:
   //   Flowing off the end of a function [...] results in undefined behavior in
   //   a value-returning function.
   // C11 6.9.1p12:
   //   If the '}' that terminates a function is reached, and the value of the

lib/CodeGen/CodeGenModule.cpp

if (!DontDefer) {
     // of the file.
     auto DDI = DeferredDecls.find(MangledName);
     if (DDI != DeferredDecls.end()) {
       // Move the potentially referenced deferred decl to the
       // DeferredDeclsToEmit list, and remove it from DeferredDecls (since we
       // don't need it anymore).
       addDeferredDeclToEmit(F, DDI->second);
       DeferredDecls.erase(DDI);
-      
-      // Otherwise, if this is a sized deallocation function, emit a weak
-      // definition for it at the end of the translation unit (if allowed),
-      // unless the sized deallocation function is aliased.
-    } else if (D &&
-               cast<FunctionDecl>(D)
-                  ->getCorrespondingUnsizedGlobalDeallocationFunction() &&
-               getLangOpts().DefineSizedDeallocation &&
-               !D->hasAttr<AliasAttr>()) {
-      addDeferredDeclToEmit(F, GD);
-
       // Otherwise, there are cases we have to worry about where we're
       // using a declaration for which we must emit a definition but where
       // we might not find a top-level definition:
       //   - member functions defined inline in their classes
       //   - friend functions defined inline in some class
       //   - special member functions with implicit definitions
       // If we ever change our AST traversal to walk into class methods,
       // this will be unnecessary.

lib/Driver/Tools.cpp

   if (getToolChain().UseSjLjExceptions())
     CmdArgs.push_back("-fsjlj-exceptions");
 
   // C++ "sane" operator new.
   if (!Args.hasFlag(options::OPT_fassume_sane_operator_new,
                     options::OPT_fno_assume_sane_operator_new))
     CmdArgs.push_back("-fno-assume-sane-operator-new");
 
+  // -fsized-deallocation is off by default, as it is an ABI-breaking change for
+  // most platforms.
+  if (Args.hasFlag(options::OPT_fsized_deallocation,
+                   options::OPT_fno_sized_deallocation, false))
+    CmdArgs.push_back("-fsized-deallocation");
+
   // -fconstant-cfstrings is default, and may be subject to argument translation
   // on Darwin.
   if (!Args.hasFlag(options::OPT_fconstant_cfstrings,
                     options::OPT_fno_constant_cfstrings) ||
       !Args.hasFlag(options::OPT_mconstant_cfstrings,
                     options::OPT_mno_constant_cfstrings))
     CmdArgs.push_back("-fno-constant-cfstrings");
 

lib/Frontend/CompilerInvocation.cpp

void CompilerInvocation::setLangDefaults(LangOptions &Opts, InputKind IK,
 
   // C++ has wchar_t keyword.
   Opts.WChar = Opts.CPlusPlus;
 
   Opts.GNUKeywords = Opts.GNUMode;
   Opts.CXXOperatorNames = Opts.CPlusPlus;
 
   Opts.DollarIdents = !Opts.AsmPreprocessor;
-
-  // C++14 onwards has sized global deallocation functions.
-  Opts.SizedDeallocation = Opts.CPlusPlus14;
 }
 
 /// Attempt to parse a visibility value out of the given argument.
 static Visibility parseVisibility(Arg *arg, ArgList &args,
                                   DiagnosticsEngine &diags) {
   StringRef value = arg->getValue();
   if (value == "default") {
     return DefaultVisibility;
#include "clang/Frontend/LangStandards.def"
   Opts.CharIsSigned = Opts.OpenCL || !Args.hasArg(OPT_fno_signed_char);
   Opts.WChar = Opts.CPlusPlus && !Args.hasArg(OPT_fno_wchar);
   Opts.ShortWChar = Args.hasFlag(OPT_fshort_wchar, OPT_fno_short_wchar, false);
   Opts.ShortEnums = Args.hasArg(OPT_fshort_enums);
   Opts.Freestanding = Args.hasArg(OPT_ffreestanding);
   Opts.NoBuiltin = Args.hasArg(OPT_fno_builtin) || Opts.Freestanding;
   Opts.NoMathBuiltin = Args.hasArg(OPT_fno_math_builtin);
   Opts.AssumeSaneOperatorNew = !Args.hasArg(OPT_fno_assume_sane_operator_new);
-  Opts.SizedDeallocation |= Args.hasArg(OPT_fsized_deallocation);
-  Opts.SizedDeallocation &= !Args.hasArg(OPT_fno_sized_deallocation);
-  Opts.DefineSizedDeallocation = Opts.SizedDeallocation &&
-      Args.hasArg(OPT_fdefine_sized_deallocation);
+  Opts.SizedDeallocation = Args.hasArg(OPT_fsized_deallocation);
   Opts.HeinousExtensions = Args.hasArg(OPT_fheinous_gnu_extensions);
   Opts.AccessControl = !Args.hasArg(OPT_fno_access_control);
   Opts.ElideConstructors = !Args.hasArg(OPT_fno_elide_constructors);
   Opts.MathErrno = !Opts.OpenCL && Args.hasArg(OPT_fmath_errno);
   Opts.InstantiationDepth =
       getLastArgIntValue(Args, OPT_ftemplate_depth, 256, Diags);
   Opts.ArrowDepth =
       getLastArgIntValue(Args, OPT_foperator_arrow_depth, 256, Diags);

lib/Sema/SemaExprCXX.cpp

static bool isNonPlacementDeallocationFunction(Sema &S, FunctionDecl *FD) {
 
   if (FD->getOverloadedOperator() != OO_Delete &&
       FD->getOverloadedOperator() != OO_Array_Delete)
     return false;
 
   if (FD->getNumParams() == 1)
     return true;
 
-  return S.getLangOpts().SizedDeallocation && FD->getNumParams() == 2 &&
+  // In C++14, the sized deallocation functions are not considered placement
+  // functions.
+  return S.getLangOpts().CPlusPlus14 && FD->getNumParams() == 2 &&
          S.Context.hasSameUnqualifiedType(FD->getParamDecl(1)->getType(),
                                           S.Context.getSizeType());
 }
 
+static FunctionDecl *chooseSizedOrUnsizedDeallocation(const LangOptions &LO,
+                                                      FunctionDecl *F1,
+                                                      FunctionDecl *F2,
+                                                      bool CanProvideSize) {
+  // We only use the sized deallocation function if we know library support is
+  // present, either from the user or the standard library. The user can pass
+  // -fsized-deallocation, or the driver can detect that the platform standard
+  // library supports sized deallocation. If we're not doing sized deallocation,
+  // we still need to filter out the sized declaration present in C++14.
+  assert(LO.CPlusPlus14);
+  unsigned NumArgs = LO.SizedDeallocation && CanProvideSize ? 2 : 1;
+  if (F1->getNumParams() == NumArgs)
+    return F1;
+  assert(F2->getNumParams() == NumArgs &&
+         "found an unexpected usual deallocation function");
+  return F2;
+}
+
 /// 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, MultiExprArg PlaceArgs,
                                    FunctionDecl *&OperatorNew,
                                    FunctionDecl *&OperatorDelete) {
   // --- Choosing an allocation function ---
if (isPlacementNew) {
     //   function lookup is used
     // 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");
+    if (getLangOpts().CPlusPlus14 && Matches.size() == 2) {
+      FunctionDecl *F = chooseSizedOrUnsizedDeallocation(
+          getLangOpts(), Matches[0].second, Matches[1].second,
+          /*CanProvideSize=*/true);
+      if (Matches[0].second != F)
+        std::swap(Matches[0], Matches[1]);
+      Matches.resize(1);
     }
   }
 
   // C++ [expr.new]p20:
   //   [...] If the lookup finds a single matching deallocation
   //   function, that function will be called; otherwise, no
   //   deallocation function will be called.
   if (Matches.size() == 1) {
DeclareGlobalAllocationFunction(
       Context.DeclarationNames.getCXXOperatorName(OO_Array_New),
       VoidPtr, SizeT, QualType(), AssumeSaneOperatorNew);
   DeclareGlobalAllocationFunction(
       Context.DeclarationNames.getCXXOperatorName(OO_Delete),
       Context.VoidTy, VoidPtr);
   DeclareGlobalAllocationFunction(
       Context.DeclarationNames.getCXXOperatorName(OO_Array_Delete),
       Context.VoidTy, VoidPtr);
-  if (getLangOpts().SizedDeallocation) {
+
+  // Implicitly declare the sized deallocation operators in C++14. CodeGen will
+  // not use them unless -fsized-deallocation was passed.
+  if (getLangOpts().CPlusPlus14) {
     DeclareGlobalAllocationFunction(
         Context.DeclarationNames.getCXXOperatorName(OO_Delete),
         Context.VoidTy, VoidPtr, Context.getSizeType());
     DeclareGlobalAllocationFunction(
         Context.DeclarationNames.getCXXOperatorName(OO_Array_Delete),
         Context.VoidTy, VoidPtr, Context.getSizeType());
   }
 }
if (FunctionDecl *Func = dyn_cast<FunctionDecl>(*Alloc)) {
           // an unimported module. It either is an implicitly-declared global
           // allocation function, or is suppressing that function.
           Func->setHidden(false);
           return;
         }
       }
     }
   }
-  
-  // If the function is sized operator delete and has not already been
-  // declared, and weak definitions have been disabled, do not declare
-  // it implicitly. Instead, let deallocation function lookup pick up
-  // unsized delete.
-  // FIXME: We should remove this guard once backward compatibility is
-  // no longer an issue
-  if (NumParams == 2 && !getLangOpts().DefineSizedDeallocation)
-    return;
-
   FunctionProtoType::ExtProtoInfo EPI;
 
   QualType BadAllocType;
   bool HasBadAllocExceptionSpec
     = (Name.getCXXOverloadedOperator() == OO_New ||
        Name.getCXXOverloadedOperator() == OO_Array_New);
   if (HasBadAllocExceptionSpec) {
     if (!getLangOpts().CPlusPlus11) {
FunctionDecl *Sema::FindUsualDeallocationFunction(SourceLocation StartLoc,
 
   // 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");
+  if (getLangOpts().CPlusPlus14 && Matches.size() == 2) {
+    FunctionDecl *F = chooseSizedOrUnsizedDeallocation(
+        getLangOpts(), Matches[0], Matches[1], CanProvideSize);
+    Matches[0] = F;
+    Matches.resize(1);
   }
 
   assert(Matches.size() == 1 &&
          "unexpectedly have multiple usual deallocation functions");
   return Matches.front();
 }
 
 bool Sema::FindDeallocationFunction(SourceLocation StartLoc, CXXRecordDecl *RD,

test/CodeGenCXX/cxx1y-sized-deallocation.cpp

-// RUN: %clang_cc1 -std=c++1y %s -emit-llvm -triple x86_64-linux-gnu -o - | FileCheck %s --check-prefix=CHECK-UNSIZED
-// RUN: %clang_cc1 -std=c++1y %s -emit-llvm -triple x86_64-linux-gnu -o - -DINLIB | FileCheck %s --check-prefix=CHECK --check-prefix=CHECKUND
-// RUN: %clang_cc1 -std=c++1y %s -emit-llvm -triple x86_64-linux-gnu -fdefine-sized-deallocation -o - | FileCheck %s --check-prefix=CHECK --check-prefix=CHECKDEF
-// RUN: %clang_cc1 -std=c++11 -fsized-deallocation %s -emit-llvm -triple x86_64-linux-gnu -o - | FileCheck %s --check-prefix=CHECK-UNSIZED
-// RUN: %clang_cc1 -std=c++11 -fsized-deallocation %s -emit-llvm -triple x86_64-linux-gnu -o - -DINLIB | FileCheck %s --check-prefix=CHECK --check-prefix=CHECKUND
-// RUN: %clang_cc1 -std=c++11 -fsized-deallocation -fdefine-sized-deallocation %s -emit-llvm -triple x86_64-linux-gnu -o - | FileCheck %s --check-prefix=CHECK --check-prefix=CHECKDEF
+// Check that delete exprs call the sized deallocation function if
+// -fsized-deallocation is passed.
+// RUN: %clang_cc1 -std=c++14 -fsized-deallocation %s -emit-llvm -triple x86_64-linux-gnu -o - | FileCheck %s --check-prefix=CHECK --check-prefix=CHECKUND
+
+// Check that we don't used sized deallocation without -fsized-deallocation and
+// C++14.
 // RUN: %clang_cc1 -std=c++11 %s -emit-llvm -triple x86_64-linux-gnu -o - | FileCheck %s --check-prefix=CHECK-UNSIZED
-// RUN: %clang_cc1 -std=c++1y %s -emit-llvm -triple x86_64-linux-gnu -fno-sized-deallocation -o - | FileCheck %s --check-prefix=CHECK-UNSIZED
+// RUN: %clang_cc1 -std=c++14 %s -emit-llvm -triple x86_64-linux-gnu -o - | FileCheck %s --check-prefix=CHECK-UNSIZED
+// RUN: %clang_cc1 -std=c++11 -fsized-deallocation %s -emit-llvm -triple x86_64-linux-gnu -o - | FileCheck %s --check-prefix=CHECK-UNSIZED
 
 // CHECK-UNSIZED-NOT: _ZdlPvm
 // CHECK-UNSIZED-NOT: _ZdaPvm
 
 typedef decltype(sizeof(0)) size_t;
 
-#ifdef INLIB
-void operator delete(void *, size_t) noexcept;
-void operator delete[](void *, size_t) noexcept;
-#endif
-
 typedef int A;
 struct B { int n; };
 struct C { ~C() {} };
 struct D { D(); virtual ~D() {} };
 struct E {
   void *operator new(size_t);
   void *operator new[](size_t);
   void operator delete(void *) noexcept;

 
 // CHECK-LABEL: define weak_odr void @_Z3delIiEvv()
 // CHECK: call void @_ZdlPvm(i8* %{{[^ ]*}}, i64 4)
 // CHECK: call void @_ZdaPv(i8* %{{[^ ]*}})
 //
 // CHECK: call void @_ZdlPvm(i8* %{{[^ ]*}}, i64 4)
 // CHECK: call void @_ZdaPv(i8* %{{[^ ]*}})
 
-// CHECKDEF-LABEL: define linkonce void @_ZdlPvm(i8*, i64) #{{[0-9]+}} comdat
-// CHECKDEF: call void @_ZdlPv(i8* %0)
 // CHECKUND-LABEL: declare void @_ZdlPvm(i8*
 
 // CHECK-LABEL: define weak_odr void @_Z3delI1BEvv()
 // CHECK: call void @_ZdlPvm(i8* %{{[^ ]*}}, i64 4)
 // CHECK: call void @_ZdaPv(i8* %{{[^ ]*}})
 //
 // CHECK: call void @_ZdlPvm(i8* %{{[^ ]*}}, i64 4)
 // CHECK: call void @_ZdaPv(i8* %{{[^ ]*}})
 
 // CHECK-LABEL: define weak_odr void @_Z3delI1CEvv()
 // CHECK: call void @_ZdlPvm(i8* %{{[^ ]*}}, i64 1)
 // CHECK: mul i64 1, %{{[^ ]*}}
 // CHECK: add i64 %{{[^ ]*}}, 8
 // CHECK: call void @_ZdaPvm(i8* %{{[^ ]*}}, i64 %{{[^ ]*}})
 //
 // CHECK: call void @_ZdlPvm(i8* %{{[^ ]*}}, i64 1)
 // CHECK: mul i64 1, %{{[^ ]*}}
 // CHECK: add i64 %{{[^ ]*}}, 8
 // CHECK: call void @_ZdaPvm(i8* %{{[^ ]*}}, i64 %{{[^ ]*}})
 
-// CHECKDEF-LABEL: define linkonce void @_ZdaPvm(i8*, i64) #{{[0-9]+}} comdat
-// CHECKDEF: call void @_ZdaPv(i8* %0)
 // CHECKUND-LABEL: declare void @_ZdaPvm(i8*
 
 // CHECK-LABEL: define weak_odr void @_Z3delI1DEvv()
 // CHECK: call void @_ZdlPvm(i8* %{{[^ ]*}}, i64 8)
 // CHECK: mul i64 8, %{{[^ ]*}}
 // CHECK: add i64 %{{[^ ]*}}, 8
 // CHECK: call void @_ZdaPvm(i8* %{{[^ ]*}}, i64 %{{[^ ]*}})
 //

test/CodeGenCXX/implicit-allocation-functions.cpp

-// RUN: %clang_cc1 -emit-llvm -triple x86_64-unknown-unknown -o - -std=c++11 %s 2>&1 | FileCheck %s -check-prefix=CHECKDEF -check-prefix=CHECK11
-// RUN: %clang_cc1 -emit-llvm -triple x86_64-unknown-unknown -o - -std=c++11 -fvisibility hidden %s 2>&1 | FileCheck %s -check-prefix=CHECKHID -check-prefix=CHECK11
-// RUN: %clang_cc1 -emit-llvm -triple x86_64-unknown-unknown -o - -std=c++14 -DINLIB -fno-sized-deallocation %s 2>&1 | FileCheck %s -check-prefix=CHECKDEF -check-prefix=CHECK11
-// RUN: %clang_cc1 -emit-llvm -triple x86_64-unknown-unknown -o - -std=c++14 -DINLIB %s 2>&1 | FileCheck %s -check-prefix=CHECKDEF -check-prefix=CHECK14 -check-prefix=CHECK14UND
-// RUN: %clang_cc1 -emit-llvm -triple x86_64-unknown-unknown -o - -std=c++14 -DINLIB -fvisibility hidden %s 2>&1 | FileCheck %s -check-prefix=CHECKHID -check-prefix=CHECK14 -check-prefix=CHECK14UND
-// RUN: %clang_cc1 -emit-llvm -triple x86_64-unknown-unknown -o - -std=c++14 -DINLIB -fdefine-sized-deallocation %s 2>&1 | FileCheck %s -check-prefix=CHECKDEF -check-prefix=CHECK14 -check-prefix=CHECK14DEFCOMDAT
-// RUN: %clang_cc1 -emit-llvm -triple x86_64-unknown-unknown -o - -std=c++14 -DINLIB -fdefine-sized-deallocation -fvisibility hidden %s 2>&1 | FileCheck %s -check-prefix=CHECKHID -check-prefix=CHECK14 -check-prefix=CHECK14DEFCOMDAT
-// RUN: %clang_cc1 -emit-llvm -triple x86_64-apple-macosx -o - -std=c++14 -DINLIB -fdefine-sized-deallocation %s | FileCheck %s -check-prefix=CHECKDEF -check-prefix=CHECK14 -check-prefix=CHECK14DEFNOCOMDAT
-
-// PR22419: Implicit sized deallocation functions always have default visibility.
-//   Generalized to all implicit allocation functions.
-
-#ifdef INLIB
-typedef decltype(sizeof(0)) size_t;
-void operator delete(void *, size_t) noexcept;
-void operator delete[](void *, size_t) noexcept;
-#endif
-
-// CHECK14-DAG: %struct.A = type { i8 }
-struct A { };
-
-// CHECKDEF-DAG: define void @_Z3fooP1A(%struct.A* %is)
-// CHECKHID-DAG: define hidden void @_Z3fooP1A(%struct.A* %is)
-void foo(A* is) {
-
-  // CHECK11-DAG: call noalias i8* @_Znwm(i64 1)
-  // CHECK14-DAG: call noalias i8* @_Znwm(i64 1)
-  is = new A();
-
-  // CHECK11-DAG: call void @_ZdlPv(i8* %{{.+}})
-  // CHECK14-DAG: call void @_ZdlPvm(i8* %{{.+}}, i64 1)
-  delete is;
-}
-
-// CHECK11-DAG: declare noalias i8* @_Znwm(i64)
-// CHECK11-DAG: declare void @_ZdlPv(i8*)
-
-// CHECK14-DAG: declare noalias i8* @_Znwm(i64)
-// CHECK14UND-DAG: declare void @_ZdlPvm(i8*, i64)
-// CHECK14DEFCOMDAT-DAG: define linkonce void @_ZdlPvm(i8*, i64) #{{[0-9]+}} comdat {
-// CHECK14DEFCOMDAT-DAG: declare void @_ZdlPv(i8*)
-// CHECK14DEFNOCOMDAT-DAG: define linkonce void @_ZdlPvm(i8*, i64) #{{[0-9]+}} {
-// CHECK14DEFNOCOMDAT-DAG: declare void @_ZdlPv(i8*)
-
-// CHECK14-DAG: %struct.B = type { i8 }
-struct B { ~B() { }};
-
-// CHECKDEF-DAG: define void @_Z1fP1B(%struct.B* %p)
-// CHECKHID-DAG: define hidden void @_Z1fP1B(%struct.B* %p)
-void f(B *p) {
-
-  // CHECK11-DAG: call noalias i8* @_Znam(i64 13)
-  // CHECK14-DAG: call noalias i8* @_Znam(i64 13)
-  p = new B[5];
-
-  // CHECK11-DAG: call void @_ZdaPv(i8* %{{.+}})
-  // CHECK14-DAG: call void @_ZdaPvm(i8* %{{.+}}, i64 %{{.+}})
-  delete[] p;
-}
-
-// CHECK11-DAG: declare noalias i8* @_Znam(i64)
-// CHECK11-DAG: declare void @_ZdaPv(i8*)
-
-// CHECK14-DAG: declare noalias i8* @_Znam(i64)
-// CHECK14UND-DAG: declare void @_ZdaPvm(i8*, i64)
-// CHECK14DEF-DAG: define linkonce void @_ZdaPvm(i8*, i64) #{{[0-9]+}} comdat {
-// CHECK14DEF-DAG: declare void @_ZdaPv(i8*)
-// CHECK14DEFNOCOMDAT-DAG: define linkonce void @_ZdaPvm(i8*, i64) #{{[0-9]+}} {
-// CHECK14DEFNOCOMDAT-DAG: declare void @_ZdaPv(i8*)

test/CodeGenCXX/pr21754.cpp

-// RUN: %clang -cc1 -emit-llvm -triple x86_64-unknown-unknown -std=c++1y -o - %s 2>&1 | FileCheck %s
-// RUN: %clang -cc1 -emit-llvm -triple x86_64-unknown-unknown -std=c++1y -fdefine-sized-deallocation -o - %s 2>&1 | FileCheck %s
-// RUN: %clang -cc1 -emit-llvm -triple x86_64-unknown-unknown -std=c++1y -fno-sized-deallocation -o - %s 2>&1 | FileCheck %s
-// RUN: %clang -cc1 -emit-llvm -triple x86_64-unknown-unknown -std=c++11 -fsized-deallocation -o - %s 2>&1 | FileCheck %s
-// RUN: %clang -cc1 -emit-llvm -triple x86_64-unknown-unknown -std=c++11 -fsized-deallocation -fdefine-sized-deallocation -o - %s 2>&1 | FileCheck %s
-// RUN: %clang -cc1 -emit-llvm -triple x86_64-unknown-unknown -std=c++11 -o - %s 2>&1 | FileCheck %s
-
-void operator delete(void*, unsigned long) throw() __attribute__((alias("foo")));
-extern "C" void foo(void*, unsigned long) {}
-
-// CHECK-DAG: @_ZdlPvm = alias void (i8*, i64)* @foo

test/Lexer/cxx-features.cpp

 // RUN: %clang_cc1 -std=c++98 -verify %s
 // RUN: %clang_cc1 -std=c++11 -verify %s
-// RUN: %clang_cc1 -std=c++1y -verify %s
+// RUN: %clang_cc1 -std=c++1y -fsized-deallocation -verify %s
 
 // expected-no-diagnostics
 
 #if __cplusplus < 201103L
 #define check(macro, cxx98, cxx11, cxx1y) cxx98 == 0 ? defined(__cpp_##macro) : __cpp_##macro != cxx98
 #elif __cplusplus < 201304L
 #define check(macro, cxx98, cxx11, cxx1y) cxx11 == 0 ? defined(__cpp_##macro) : __cpp_##macro != cxx11
 #else