Dummy patch with changes to C++14 sized deallocation and diagnostics.

[EricWF]

Summary

Just putting this up so I can personally use phab to review it.

include/clang/AST/Decl.h

 #include "clang/Basic/OperatorKinds.h"
 #include "clang/Basic/PartialDiagnostic.h"
 #include "clang/Basic/PragmaKinds.h"
 #include "clang/Basic/SourceLocation.h"
 #include "clang/Basic/Specifiers.h"
 #include "clang/Basic/Visibility.h"
 #include "llvm/ADT/APSInt.h"
 #include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/BitmaskEnum.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/PointerIntPair.h"
 #include "llvm/ADT/PointerUnion.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/iterator_range.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/TrailingObjects.h"

   ///    These functions are reserved, a C++ program may not define
   ///    functions that displace the versions in the Standard C++ library.
   ///    The provisions of [basic.stc.dynamic] do not apply to these
   ///    reserved placement forms of operator new and operator delete.
   ///
   /// This function must be an allocation or deallocation function.
   bool isReservedGlobalPlacementOperator() const;
 
+  enum class AllocationFunctionClassification : unsigned {
+    None = 0,
+    Allocation = 1 << 0,
+    Deallocation = 1 << 1,
+    Aligned = 1 << 2,
+    Sized = 1 << 3,
+    Array = 1 << 4,
+    LLVM_BITMASK_LARGEST_ENUMERATOR = Array,
+  };
+
   /// Determines whether this function is one of the replaceable
-  /// global allocation functions:
+  /// global allocation functions, and classifies the kind of allocation or
+  /// deallocation function it is:
   ///    void *operator new(size_t);
   ///    void *operator new(size_t, const std::nothrow_t &) noexcept;
   ///    void *operator new[](size_t);
   ///    void *operator new[](size_t, const std::nothrow_t &) noexcept;
   ///    void operator delete(void *) noexcept;
   ///    void operator delete(void *, std::size_t) noexcept;      [C++1y]
   ///    void operator delete(void *, const std::nothrow_t &) noexcept;
   ///    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. [...]
   ///
-  /// If this function is an aligned allocation/deallocation function, return
-  /// true through IsAligned.
-  bool isReplaceableGlobalAllocationFunction(bool *IsAligned = nullptr) const;
+  AllocationFunctionClassification
+  classifyReplaceableGlobalAllocationFunction() const;
+
+  bool isReplaceableGlobalAllocationFunction() const {
+    return classifyReplaceableGlobalAllocationFunction() !=
+           AllocationFunctionClassification::None;
+  }
 
   /// Determine whether this is a destroying operator delete.
   bool isDestroyingOperatorDelete() const;
 
   /// Compute the language linkage.
   LanguageLinkage getLanguageLinkage() const;
 
   /// Determines whether this function is a function with

   static DeclContext *castToDeclContext(const FunctionDecl *D) {
     return static_cast<DeclContext *>(const_cast<FunctionDecl*>(D));
   }
   static FunctionDecl *castFromDeclContext(const DeclContext *DC) {
     return static_cast<FunctionDecl *>(const_cast<DeclContext*>(DC));
   }
 };
 
+// Used by FunctionDecl::AllocationFunctionClassification
+LLVM_ENABLE_BITMASK_ENUMS_IN_NAMESPACE();
+
 /// Represents a member of a struct/union/class.
 class FieldDecl : public DeclaratorDecl, public Mergeable<FieldDecl> {
   unsigned BitField : 1;
   unsigned Mutable : 1;
   mutable unsigned CachedFieldIndex : 30;
 
   /// The kinds of value we can store in InitializerOrBitWidth.
   ///

include/clang/Basic/AlignedAllocation.h

-//===--- AlignedAllocation.h - Aligned Allocation ---------------*- C++ -*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-///
-/// \file
-/// Defines a function that returns the minimum OS versions supporting
-/// C++17's aligned allocation functions.
-///
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_CLANG_BASIC_ALIGNED_ALLOCATION_H
-#define LLVM_CLANG_BASIC_ALIGNED_ALLOCATION_H
-
-#include "clang/Basic/VersionTuple.h"
-#include "llvm/ADT/Triple.h"
-#include "llvm/Support/ErrorHandling.h"
-
-namespace clang {
-
-inline VersionTuple alignedAllocMinVersion(llvm::Triple::OSType OS) {
-  switch (OS) {
-  default:
-    break;
-  case llvm::Triple::Darwin:
-  case llvm::Triple::MacOSX: // Earliest supporting version is 10.13.
-    return VersionTuple(10U, 13U);
-  case llvm::Triple::IOS:
-  case llvm::Triple::TvOS: // Earliest supporting version is 11.0.0.
-    return VersionTuple(11U);
-  case llvm::Triple::WatchOS: // Earliest supporting version is 4.0.0.
-    return VersionTuple(4U);
-  }
-
-  llvm_unreachable("Unexpected OS");
-}
-
-} // end namespace clang
-
-#endif // LLVM_CLANG_BASIC_ALIGNED_ALLOCATION_H

include/clang/Basic/AllocationAvailability.h

+//===--- AllocationAvailability.h - Allocation Availability -----*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// Defines a functions that return the minimum OS versions supporting various
+/// C++ allocation functions. Including C++17's aligned allocation and C++14's
+/// sized deallocation.
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_BASIC_ALLOCATION_AVAILABILITY_H
+#define LLVM_CLANG_BASIC_ALLOCATION_AVAILABILITY_H
+
+#include "clang/Basic/VersionTuple.h"
+#include "llvm/ADT/Triple.h"
+#include "llvm/Support/ErrorHandling.h"
+
+namespace clang {
+
+inline VersionTuple alignedAllocMinVersion(llvm::Triple::OSType OS) {
+  switch (OS) {
+  default:
+    break;
+  case llvm::Triple::Darwin:
+  case llvm::Triple::MacOSX: // Earliest supporting version is 10.13.
+    return VersionTuple(10U, 13U);
+  case llvm::Triple::IOS:
+  case llvm::Triple::TvOS: // Earliest supporting version is 11.0.0.
+    return VersionTuple(11U);
+  case llvm::Triple::WatchOS: // Earliest supporting version is 4.0.0.
+    return VersionTuple(4U);
+  }
+
+  llvm_unreachable("Unexpected OS");
+}
+
+inline VersionTuple sizedDeallocMinVersion(llvm::Triple::OSType OS) {
+  switch (OS) {
+  default:
+    break;
+  case llvm::Triple::Darwin:
+  case llvm::Triple::MacOSX: // Earliest supporting version is 10.12.
+    return VersionTuple(10U, 12U);
+  case llvm::Triple::IOS:
+  case llvm::Triple::TvOS: // Earliest supporting version is 11.0.0.
+    return VersionTuple(10U);
+  case llvm::Triple::WatchOS: // Earliest supporting version is 4.0.0.
+    return VersionTuple(3U);
+  }
+
+  llvm_unreachable("Unexpected OS");
+}
+
+} // end namespace clang
+
+#endif // LLVM_CLANG_BASIC_ALLOCATION_AVAILABILITY_H

include/clang/Basic/DiagnosticGroups.td

 def NonNull : DiagGroup<"nonnull">;
 def NonPODVarargs : DiagGroup<"non-pod-varargs">;
 def ClassVarargs : DiagGroup<"class-varargs", [NonPODVarargs]>;
 def : DiagGroup<"nonportable-cfstrings">;
 def NonVirtualDtor : DiagGroup<"non-virtual-dtor">;
 def NullPointerArithmetic : DiagGroup<"null-pointer-arithmetic">;
 def : DiagGroup<"effc++", [NonVirtualDtor]>;
 def OveralignedType : DiagGroup<"over-aligned">;
-def AlignedAllocationUnavailable : DiagGroup<"aligned-allocation-unavailable">;
 def OldStyleCast : DiagGroup<"old-style-cast">;
 def : DiagGroup<"old-style-definition">;
 def OutOfLineDeclaration : DiagGroup<"out-of-line-declaration">;
 def : DiagGroup<"overflow">;
 def ForwardClassReceiver : DiagGroup<"receiver-forward-class">;
 def MethodAccess : DiagGroup<"objc-method-access">;
 def ObjCReceiver : DiagGroup<"receiver-expr">;
 def OperatorNewReturnsNull : DiagGroup<"new-returns-null">;

include/clang/Basic/DiagnosticSemaKinds.td

   "|: different exception specifications}1">;
 def warn_using_directive_in_header : Warning<
   "using namespace directive in global context in header">,
   InGroup<HeaderHygiene>, DefaultIgnore;
 def warn_overaligned_type : Warning<
   "type %0 requires %1 bytes of alignment and the default allocator only "
   "guarantees %2 bytes">,
   InGroup<OveralignedType>, DefaultIgnore;
-def warn_aligned_allocation_unavailable :Warning<
-  "aligned %select{allocation|deallocation}0 function of type '%1' is only "
-  "available on %2 %3 or newer">, InGroup<AlignedAllocationUnavailable>, DefaultError;
-def note_silence_unligned_allocation_unavailable : Note<
-  "if you supply your own aligned allocation functions, use "
-  "-Wno-aligned-allocation-unavailable to silence this diagnostic">;
+def err_allocation_function_unavailable : Error<
+  "%select{aligned allocation|aligned deallocation|sized deallocation}0 function "
+  "of type '%1' is only available on %2 %3 or newer">;
+def note_silence_allocation_function_unavailable : Note<
+  "if you supply your own "
+  "%select{aligned allocation|aligned allocation|sized deallocation}0 functions, use "
+  "%select{-faligned-allocation|-faligned-allocation|-fsized-deallocation}0 to "
+  "silence this diagnostic">;
 
 def err_conditional_void_nonvoid : Error<
   "%select{left|right}1 operand to ? is void, but %select{right|left}1 operand "
   "is of type %0">;
 def err_conditional_ambiguous : Error<
   "conditional expression is ambiguous; "
   "%diff{$ can be converted to $ and vice versa|"
   "types can be convert to each other}0,1">;

include/clang/Basic/LangOptions.def

 LANGOPT(CUDAIsDevice      , 1, 0, "compiling for CUDA device")
 LANGOPT(CUDAAllowVariadicFunctions, 1, 0, "allowing variadic functions in CUDA device code")
 LANGOPT(CUDAHostDeviceConstexpr, 1, 1, "treating unattributed constexpr functions as __host__ __device__")
 LANGOPT(CUDADeviceFlushDenormalsToZero, 1, 0, "flushing denormals to zero")
 LANGOPT(CUDADeviceApproxTranscendentals, 1, 0, "using approximate transcendental functions")
 LANGOPT(CUDARelocatableDeviceCode, 1, 0, "generate relocatable device code")
 
 LANGOPT(SizedDeallocation , 1, 0, "sized deallocation")
+LANGOPT(SizedDeallocationUnavailable, 1, 0, "sized deallocation functions are unavailable")
 LANGOPT(AlignedAllocation , 1, 0, "aligned allocation")
 LANGOPT(AlignedAllocationUnavailable, 1, 0, "aligned allocation functions are unavailable")
+
 LANGOPT(NewAlignOverride  , 32, 0, "maximum alignment guaranteed by '::operator new(size_t)'")
 LANGOPT(ConceptsTS , 1, 0, "enable C++ Extensions for Concepts")
 BENIGN_LANGOPT(ModulesCodegen , 1, 0, "Modules code generation")
 BENIGN_LANGOPT(ModulesDebugInfo , 1, 0, "Modules debug info")
 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")

include/clang/Driver/CC1Options.td

def find_pch_source_EQ : Joined<["-"], "find-pch-source=">,
   HelpText<"When building a pch, try to find the input file in include "
            "directories, as if it had been included by the argument passed "
            "to this flag.">;
 def fno_pch_timestamp : Flag<["-"], "fno-pch-timestamp">,
   HelpText<"Disable inclusion of timestamp in precompiled headers">;
   
 def aligned_alloc_unavailable : Flag<["-"], "faligned-alloc-unavailable">,
   HelpText<"Aligned allocation/deallocation functions are unavailable">;
+def sized_deallocation_unavailable : Flag<["-"], "fsized-deallocation-unavailable">,
+  HelpText<"Sized deallocation functions are unavailable">;
+
 
 //===----------------------------------------------------------------------===//
 // Language Options
 //===----------------------------------------------------------------------===//
 
 let Flags = [CC1Option, CC1AsOption, NoDriverOption] in {
 
 def version : Flag<["-"], "version">,

include/clang/Driver/Options.td

   Group<f_Group>;
 def frelaxed_template_template_args : Flag<["-"], "frelaxed-template-template-args">,
   Flags<[CC1Option]>, HelpText<"Enable C++17 relaxed template template argument matching">,
   Group<f_Group>;
 def fno_relaxed_template_template_args : Flag<["-"], "fno-relaxed-template-template-args">,
   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 fno_sized_deallocation: Flag<["-"], "fno-sized-deallocation">, Flags<[CC1Option]>,
+  HelpText<"Disable C++14 sized global deallocation functions">, Group<f_Group>;
 def faligned_allocation : Flag<["-"], "faligned-allocation">, Flags<[CC1Option]>,
   HelpText<"Enable C++17 aligned allocation functions">, Group<f_Group>;
 def fno_aligned_allocation: Flag<["-"], "fno-aligned-allocation">,
   Group<f_Group>, Flags<[CC1Option]>;
 def fnew_alignment_EQ : Joined<["-"], "fnew-alignment=">,
   HelpText<"Specifies the largest alignment guaranteed by '::operator new(size_t)'">,
   MetaVarName<"<align>">, Group<f_Group>, Flags<[CC1Option]>;
 def : Separate<["-"], "fnew-alignment">, Alias<fnew_alignment_EQ>;

include/clang/Sema/Sema.h

                                 bool Diagnose = true);
   FunctionDecl *FindUsualDeallocationFunction(SourceLocation StartLoc,
                                               bool CanProvideSize,
                                               bool Overaligned,
                                               DeclarationName Name);
   FunctionDecl *FindDeallocationFunctionForDestructor(SourceLocation StartLoc,
                                                       CXXRecordDecl *RD);
 
+  void DiagnoseUnavailableAllocationFunction(const FunctionDecl *FD,
+                                             SourceLocation Loc);
+
   /// ActOnCXXDelete - Parsed a C++ 'delete' expression
   ExprResult ActOnCXXDelete(SourceLocation StartLoc,
                             bool UseGlobal, bool ArrayForm,
                             Expr *Operand);
   void CheckVirtualDtorCall(CXXDestructorDecl *dtor, SourceLocation Loc,
                             bool IsDelete, bool CallCanBeVirtual,
                             bool WarnOnNonAbstractTypes,
                             SourceLocation DtorLoc);

lib/AST/Decl.cpp

     cast<TranslationUnitDecl>(getDeclContext()->getRedeclContext())
       ->getASTContext();
 
   // The result type and first argument type are constant across all
   // these operators.  The second argument must be exactly void*.
   return (proto->getParamType(1).getCanonicalType() == Context.VoidPtrTy);
 }
 
-bool FunctionDecl::isReplaceableGlobalAllocationFunction(bool *IsAligned) const {
+FunctionDecl::AllocationFunctionClassification
+FunctionDecl::classifyReplaceableGlobalAllocationFunction() const {
+  using AFC = AllocationFunctionClassification;
   if (getDeclName().getNameKind() != DeclarationName::CXXOperatorName)
-    return false;
-  if (getDeclName().getCXXOverloadedOperator() != OO_New &&
-      getDeclName().getCXXOverloadedOperator() != OO_Delete &&
-      getDeclName().getCXXOverloadedOperator() != OO_Array_New &&
-      getDeclName().getCXXOverloadedOperator() != OO_Array_Delete)
-    return false;
+    return AFC::None;
+  OverloadedOperatorKind OpKind = getDeclName().getCXXOverloadedOperator();
+  std::pair<OverloadedOperatorKind, AFC> Classifications[] = {
+      {OO_New, AFC::Allocation},
+      {OO_Array_New, AFC::Allocation | AFC::Array},
+      {OO_Delete, AFC::Deallocation},
+      {OO_Array_Delete, AFC::Deallocation | AFC::Array}};
+  auto It = llvm::find_if(Classifications,
+                          [&](std::pair<OverloadedOperatorKind, AFC> Info) {
+                            return Info.first == OpKind;
+                          });
+  if (It == std::end(Classifications))
+    return AFC::None;
+
+  AFC Result = It->second;
 
   if (isa<CXXRecordDecl>(getDeclContext()))
-    return false;
+    return AFC::None;
 
   // This can only fail for an invalid 'operator new' declaration.
   if (!getDeclContext()->getRedeclContext()->isTranslationUnit())
-    return false;
+    return AFC::None;
 
   const auto *FPT = getType()->castAs<FunctionProtoType>();
   if (FPT->getNumParams() == 0 || FPT->getNumParams() > 3 || FPT->isVariadic())
-    return false;
+    return AFC::None;
 
   // If this is a single-parameter function, it must be a replaceable global
   // allocation or deallocation function.
   if (FPT->getNumParams() == 1)
-    return true;
+    return Result;
 
   unsigned Params = 1;
   QualType Ty = FPT->getParamType(Params);
   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) &&
+  if (Ctx.getLangOpts().SizedDeallocation && bool(Result & AFC::Deallocation) &&
       Ctx.hasSameType(Ty, Ctx.getSizeType())) {
-    IsSizedDelete = true;
+    Result |= AFC::Sized;
     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()) {
-    if (IsAligned)
-      *IsAligned = true;
+    Result |= AFC::Aligned;
     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()) {
+  if (!bool(Result & AFC::Sized) && !Ty.isNull() && Ty->isReferenceType()) {
     Ty = Ty->getPointeeType();
     if (Ty.getCVRQualifiers() != Qualifiers::Const)
-      return false;
+      return AFC::None;
     const CXXRecordDecl *RD = Ty->getAsCXXRecordDecl();
     if (RD && isNamed(RD, "nothrow_t") && RD->isInStdNamespace())
       Consume();
   }
 
-  return Params == FPT->getNumParams();
+  if (Params != FPT->getNumParams())
+    return AFC::None;
+  return Result;
 }
 
 bool FunctionDecl::isDestroyingOperatorDelete() const {
   // C++ P0722:
   //   Within a class C, a single object deallocation function with signature
   //     (T, std::destroying_delete_t, <more params>)
   //   is a destroying operator delete.
   if (!isa<CXXMethodDecl>(this) || getOverloadedOperator() != OO_Delete ||

lib/Driver/ToolChains/Clang.cpp

 
   // -frelaxed-template-template-args is off by default, as it is a severe
   // breaking change until a corresponding change to template partial ordering
   // is provided.
   if (Args.hasFlag(options::OPT_frelaxed_template_template_args,
                    options::OPT_fno_relaxed_template_template_args, false))
     CmdArgs.push_back("-frelaxed-template-template-args");
 
-  // -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");
-
+  // -fsized-deallocation is on by default in C++14 onwards and otherwise off
+  // by default.
+  if (Arg *A = Args.getLastArg(options::OPT_fsized_deallocation,
+                               options::OPT_fno_sized_deallocation)) {
+    if (A->getOption().matches(options::OPT_fno_sized_deallocation))
+      CmdArgs.push_back("-fno-sized-deallocation");
+    else
+      CmdArgs.push_back("-fsized-deallocation");
+  }
   // -faligned-allocation is on by default in C++17 onwards and otherwise off
   // by default.
   if (Arg *A = Args.getLastArg(options::OPT_faligned_allocation,
                                options::OPT_fno_aligned_allocation,
                                options::OPT_faligned_new_EQ)) {
     if (A->getOption().matches(options::OPT_fno_aligned_allocation))
       CmdArgs.push_back("-fno-aligned-allocation");
     else

lib/Driver/ToolChains/Darwin.h

bool isMacosxVersionLT(unsigned V0, unsigned V1 = 0, unsigned V2 = 0) const {
     return TargetVersion < VersionTuple(V0, V1, V2);
   }
 
   /// Return true if c++17 aligned allocation/deallocation functions are not
   /// implemented in the c++ standard library of the deployment target we are
   /// targeting.
   bool isAlignedAllocationUnavailable() const;
 
+  /// Return true if C++14 sized deallocation functions are not
+  /// implemented in the C++ standard library of the deployment target we are
+  /// targeting.
+  bool isSizedDeallocationUnavailable() const;
+
   void addClangTargetOptions(const llvm::opt::ArgList &DriverArgs,
                              llvm::opt::ArgStringList &CC1Args,
                              Action::OffloadKind DeviceOffloadKind) const override;
 
   StringRef getPlatformFamily() const;
   StringRef getOSLibraryNameSuffix() const;
 
 public:

lib/Driver/ToolChains/Darwin.cpp

 //===--- Darwin.cpp - Darwin Tool and ToolChain Implementations -*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "Darwin.h"
 #include "Arch/ARM.h"
 #include "CommonArgs.h"
-#include "clang/Basic/AlignedAllocation.h"
+#include "clang/Basic/AllocationAvailability.h"
 #include "clang/Basic/ObjCRuntime.h"
 #include "clang/Basic/VirtualFileSystem.h"
 #include "clang/Driver/Compilation.h"
 #include "clang/Driver/Driver.h"
 #include "clang/Driver/DriverDiagnostic.h"
 #include "clang/Driver/Options.h"
 #include "clang/Driver/SanitizerArgs.h"
 #include "llvm/ADT/StringSwitch.h"
CompilerRT +=
       (tools::arm::getARMFloatABI(*this, Args) == tools::arm::FloatABI::Hard)
           ? "hard"
           : "soft";
   CompilerRT += Args.hasArg(options::OPT_fPIC) ? "_pic.a" : "_static.a";
 
   AddLinkRuntimeLib(Args, CmdArgs, CompilerRT, RLO_IsEmbedded);
 }
 
-bool Darwin::isAlignedAllocationUnavailable() const {
-  llvm::Triple::OSType OS;
+static llvm::Triple::OSType getOSType(const Darwin &TC) {
+  switch (TC.TargetPlatform) {
+  case Darwin::MacOS:
+    return llvm::Triple::MacOSX;
+  case Darwin::IPhoneOS:
+    return llvm::Triple::IOS;
+  case Darwin::TvOS:
+    return llvm::Triple::TvOS;
+  case Darwin::WatchOS:
+    return llvm::Triple::WatchOS;
+  }
+  llvm_unreachable("unhandled case");
+}
 
-  switch (TargetPlatform) {
-  case MacOS: // Earlier than 10.13.
-    OS = llvm::Triple::MacOSX;
-    break;
-  case IPhoneOS:
-    OS = llvm::Triple::IOS;
-    break;
-  case TvOS: // Earlier than 11.0.
-    OS = llvm::Triple::TvOS;
-    break;
-  case WatchOS: // Earlier than 4.0.
-    OS = llvm::Triple::WatchOS;
-    break;
-  }
+bool Darwin::isAlignedAllocationUnavailable() const {
+  return TargetVersion < alignedAllocMinVersion(getOSType(*this));
 
-  return TargetVersion < alignedAllocMinVersion(OS);
+bool Darwin::isSizedDeallocationUnavailable() const {
+  return TargetVersion < sizedDeallocMinVersion(getOSType(*this));
 }
 
 void Darwin::addClangTargetOptions(const llvm::opt::ArgList &DriverArgs,
                                    llvm::opt::ArgStringList &CC1Args,
                                    Action::OffloadKind DeviceOffloadKind) const {
-  if (isAlignedAllocationUnavailable())
+  // Pass "-faligned-alloc-unavailable" only when the user hasn't manually
+  // enabled or disabled aligned allocations and hasn't specified a custom
+  // standard library installation.
+  if (!DriverArgs.hasArgNoClaim(options::OPT_nostdincxx)) {
+    if (!DriverArgs.hasArgNoClaim(options::OPT_faligned_allocation,
+                                  options::OPT_fno_aligned_allocation) &&
+        isAlignedAllocationUnavailable())
       CC1Args.push_back("-faligned-alloc-unavailable");
+    if (!DriverArgs.hasArgNoClaim(options::OPT_fsized_deallocation,
+                                  options::OPT_fno_sized_deallocation) &&
+        isSizedDeallocationUnavailable())
+      CC1Args.push_back("-fsized-deallocation-unavailable");
+  }
 }
 
 DerivedArgList *
 Darwin::TranslateArgs(const DerivedArgList &Args, StringRef BoundArch,
                       Action::OffloadKind DeviceOffloadKind) const {
   // First get the generic Apple args, before moving onto Darwin-specific ones.
   DerivedArgList *DAL =
       MachO::TranslateArgs(Args, BoundArch, DeviceOffloadKind);

lib/Frontend/CompilerInvocation.cpp

   Opts.Half = Opts.OpenCL;
 
   // C++ has wchar_t keyword.
   Opts.WChar = Opts.CPlusPlus;
 
   Opts.GNUKeywords = Opts.GNUMode;
   Opts.CXXOperatorNames = Opts.CPlusPlus;
 
+  Opts.SizedDeallocation = Opts.CPlusPlus14;
   Opts.AlignedAllocation = Opts.CPlusPlus17;
 
   Opts.DollarIdents = !Opts.AsmPreprocessor;
 }
 
 /// Attempt to parse a visibility value out of the given argument.
 static Visibility parseVisibility(Arg *arg, ArgList &args,
                                   DiagnosticsEngine &diags) {

   Opts.ShortEnums = Args.hasArg(OPT_fshort_enums);
   Opts.Freestanding = Args.hasArg(OPT_ffreestanding);
   Opts.NoBuiltin = Args.hasArg(OPT_fno_builtin) || Opts.Freestanding;
   if (!Opts.NoBuiltin)
     getAllNoBuiltinFuncValues(Args, Opts.NoBuiltinFuncs);
   Opts.NoMathBuiltin = Args.hasArg(OPT_fno_math_builtin);
   Opts.RelaxedTemplateTemplateArgs =
       Args.hasArg(OPT_frelaxed_template_template_args);
-  Opts.SizedDeallocation = Args.hasArg(OPT_fsized_deallocation);
+  Opts.SizedDeallocation =
+      Args.hasFlag(OPT_fsized_deallocation, OPT_fno_sized_deallocation,
+                   Opts.SizedDeallocation);
+  Opts.SizedDeallocationUnavailable =
+      Opts.SizedDeallocation && Args.hasArg(OPT_sized_deallocation_unavailable);
   Opts.AlignedAllocation =
       Args.hasFlag(OPT_faligned_allocation, OPT_fno_aligned_allocation,
                    Opts.AlignedAllocation);
   Opts.AlignedAllocationUnavailable =
       Opts.AlignedAllocation && Args.hasArg(OPT_aligned_alloc_unavailable);
   Opts.NewAlignOverride =
       getLastArgIntValue(Args, OPT_fnew_alignment_EQ, 0, Diags);
   if (Opts.NewAlignOverride && !llvm::isPowerOf2_32(Opts.NewAlignOverride)) {

lib/Frontend/InitPreprocessor.cpp

if (LangOpts.CPlusPlus14) {
     Builder.defineMacro("__cpp_digit_separators", "201309");
     Builder.defineMacro("__cpp_init_captures", "201304");
     Builder.defineMacro("__cpp_generic_lambdas", "201304");
     Builder.defineMacro("__cpp_decltype_auto", "201304");
     Builder.defineMacro("__cpp_return_type_deduction", "201304");
     Builder.defineMacro("__cpp_aggregate_nsdmi", "201304");
     Builder.defineMacro("__cpp_variable_templates", "201304");
   }
-  if (LangOpts.SizedDeallocation)
+  if (LangOpts.SizedDeallocation && !LangOpts.SizedDeallocationUnavailable)
     Builder.defineMacro("__cpp_sized_deallocation", "201309");
 
   // C++17 features.
   if (LangOpts.CPlusPlus17) {
     Builder.defineMacro("__cpp_hex_float", "201603");
     Builder.defineMacro("__cpp_inline_variables", "201606");
     Builder.defineMacro("__cpp_noexcept_function_type", "201510");
     Builder.defineMacro("__cpp_capture_star_this", "201603");
     Builder.defineMacro("__cpp_if_constexpr", "201606");
     Builder.defineMacro("__cpp_deduction_guides", "201703");
     Builder.defineMacro("__cpp_template_auto", "201606");
     Builder.defineMacro("__cpp_namespace_attributes", "201411");
     Builder.defineMacro("__cpp_enumerator_attributes", "201411");
     Builder.defineMacro("__cpp_nested_namespace_definitions", "201411");
     Builder.defineMacro("__cpp_variadic_using", "201611");
     Builder.defineMacro("__cpp_aggregate_bases", "201603");
     Builder.defineMacro("__cpp_structured_bindings", "201606");
     Builder.defineMacro("__cpp_nontype_template_args", "201411");
     Builder.defineMacro("__cpp_fold_expressions", "201603");
   }
-  if (LangOpts.AlignedAllocation)
+  if (LangOpts.AlignedAllocation && !LangOpts.AlignedAllocationUnavailable)
     Builder.defineMacro("__cpp_aligned_new", "201606");
 
   // TS features.
   if (LangOpts.ConceptsTS)
     Builder.defineMacro("__cpp_experimental_concepts", "1");
   if (LangOpts.CoroutinesTS)
     Builder.defineMacro("__cpp_coroutines", "201703L");
 

lib/Sema/SemaExpr.cpp

if (Pos != SuppressedDiagnostics.end()) {
 
       // Clear out the list of suppressed diagnostics, so that we don't emit
       // them again for this specialization. However, we don't obsolete this
       // entry from the table, because we want to avoid ever emitting these
       // diagnostics again.
       Pos->second.clear();
     }
 
+    const auto *FD = cast<FunctionDecl>(D);
+
     // C++ [basic.start.main]p3:
     //   The function 'main' shall not be used within a program.
-    if (cast<FunctionDecl>(D)->isMain())
+    if (FD->isMain())
       Diag(Loc, diag::ext_main_used);
+
+    // DiagnoseUnavailableAllocationFunction(FD, Loc);
   }
 
   // See if this is an auto-typed variable whose initializer we are parsing.
   if (ParsingInitForAutoVars.count(D)) {
     if (isa<BindingDecl>(D)) {
       Diag(Loc, diag::err_binding_cannot_appear_in_own_initializer)
         << D->getDeclName();
     } else {

lib/Sema/SemaExprCXX.cpp

 //===--- SemaExprCXX.cpp - Semantic Analysis for Expressions --------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
 /// Implements semantic analysis for C++ expressions.
 ///
 //===----------------------------------------------------------------------===//
 
-#include "clang/Sema/SemaInternal.h"
 #include "TreeTransform.h"
 #include "TypeLocBuilder.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/ASTLambda.h"
 #include "clang/AST/CXXInheritance.h"
 #include "clang/AST/CharUnits.h"
 #include "clang/AST/DeclObjC.h"
 #include "clang/AST/ExprCXX.h"
 #include "clang/AST/ExprObjC.h"
 #include "clang/AST/RecursiveASTVisitor.h"
 #include "clang/AST/TypeLoc.h"
-#include "clang/Basic/AlignedAllocation.h"
+#include "clang/Basic/AllocationAvailability.h"
 #include "clang/Basic/PartialDiagnostic.h"
 #include "clang/Basic/TargetInfo.h"
 #include "clang/Lex/Preprocessor.h"
 #include "clang/Sema/DeclSpec.h"
 #include "clang/Sema/Initialization.h"
 #include "clang/Sema/Lookup.h"
 #include "clang/Sema/ParsedTemplate.h"
 #include "clang/Sema/Scope.h"
 #include "clang/Sema/ScopeInfo.h"
+#include "clang/Sema/SemaInternal.h"
 #include "clang/Sema/SemaLambda.h"
 #include "clang/Sema/TemplateDeduction.h"
 #include "llvm/ADT/APInt.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/Support/ErrorHandling.h"
 using namespace clang;
 using namespace sema;
 
static bool isLegalArrayNewInitializer(CXXNewExpr::InitializationStyle Style,
   else if (Style == CXXNewExpr::ListInit) {
     assert(isa<InitListExpr>(Init) &&
            "Shouldn't create list CXXConstructExprs for arrays.");
     return true;
   }
   return false;
 }
 
+enum AllocationFunctionKind {
+  AFK_AlignedAllocation,
+  AFK_AlignedDeallocation,
+  AFK_SizedDeallocation
+};
+
 // Emit a diagnostic if an aligned allocation/deallocation function that is not
 // implemented in the standard library is selected.
-static void diagnoseUnavailableAlignedAllocation(const FunctionDecl &FD,
-                                                 SourceLocation Loc, bool IsDelete,
-                                                 Sema &S) {
-  if (!S.getLangOpts().AlignedAllocationUnavailable)
+void Sema::DiagnoseUnavailableAllocationFunction(const FunctionDecl *FD,
+                                                 SourceLocation Loc) {
+  // Return if there is a definition.
+  if (FD->isDefined())
     return;
 
-  // Return if there is a definition.
-  if (FD.isDefined())
+  using AFC = FunctionDecl::AllocationFunctionClassification;
+  AFC Classify = FD->classifyReplaceableGlobalAllocationFunction();
+  if (Classify == AFC::None)
     return;
 
-  bool IsAligned = false;
-  if (FD.isReplaceableGlobalAllocationFunction(&IsAligned) && IsAligned) {
-    const llvm::Triple &T = S.getASTContext().getTargetInfo().getTriple();
-    StringRef OSName = AvailabilityAttr::getPlatformNameSourceSpelling(
-        S.getASTContext().getTargetInfo().getPlatformName());
+  // Figure out if the found allocation/deallocation function is unavailable
+  // and gather the required information for the diagnostic.
+  AllocationFunctionKind AllocKind;
+  if (bool(Classify & AFC::Aligned) &&
+      getLangOpts().AlignedAllocationUnavailable)
+    AllocKind = bool(Classify & AFC::Allocation) ? AFK_AlignedAllocation
+                                                 : AFK_AlignedDeallocation;
+  else if (bool(Classify & AFC::Sized) &&
+           getLangOpts().SizedDeallocationUnavailable)
+    AllocKind = AFK_SizedDeallocation;
+  else
+    return; // nothing to do
+
+  const llvm::Triple &T = Context.getTargetInfo().getTriple();
+  VersionTuple MinVer = AllocKind == AFK_SizedDeallocation
+                            ? sizedDeallocMinVersion(T.getOS())
+                            : alignedAllocMinVersion(T.getOS());
+      Context.getTargetInfo().getPlatformName());
 
-    S.Diag(Loc, diag::warn_aligned_allocation_unavailable)
-         << IsDelete << FD.getType().getAsString() << OSName
-         << alignedAllocMinVersion(T.getOS()).getAsString();
-    S.Diag(Loc, diag::note_silence_unligned_allocation_unavailable);
-  }
+  Diag(Loc, diag::err_allocation_function_unavailable)
+      << (unsigned)AllocKind << FD->getType().getAsString() << OSName
+      << MinVer.getAsString();
+  Diag(Loc, diag::note_silence_allocation_function_unavailable)
+      << (unsigned)AllocKind;
 }
 
 ExprResult
 Sema::BuildCXXNew(SourceRange Range, bool UseGlobal,
                   SourceLocation PlacementLParen,
                   MultiExprArg PlacementArgs,
                   SourceLocation PlacementRParen,
                   SourceRange TypeIdParens,
if (!AllocType->isDependentType() &&
     Initializer = FullInit.get();
   }
 
   // Mark the new and delete operators as referenced.
   if (OperatorNew) {
     if (DiagnoseUseOfDecl(OperatorNew, StartLoc))
       return ExprError();
     MarkFunctionReferenced(StartLoc, OperatorNew);
-    diagnoseUnavailableAlignedAllocation(*OperatorNew, StartLoc, false, *this);
   }
   if (OperatorDelete) {
     if (DiagnoseUseOfDecl(OperatorDelete, StartLoc))
       return ExprError();
     MarkFunctionReferenced(StartLoc, OperatorDelete);
-    diagnoseUnavailableAlignedAllocation(*OperatorDelete, StartLoc, true, *this);
   }
 
   // C++0x [expr.new]p17:
   //   If the new expression creates an array of objects of class type,
   //   access and ambiguity control are done for the destructor.
   QualType BaseAllocType = Context.getBaseElementType(AllocType);
   if (ArraySize && !BaseAllocType->isDependentType()) {
     if (const RecordType *BaseRecordType = BaseAllocType->getAs<RecordType>()) {
if (!OperatorDelete) {
                          Pointee.isDestructedType());
       bool Overaligned = hasNewExtendedAlignment(*this, Pointee);
 
       // Look for a global declaration.
       OperatorDelete = FindUsualDeallocationFunction(StartLoc, CanProvideSize,
                                                      Overaligned, DeleteName);
     }
 
+    if (DiagnoseUseOfDecl(OperatorDelete, StartLoc))
+      return ExprError();
     MarkFunctionReferenced(StartLoc, OperatorDelete);
 
     // Check access and ambiguity of destructor if we're going to call it.
     // Note that this is required even for a virtual delete.
     bool IsVirtualDelete = false;
     if (PointeeRD) {
       if (CXXDestructorDecl *Dtor = LookupDestructor(PointeeRD)) {
         CheckDestructorAccess(Ex.get()->getExprLoc(), Dtor,
                               PDiag(diag::err_access_dtor) << PointeeElem);
         IsVirtualDelete = Dtor->isVirtual();
       }
     }
 
-    diagnoseUnavailableAlignedAllocation(*OperatorDelete, StartLoc, true,
-                                         *this);
-
     // Convert the operand to the type of the first parameter of operator
     // delete. This is only necessary if we selected a destroying operator
     // delete that we are going to call (non-virtually); converting to void*
     // is trivial and left to AST consumers to handle.
     QualType ParamType = OperatorDelete->getParamDecl(0)->getType();
     if (!IsVirtualDelete && !ParamType->getPointeeType()->isVoidType()) {
       Qualifiers Qs = Pointee.getQualifiers();
       if (Qs.hasCVRQualifiers()) {

test/CodeGenCXX/cxx1y-sized-deallocation.cpp

 // Check that delete exprs call the sized deallocation function if
-// -fsized-deallocation is passed in both C++11 and C++14.
+// -fsized-deallocation is passed in C++11 or the dialect is C++14.
 // RUN: %clang_cc1 -std=c++11 -fsized-deallocation %s -emit-llvm -triple x86_64-linux-gnu -o - | FileCheck %s
-// RUN: %clang_cc1 -std=c++14 -fsized-deallocation %s -emit-llvm -triple x86_64-linux-gnu -o - | FileCheck %s
+// RUN: %clang_cc1 -std=c++14 %s -emit-llvm -triple x86_64-linux-gnu -o - | FileCheck %s
 
-// Check that we don't used sized deallocation without -fsized-deallocation and
-// C++14.
+// Check that we don't used sized deallocation without -fsized-deallocation in C++11
+// or when -fno-sized-deallocation is passed in 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++14 %s -emit-llvm -triple x86_64-linux-gnu -o - | FileCheck %s --check-prefix=CHECK-UNSIZED
+// RUN: %clang_cc1 -std=c++14 -fno-sized-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;
 
 typedef int A;
 struct B { int n; };

test/CodeGenCXX/cxx1z-aligned-allocation.cpp

 // 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
+// RUN: %clang_cc1 -std=c++14 -fexceptions -faligned-allocation %s -emit-llvm -triple x86_64-linux-gnu -o - | FileCheck %s
+// RUN: %clang_cc1 -std=c++1z -fexceptions %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-windows-msvc -o - | FileCheck %s --check-prefix=CHECK-MS
+// RUN: %clang_cc1 -std=c++1z -fexceptions %s -emit-llvm -triple x86_64-windows-msvc -o - | FileCheck %s --check-prefix=CHECK-MS
 
 // 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

test/Driver/unavailable_aligned_allocation.cpp

 // RUN: %clang -target x86_64-apple-darwin -mtvos-simulator-version-min=11 \
 // RUN: -c -### %s 2>&1 \
 // RUN:   | FileCheck %s -check-prefix=AVAILABLE
 //
 // RUN: %clang -target x86_64-apple-darwin -mwatchos-simulator-version-min=4 \
 // RUN: -c -### %s 2>&1 \
 // RUN:   | FileCheck %s -check-prefix=AVAILABLE
 //
+// Check that passing -faligned-allocation, -fno-aligned-allocation, or
+// -nostdinc++ stops the driver from passing -faligned-alloc-unavailable to cc1.
+//
+// RUN: %clang -target x86_64-apple-macosx10.12 -faligned-allocation -c -### %s 2>&1 \
+// RUN:   | FileCheck %s -check-prefix=AVAILABLE
+//
+// RUN: %clang -target x86_64-apple-macosx10.12 -fno-aligned-allocation -c -### %s 2>&1 \
+// RUN:   | FileCheck %s -check-prefix=AVAILABLE
+//
+// RUN: %clang -target x86_64-apple-macosx10.12 -nostdinc++ -c -### %s 2>&1 \
+// RUN:   | FileCheck %s -check-prefix=AVAILABLE
+
 // AVAILABLE-NOT: "-faligned-alloc-unavailable"

test/Driver/unavailable_sized_deallocation.cpp

+// RUN: %clang -target x86_64-apple-macosx10.11 -c -### %s 2>&1 \
+// RUN:   | FileCheck %s -check-prefix=UNAVAILABLE
+//
+// RUN: %clang -target arm64-apple-ios9 -c -### %s 2>&1 \
+// RUN:   | FileCheck %s -check-prefix=UNAVAILABLE
+//
+// RUN: %clang -target arm64-apple-tvos9 -c -### %s 2>&1 \
+// RUN:   | FileCheck %s -check-prefix=UNAVAILABLE
+//
+// RUN: %clang -target thumbv7-apple-watchos2 -c -### %s 2>&1 \
+// RUN:   | FileCheck %s -check-prefix=UNAVAILABLE
+//
+// RUN: %clang -target x86_64-apple-darwin -mios-simulator-version-min=9 \
+// RUN:  -c -### %s 2>&1 \
+// RUN:   | FileCheck %s -check-prefix=UNAVAILABLE
+//
+// RUN: %clang -target x86_64-apple-darwin -mtvos-simulator-version-min=9 \
+// RUN: -c -### %s 2>&1 \
+// RUN:   | FileCheck %s -check-prefix=UNAVAILABLE
+//
+// RUN: %clang -target x86_64-apple-darwin -mwatchos-simulator-version-min=2 \
+// RUN: -c -### %s 2>&1 \
+// RUN:   | FileCheck %s -check-prefix=UNAVAILABLE
+//
+// UNAVAILABLE: "-fsized-deallocation-unavailable"
+
+// RUN: %clang -target x86_64-apple-macosx10.12 -c -### %s 2>&1 \
+// RUN:   | FileCheck %s -check-prefix=AVAILABLE
+//
+// RUN: %clang -target arm64-apple-ios10 -c -### %s 2>&1 \
+// RUN:   | FileCheck %s -check-prefix=AVAILABLE
+//
+// RUN: %clang -target arm64-apple-tvos10 -c -### %s 2>&1 \
+// RUN:   | FileCheck %s -check-prefix=AVAILABLE
+//
+// RUN: %clang -target armv7k-apple-watchos3 -c -### %s 2>&1 \
+// RUN:   | FileCheck %s -check-prefix=AVAILABLE
+//
+// RUN: %clang -target x86_64-unknown-linux-gnu -c -### %s 2>&1 \
+// RUN:   | FileCheck %s -check-prefix=AVAILABLE
+//
+// RUN: %clang -target x86_64-apple-darwin -mios-simulator-version-min=10 \
+// RUN:  -c -### %s 2>&1 \
+// RUN:   | FileCheck %s -check-prefix=AVAILABLE
+//
+// RUN: %clang -target x86_64-apple-darwin -mtvos-simulator-version-min=10 \
+// RUN: -c -### %s 2>&1 \
+// RUN:   | FileCheck %s -check-prefix=AVAILABLE
+//
+// RUN: %clang -target x86_64-apple-darwin -mwatchos-simulator-version-min=3 \
+// RUN: -c -### %s 2>&1 \
+// RUN:   | FileCheck %s -check-prefix=AVAILABLE
+//
+// Check that passing -fsized-deallocation, -fno-sized-deallocation, or
+// -nostdinc++ stops the driver from passing -fsized-deallocation-unavailable to cc1.
+//
+// RUN: %clang -target x86_64-apple-macosx10.11 -fsized-deallocation -c -### %s 2>&1 \
+// RUN:   | FileCheck %s -check-prefix=AVAILABLE
+//
+// RUN: %clang -target x86_64-apple-macosx10.11 -fno-sized-deallocation -c -### %s 2>&1 \
+// RUN:   | FileCheck %s -check-prefix=AVAILABLE
+//
+// RUN: %clang -target x86_64-apple-macosx10.11 -nostdinc++ -c -### %s 2>&1 \
+// RUN:   | FileCheck %s -check-prefix=AVAILABLE
+
+// AVAILABLE-NOT: "-fsized-deallocation-unavailable"

test/Lexer/aligned-allocation.cpp

+// RUN: %clang_cc1 -triple x86_64-apple-macosx10.12.0 -fexceptions -std=c++17 -verify %s \
+// RUN:   -DEXPECT_DEFINED
+//
+// RUN: %clang_cc1 -triple x86_64-apple-macosx10.12.0 -fexceptions -std=c++17 -verify %s \
+// RUN:   -faligned-alloc-unavailable
+//
+// RUN: %clang_cc1 -triple x86_64-apple-macosx10.12.0 -fexceptions -std=c++17 -verify %s \
+// RUN:   -faligned-allocation -faligned-alloc-unavailable
+
+// Test that __cpp_aligned_new is not defined when CC1 is passed
+// -faligned-alloc-unavailable by the Darwin driver, even when aligned
+// allocation is actually enabled.
+
+// expected-no-diagnostics
+#ifdef EXPECT_DEFINED
+# ifndef __cpp_aligned_new
+#   error "__cpp_aligned_new" should be defined
+# endif
+#else
+# ifdef __cpp_aligned_new
+#   error "__cpp_aligned_new" should not be defined
+# endif
+#endif

test/Lexer/cxx-features.cpp

 // RUN: %clang_cc1 -std=c++98 -fcxx-exceptions -verify %s
 // RUN: %clang_cc1 -std=c++11 -fcxx-exceptions -verify %s
-// RUN: %clang_cc1 -std=c++1y -fcxx-exceptions -fsized-deallocation -verify %s
-// RUN: %clang_cc1 -std=c++14 -fcxx-exceptions -fsized-deallocation -verify %s
-// RUN: %clang_cc1 -std=c++1z -fcxx-exceptions -fsized-deallocation -verify %s
-// RUN: %clang_cc1 -std=c++1z -fcxx-exceptions -fsized-deallocation -fconcepts-ts -DCONCEPTS_TS=1 -verify %s
-// RUN: %clang_cc1 -fno-rtti -fno-threadsafe-statics -verify %s -DNO_EXCEPTIONS -DNO_RTTI -DNO_THREADSAFE_STATICS -fsized-deallocation
-// RUN: %clang_cc1 -fcoroutines-ts -DNO_EXCEPTIONS -DCOROUTINES -verify -fsized-deallocation %s
-// RUN: %clang_cc1 -fchar8_t -DNO_EXCEPTIONS -DCHAR8_T -verify -fsized-deallocation %s
+// RUN: %clang_cc1 -std=c++1y -fcxx-exceptions -verify %s
+// RUN: %clang_cc1 -std=c++14 -fcxx-exceptions -verify %s
+// RUN: %clang_cc1 -std=c++1z -fcxx-exceptions -verify %s
+// RUN: %clang_cc1 -std=c++1z -fcxx-exceptions -fconcepts-ts -DCONCEPTS_TS=1 -verify %s
+// RUN: %clang_cc1 -fno-rtti -fno-threadsafe-statics -verify %s -DNO_EXCEPTIONS -DNO_RTTI -DNO_THREADSAFE_STATICS
+// RUN: %clang_cc1 -fcoroutines-ts -DNO_EXCEPTIONS -DCOROUTINES -verify %s
+// RUN: %clang_cc1 -fchar8_t -DNO_EXCEPTIONS -DCHAR8_T -verify %s
 
 // expected-no-diagnostics
 
 // FIXME using `defined` in a macro has undefined behavior.
 #if __cplusplus < 201103L
 #define check(macro, cxx98, cxx11, cxx14, cxx1z) cxx98 == 0 ? defined(__cpp_##macro) : __cpp_##macro != cxx98
 #elif __cplusplus < 201402L
 #define check(macro, cxx98, cxx11, cxx14, cxx1z) cxx11 == 0 ? defined(__cpp_##macro) : __cpp_##macro != cxx11

test/Lexer/sized-deallocation.cpp

+// RUN: %clang_cc1 -triple x86_64-apple-macosx10.11.0 -fexceptions -std=c++14 -verify %s \
+// RUN:   -DEXPECT_DEFINED
+//
+// RUN: %clang_cc1 -triple x86_64-apple-macosx10.13.0 -fexceptions -std=c++14 -verify %s \
+// RUN:   -fsized-deallocation-unavailable
+//
+// RUN: %clang_cc1 -triple x86_64-apple-macosx10.12.0 -fexceptions -std=c++14 -verify %s \
+// RUN:   -fsized-deallocation -fsized-deallocation-unavailable
+
+// Test that __cpp_sized_deallocation is not defined when CC1 is passed
+// -fsized-deallocation-unavailable by the Darwin driver, even when sized
+// deallocation is actually enabled.
+
+// expected-no-diagnostics
+#ifdef EXPECT_DEFINED
+#ifndef __cpp_sized_deallocation
+#error "__cpp_sized_deallocation" should be defined
+#endif
+#else
+#ifdef __cpp_sized_deallocation
+#error "__cpp_sized_deallocation" should not be defined
+#endif
+#endif

test/SemaCXX/MicrosoftExtensions.cpp

-// RUN: %clang_cc1 %s -triple i686-pc-win32 -fsyntax-only -Wmicrosoft -Wc++11-extensions -Wno-long-long -verify -fms-extensions -fexceptions -fcxx-exceptions -DTEST1
+// RUN: %clang_cc1 %s -triple i686-pc-win32 -fsyntax-only -Wmicrosoft -Wc++11-extensions -Wno-long-long -verify -fms-extensions -fexceptions -fcxx-exceptions -fno-sized-deallocation -DTEST1
 // RUN: %clang_cc1 -std=c++98 %s -triple i686-pc-win32 -fsyntax-only -Wmicrosoft -Wc++11-extensions -Wno-long-long -verify -fms-extensions -fexceptions -fcxx-exceptions -DTEST1
 // RUN: %clang_cc1 -std=c++11 %s -triple i686-pc-win32 -fsyntax-only -Wmicrosoft -Wc++11-extensions -Wno-long-long -verify -fms-extensions -fexceptions -fcxx-exceptions -DTEST1
 // RUN: %clang_cc1 %s -triple i686-pc-win32 -fsyntax-only -Wmicrosoft -Wc++11-extensions -Wno-long-long -verify -fexceptions -fcxx-exceptions -DTEST2
 // RUN: %clang_cc1 %s -triple i686-pc-win32 -fsyntax-only -std=c++11 -fms-compatibility -verify -DTEST3
 
 #if TEST1
 
 // Microsoft doesn't validate exception specification.

test/SemaCXX/builtin-operator-new-delete.cpp

 // 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 operator delete(void *, size_t, std::align_val_t); // expected-note 1+ {{candidate}}
+void operator delete[](void *, size_t, std::align_val_t);
+
 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'}}
 }

test/SemaCXX/cxx1y-sized-deallocation.cpp

-// RUN: %clang_cc1 -std=c++1y -verify %s -fsized-deallocation -fexceptions -fcxx-exceptions
+// RUN: %clang_cc1 -std=c++1y -verify %s -fexceptions -fcxx-exceptions
 
 using size_t = decltype(sizeof(0));
 void operator delete(void *, size_t) noexcept;   // expected-note {{'operator delete' declared here}}
 void operator delete[](void *, size_t) noexcept;
 
 void f(void *p, void *q) {
   // OK, implicitly declared.
   operator delete(p, 8);

test/SemaCXX/test.cpp

+
+namespace std {
+typedef decltype(sizeof(0)) size_t;
+enum class align_val_t : std::size_t {};
+struct nothrow_t {};
+nothrow_t nothrow;
+} // namespace std
+
+void *operator new(std::size_t __sz, const std::nothrow_t &) noexcept;
+void *operator new[](std::size_t __sz, const std::nothrow_t &) noexcept;
+
+void *operator new(std::size_t __sz, const std::nothrow_t &) noexcept;
+void *operator new[](std::size_t __sz, const std::nothrow_t &) noexcept;
+void operator delete(void *, std::size_t) noexcept;
+void operator delete[](void *, std::size_t) noexcept;
+
+void *operator new(std::size_t, std::size_t, long long);
+
+struct S {
+  int x[16];
+};
+
+void test() {
+  void *v = operator new(42);
+  operator delete(v, 42);
+}

test/SemaCXX/unavailable_sized_deallocation.cpp

+// RUN: %clang_cc1 -triple x86_64-apple-macosx10.11.0 -fexceptions -fsized-deallocation-unavailable -std=c++14 -verify %s
+// RUN: %clang_cc1 -triple x86_64-apple-macosx10.11.0 -fexceptions -std=c++14 -verify -DNO_ERRORS %s
+// RUN: %clang_cc1 -triple x86_64-apple-macosx10.11.0 -fexceptions -fsized-deallocation -fsized-deallocation-unavailable -std=c++14 -verify %s
+// RUN: %clang_cc1 -triple arm64-apple-ios9.0.0 -fexceptions -fsized-deallocation-unavailable -std=c++14 -verify -DIOS %s
+// RUN: %clang_cc1 -triple arm64-apple-ios9.0.0 -fexceptions -std=c++14 -verify -DNO_ERRORS %s
+// RUN: %clang_cc1 -triple arm64-apple-tvos9.0.0 -fexceptions -fsized-deallocation-unavailable -std=c++14 -verify -DTVOS %s
+// RUN: %clang_cc1 -triple arm64-apple-tvos9.0.0 -fexceptions -std=c++14 -verify -DNO_ERRORS %s
+// RUN: %clang_cc1 -triple armv7k-apple-watchos2.0.0 -fexceptions -fsized-deallocation-unavailable -std=c++14 -verify -DWATCHOS %s
+// RUN: %clang_cc1 -triple armv7k-apple-watchos2.0.0 -fexceptions -std=c++14 -verify -DNO_ERRORS %s
+
+#ifdef NO_ERRORS
+// expected-no-diagnostics
+#endif
+
+namespace std {
+typedef decltype(sizeof(0)) size_t;
+enum class align_val_t : std::size_t {};
+struct nothrow_t {};
+nothrow_t nothrow;
+} // namespace std
+
+void *operator new(std::size_t __sz, const std::nothrow_t &) noexcept;
+void *operator new[](std::size_t __sz, const std::nothrow_t &) noexcept;
+
+void *operator new(std::size_t __sz, const std::nothrow_t &) noexcept;
+void *operator new[](std::size_t __sz, const std::nothrow_t &) noexcept;
+void operator delete(void *, std::size_t) noexcept;
+void operator delete[](void *, std::size_t) noexcept;
+
+void *operator new(std::size_t, std::size_t, long long);
+
+struct S {
+  int x[16];
+};
+
+void test() {
+  auto *p = new S;
+#ifndef NO_ERRORS
+// expected-error@-2 {{sized deallocation function of type 'void (void *, std::size_t) noexcept' is only available on}}
+// expected-note@-3 {{if you supply your own sized deallocation functions}}
+#endif
+
+  delete p;
+#ifndef NO_ERRORS
+// expected-error@-2 {{sized deallocation function of type 'void (void *, std::size_t) noexcept' is only available on}}
+// expected-note@-3 {{if you supply your own sized deallocation functions}}
+#endif
+
+  auto *pa = new S[4];
+#ifndef NO_ERRORS
+// expected-error@-2 {{sized deallocation function of type 'void (void *, std::size_t) noexcept' is only available on}}
+// expected-note@-3 {{if you supply your own sized deallocation functions}}
+#endif
+
+  delete[] pa; // OK, doesn't call sized delete.
+
+  void *v = operator new(42);
+  operator delete(v, 42);
+#ifndef NO_ERRORS
+// expected-error@-2 {{sized deallocation function of type 'void (void *, std::size_t) noexcept' is only available on}}
+// expected-note@-3 {{if you supply your own sized deallocation functions}}
+#endif
+}
+
+void testCheckOS(S *p) {
+  delete p;
+}
+#if defined(IOS)
+// expected-error@-3 {{sized deallocation function of type 'void (void *, std::size_t) noexcept' is only available on iOS 10 or newer}}}
+#elif defined(TVOS)
+// expected-error@-5 {{sized deallocation function of type 'void (void *, std::size_t) noexcept' is only available on tvOS 10 or newer}}}
+#elif defined(WATCHOS)
+// expected-error@-7 {{sized deallocation function of type 'void (void *, std::size_t) noexcept' is only available on watchOS 3 or newer}}}
+#elif !defined(NO_ERRORS)
+// expected-error@-9 {{sized deallocation function of type 'void (void *, std::size_t) noexcept' is only available on macOS 10.12 or newer}}}
+#endif
+#ifndef NO_ERRORS
+// expected-note@-12 1 {{if you supply your own sized deallocation functions}}
+#endif
+
+// No errors if user-defined sized deallocation functions are available.
+void *operator new(std::size_t __sz, std::size_t) {
+  static char array[256];
+  return &array;
+}
+
+void operator delete(void *p, std::size_t) {
+}
+
+void testOveraligned2() {
+  auto p = new S;
+  delete p;
+}