[Builtins] Overload __builtin_operator_new/delete to allow forwarding to usual allocation/deallocation functions.

[EricWF]

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.

[rsmith]

lib/CodeGen/CGExprCXX.cpp

1309–1344

Can we leave this code alone and set the builtin expression's type to exactly match the type of the chosen function? I really don't want to be special-casing aligned allocation here. (This change should also cover sized delete and any future extensions to builtin operator new/delete.)

lib/Lex/PPMacroExpansion.cpp

1242–1243

Hmm, I'd prefer something that just indicates that we have generalized __builtin_operator_new/delete support, so that you can use it for sized delete too.

lib/Sema/SemaChecking.cpp

2918–2962

Here's how I think this should work:

• perform overload resolution for an operator new or operator delete with the given arguments
• if the selected function is not a usual allocation / deallocation function, issue an error
• set the type of the callee expression to the type of the selected function and convert the parameters as if you were going to call the selected function (so that codegen can find the correct callee again)

[EricWF]

lib/CodeGen/CGExprCXX.cpp

1309–1344

That doesn't seem possible as you describe it. Both overloads of the builtin operator share the same FunctionDecl, and we can't change the type of that decl to match the selected operator for a particular call.

I think checking the argument types is the best way to proceed. However, I'll change the types of the call expression to exactly match the types of the selected operator new/delete, which will at least clean this up some.

[EricWF]

lib/CodeGen/CGExprCXX.cpp

1309–1344

Nevermind... I see what you meant. I can set the Callee type and not the type of the CalleeDecl.

[EricWF]

@rsmith Is this the direction you were thinking?

I haven't updated the tests yet, but I wanted to make the other changes visible earlier.

[EricWF]

• Complete implementation suggested by @rsmith. The builtins now perform overload resolution to allow calling arbitrary usual allocation/deallocation functions.
• Complete tests.

[EricWF]

Ping.

[rsmith]

Thanks, this looks great.

lib/Sema/SemaExprCXX.cpp

3458 ↗

(On Diff #134989)

It would be nice to assert that the callee you're setting the type of is an ImplicitCastExpr doing a BuiltinFnToFnPtr cast (just so that it's obvious that this is the only type we need to update and that it's freshly-created).

[EricWF]

• Merge with upstream.
• Add requested assertion.

lib/Sema/SemaExprCXX.cpp

3458 ↗

(On Diff #134989)

Ack. Done.

include/clang/Basic/Builtins.def

 BUILTIN(__builtin_ssubl_overflow, "bSLiCSLiCSLi*", "n")
 BUILTIN(__builtin_ssubll_overflow, "bSLLiCSLLiCSLLi*", "n")
 BUILTIN(__builtin_smul_overflow, "bSiCSiCSi*", "n")
 BUILTIN(__builtin_smull_overflow, "bSLiCSLiCSLi*", "n")
 BUILTIN(__builtin_smulll_overflow, "bSLLiCSLLiCSLLi*", "n")
 
 // 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
 BUILTIN(__builtin___get_unsafe_stack_start, "v*", "Fn")
 BUILTIN(__builtin___get_unsafe_stack_ptr, "v*", "Fn")
 
 // Nontemporal loads/stores builtins
 BUILTIN(__builtin_nontemporal_store, "v.", "t")

include/clang/Basic/DiagnosticSemaKinds.td

   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 warn_aligned_builtin_operator_new_unavailable :Warning<
+  "aligned %select{__builtin_operator_new|__builtin_operator_delete}0 function 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_builtin_operator_new_requires_aligned_allocation : Error<
+  "%select{__builtin_operator_new|__builtin_operator_delete}0 with alignment "
+  "requires aligned allocation support; use -faligned-allocation to enable">;
 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">;
 def err_conditional_ambiguous_ovl : Error<

include/clang/Sema/Sema.h

   bool SemaBuiltinAssume(CallExpr *TheCall);
   bool SemaBuiltinAssumeAligned(CallExpr *TheCall);
   bool SemaBuiltinLongjmp(CallExpr *TheCall);
   bool SemaBuiltinSetjmp(CallExpr *TheCall);
   ExprResult SemaBuiltinAtomicOverloaded(ExprResult TheCallResult);
   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,
                                    int Low, int High);
   bool SemaBuiltinConstantArgMultiple(CallExpr *TheCall, int ArgNum,
                                       unsigned Multiple);
   bool SemaBuiltinARMSpecialReg(unsigned BuiltinID, CallExpr *TheCall,
                                 int ArgNum, unsigned ExpectedFieldNum,

lib/CodeGen/CGBuiltin.cpp

     Builder.CreateStore(Sum, SumOutPtr);
 
     return RValue::get(Carry);
   }
   case Builtin::BI__builtin_addressof:
     return RValue::get(EmitLValue(E->getArg(0)).getPointer());
   case Builtin::BI__builtin_operator_new:
     return EmitBuiltinNewDeleteCall(FD->getType()->castAs<FunctionProtoType>(),
-                                    E->getArg(0), false);
+                                    E, false);
   case Builtin::BI__builtin_operator_delete:
     return EmitBuiltinNewDeleteCall(FD->getType()->castAs<FunctionProtoType>(),
-                                    E->getArg(0), true);
+                                    E, true);
+
   case Builtin::BI__noop:
     // __noop always evaluates to an integer literal zero.
     return RValue::get(ConstantInt::get(IntTy, 0));
   case Builtin::BI__builtin_call_with_static_chain: {
     const CallExpr *Call = cast<CallExpr>(E->getArg(0));
     const Expr *Chain = E->getArg(1);
     return EmitCall(Call->getCallee()->getType(),
                     EmitCallee(Call->getCallee()), Call, ReturnValue,

lib/CodeGen/CGExprCXX.cpp

                        llvm::Attribute::Builtin);
     else
       llvm_unreachable("unexpected kind of call instruction");
   }
 
   return RV;
 }
 
 RValue CodeGenFunction::EmitBuiltinNewDeleteCall(const FunctionProtoType *Type,
-                                                 const Expr *Arg,
-                                                 bool IsDelete) {
+                                                 const Expr *E, bool IsDelete) {
+  const auto *TheCall = dyn_cast<CallExpr>(E);
+  llvm::SmallVector<QualType, 2> ArgTypes;
+  for (auto *Arg : TheCall->arguments())
+    ArgTypes.push_back(Arg->getType());
   CallArgList Args;
-  const Stmt *ArgS = Arg;
-  EmitCallArgs(Args, *Type->param_type_begin(), llvm::makeArrayRef(ArgS));
+  EmitCallArgs(Args, ArgTypes, 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);
+
+  auto IsMatchingDecl = [&](FunctionDecl *FD) {
+    if (TheCall->getNumArgs() != FD->getNumParams())
+      return false;
+    if (!Ctx.hasSameType(TheCall->getArg(0)->getType(),
+                         FD->getParamDecl(0)->getType()))
+      return false;
+    if (TheCall->getNumArgs() == 2 &&
+        !FD->getParamDecl(1)->getType()->isAlignValT())
+      return false;
+    // FIXME: Should we be comparing things like the exception type of the
+    // functions to ensure it perfectly matches the standard?
+    if (Type->getExtInfo() !=
+        FD->getType()->getAs<FunctionProtoType>()->getExtInfo())
+      return false;
+    return true;
+  };
+
   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);
+      if (IsMatchingDecl(FD))
+        return EmitNewDeleteCall(*this, FD, Type, Args);
   llvm_unreachable("predeclared global operator new/delete is missing");
 }
 
 namespace {
 /// The parameters to pass to a usual operator delete.
 struct UsualDeleteParams {
   bool DestroyingDelete = false;
   bool Size = false;
   bool Alignment = false;
 };

lib/CodeGen/CodeGenFunction.h

   llvm::Value *EmitCXXNewExpr(const CXXNewExpr *E);
   void EmitCXXDeleteExpr(const CXXDeleteExpr *E);
 
   void EmitDeleteCall(const FunctionDecl *DeleteFD, llvm::Value *Ptr,
                       QualType DeleteTy, llvm::Value *NumElements = nullptr,
                       CharUnits CookieSize = CharUnits());
 
   RValue EmitBuiltinNewDeleteCall(const FunctionProtoType *Type,
-                                  const Expr *Arg, bool IsDelete);
+                                  const Expr *TheCallExpr, bool IsDelete);
 
   llvm::Value *EmitCXXTypeidExpr(const CXXTypeidExpr *E);
   llvm::Value *EmitDynamicCast(Address V, const CXXDynamicCastExpr *DCE);
   Address EmitCXXUuidofExpr(const CXXUuidofExpr *E);
 
   /// \brief Situations in which we might emit a check for the suitability of a
   ///        pointer or glvalue.
   enum TypeCheckKind {

lib/Lex/PPMacroExpansion.cpp

       .Case("cxx_generic_lambdas", LangOpts.CPlusPlus14)
       .Case("cxx_init_captures", LangOpts.CPlusPlus14)
       .Case("cxx_relaxed_constexpr", LangOpts.CPlusPlus14)
       .Case("cxx_return_type_deduction", LangOpts.CPlusPlus14)
       .Case("cxx_variable_templates", LangOpts.CPlusPlus14)
       // NOTE: For features covered by SD-6, it is preferable to provide *only*
       // the SD-6 macro and not a __has_feature check.
 
+      // Clang specific changes which libc++ needs to be able to detect
+      .Case("has_aligned_builtin_operator_new",
+            LangOpts.CPlusPlus && LangOpts.AlignedAllocation)
+
       // C++ TSes
       //.Case("cxx_runtime_arrays", LangOpts.CPlusPlusTSArrays)
       //.Case("cxx_concepts", LangOpts.CPlusPlusTSConcepts)
       // FIXME: Should this be __has_feature or __has_extension?
       //.Case("raw_invocation_type", LangOpts.CPlusPlus)
       // Type traits
       // N.B. Additional type traits should not be added to the following list.
       // Instead, they should be detected by has_extension.

lib/Sema/SemaChecking.cpp

 #include "clang/AST/OperationKinds.h"
 #include "clang/AST/Stmt.h"
 #include "clang/AST/TemplateBase.h"
 #include "clang/AST/Type.h"
 #include "clang/AST/TypeLoc.h"
 #include "clang/AST/UnresolvedSet.h"
 #include "clang/Analysis/Analyses/FormatString.h"
 #include "clang/Basic/AddressSpaces.h"
+#include "clang/Basic/AlignedAllocation.h"
 #include "clang/Basic/CharInfo.h"
 #include "clang/Basic/Diagnostic.h"
 #include "clang/Basic/IdentifierTable.h"
 #include "clang/Basic/LLVM.h"
 #include "clang/Basic/LangOptions.h"
 #include "clang/Basic/OpenCLOptions.h"
 #include "clang/Basic/OperatorKinds.h"
 #include "clang/Basic/PartialDiagnostic.h"
case Builtin::BI__builtin_addressof:
     break;
   case Builtin::BI__builtin_add_overflow:
   case Builtin::BI__builtin_sub_overflow:
   case Builtin::BI__builtin_mul_overflow:
     if (SemaBuiltinOverflow(*this, TheCall))
       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:
   case Builtin::BI__builtin___memmove_chk:
   case Builtin::BI__builtin___memset_chk:
   case Builtin::BI__builtin___strlcat_chk:
   case Builtin::BI__builtin___strlcpy_chk:
   case Builtin::BI__builtin___strncat_chk:
return OrderingCABI != llvm::AtomicOrderingCABI::consume &&
            OrderingCABI != llvm::AtomicOrderingCABI::acquire &&
            OrderingCABI != llvm::AtomicOrderingCABI::acq_rel;
 
   default:
     return true;
   }
 }
 
+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();
+
+  TheCall->setType(IsDelete ? Context.VoidTy : Context.VoidPtrTy);
+
+  if (TheCall->getNumArgs() < 1) {
+    Diag(TheCall->getLocEnd(), diag::err_typecheck_call_too_few_args)
+        << 0 << 1 << TheCall->getNumArgs()
+        << TheCall->getCallee()->getSourceRange();
+    return ExprError();
+  } else if (TheCall->getNumArgs() > 2) {
+    Diag(TheCall->getArg(2)->getLocStart(),
+         diag::err_typecheck_call_too_many_args)
+        << 0 << 2 << TheCall->getNumArgs()
+        << TheCall->getCallee()->getSourceRange();
+    return ExprError();
+  }
+
+  llvm::SmallVector<QualType, 2> ArgTypes;
+  ArgTypes.push_back(IsDelete ? Context.VoidPtrTy : Context.getSizeType());
+
+  if (TheCall->getNumArgs() == 2) {
+    if (!getLangOpts().AlignedAllocation) {
+      Diag(TheCall->getArg(1)->getLocStart(),
+           diag::err_builtin_operator_new_requires_aligned_allocation)
+          << IsDelete << TheCall->getSourceRange();
+      return ExprError();
+    }
+    if (getLangOpts().AlignedAllocationUnavailable) {
+      const llvm::Triple &T = Context.getTargetInfo().getTriple();
+      StringRef OSName = AvailabilityAttr::getPlatformNameSourceSpelling(
+          Context.getTargetInfo().getPlatformName());
+      auto Loc = TheCall->getExprLoc();
+      Diag(Loc, diag::warn_aligned_builtin_operator_new_unavailable)
+          << IsDelete << OSName
+          << alignedAllocMinVersion(T.getOS()).getAsString();
+      Diag(Loc, diag::note_silence_unligned_allocation_unavailable);
+    }
+    ArgTypes.push_back(getStdAlignValT()->getIntegerType());
+  }
+
+  for (unsigned i = 0; i != TheCall->getNumArgs(); ++i) {
+    InitializedEntity Entity =
+        InitializedEntity::InitializeParameter(Context, ArgTypes[i], false);
+    ExprResult Arg = TheCall->getArg(i);
+    Arg = PerformCopyInitialization(Entity, SourceLocation(), Arg);
+    if (Arg.isInvalid())
+      return ExprError();
+    TheCall->setArg(i, Arg.get());
+  }
+
+  return TheCallResult;
+}
+
 ExprResult Sema::SemaAtomicOpsOverloaded(ExprResult TheCallResult,
                                          AtomicExpr::AtomicOp Op) {
   CallExpr *TheCall = cast<CallExpr>(TheCallResult.get());
   DeclRefExpr *DRE =cast<DeclRefExpr>(TheCall->getCallee()->IgnoreParenCasts());
 
   // All the non-OpenCL operations take one of the following forms.
   // The OpenCL operations take the __c11 forms with one extra argument for
   // synchronization scope.

test/CodeGenCXX/new.cpp

-// RUN: %clang_cc1 -triple x86_64-unknown-unknown %s -emit-llvm -o - | FileCheck %s
+// RUN: %clang_cc1 -triple x86_64-unknown-unknown %s -verify -faligned-allocation \
+// RUN:    -emit-llvm -o - | FileCheck %s
 
 typedef __typeof__(sizeof(0)) 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.

 
 namespace builtins {
   // CHECK-LABEL: define void @_ZN8builtins1fEv
   void f() {
     // CHECK: call i8* @_Znwm(i64 4) [[ATTR_BUILTIN_NEW]]
     // CHECK: call void @_ZdlPv({{.*}}) [[ATTR_BUILTIN_DELETE]]
     __builtin_operator_delete(__builtin_operator_new(4));
   }
+  // CHECK-LABEL: define void @_ZN8builtins1gEv
+  void g() {
+    // 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, 4), 4);
+  }
 }
 
 // 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 {{.*[}]}}
 
 // The ([^b}|...) monstrosity is matching a character that's not the start of 'builtin'.
 // Add more letters if this matches some other attribute.
 // CHECK-DAG: attributes [[ATTR_NOUNWIND]] = {{([^b]|b[^u]|bu[^i]|bui[^l])*}} nounwind {{([^b]|b[^u]|bu[^i]|bui[^l])*$}}

test/Lexer/has_feature_aligned_builtin_new.cpp

+// RUN: %clang_cc1 -E -triple x86_64-linux-gnu -std=c++11 %s -o - | \
+// RUN:   FileCheck --check-prefix=CHECK-NO-BUILTIN %s
+// RUN: %clang_cc1 -E -triple x86_64-linux-gnu -std=c++11 -faligned-allocation %s -o - | \
+// RUN:   FileCheck --check-prefix=CHECK-HAS-BUILTIN %s
+// RUN: %clang_cc1 -E -triple x86_64-linux-gnu -std=c++1z %s -o - | \
+// RUN:   FileCheck --check-prefix=CHECK-HAS-BUILTIN %s
+// RUN: %clang_cc1 -E -triple x86_64-linux-gnu -std=c++1z -fno-aligned-allocation %s -o - | \
+// RUN:   FileCheck --check-prefix=CHECK-NO-BUILTIN %s
+
+#if __has_feature(has_aligned_builtin_operator_new)
+void has_builtin();
+#else
+void no_builtin();
+#endif
+
+// CHECK-HAS-BUILTIN: has_builtin
+// CHECK-NO-BUILTIN: no_builtin

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

+// 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++1z -fno-aligned-allocation -fsyntax-only -verify %s
+
+void test_disabled() {
+#ifdef __cpp_aligned_new
+  // expected-no-diagnostics
+#else
+  // expected-error@+3 {{__builtin_operator_new with alignment requires aligned allocation support; use -faligned-allocation to enable}}
+  // expected-error@+3 {{__builtin_operator_delete with alignment requires aligned allocation support; use -faligned-allocation to enable}}
+#endif
+  (void)__builtin_operator_new(1, 2);
+  __builtin_operator_delete((void *)0, 2);
+}

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

+// RUN: %clang_cc1 -std=c++1z -fsyntax-only -verify %s
+// RUN: %clang_cc1 -std=c++03 -faligned-allocation -fsyntax-only -verify %s
+
+void *NP = 0;
+
+void test_signature() {
+  __builtin_operator_new();           // expected-error {{too few arguments to function call, expected 1, have 0}}
+  __builtin_operator_new(0, 0, 0);    // expected-error {{too many arguments to function call, expected 2, have 3}}
+  __builtin_operator_delete();        // expected-error {{too few arguments to function call, expected 1, have 0}}
+  __builtin_operator_delete(0, 0, 0); // expected-error {{too many arguments to function call, expected 2, have 3}}
+}
+
+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 {{cannot initialize a parameter of type 'unsigned long' with an lvalue of type 'void *'}}
+  __builtin_operator_new(NP, 0); // expected-error {{cannot initialize a parameter of type 'unsigned long' with an lvalue of type 'void *'}}
+}
+
+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 x = __builtin_operator_new(42, 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'}}
+  int z = __builtin_operator_delete(NP, 42); // expected-error {{cannot initialize a variable of type 'int' with an rvalue of type 'void'}}
+}