Use returns_nonnull in BumpPtrAllocator and MallocAllocator to avoid null-check in placement new

[hans]

Summary

In both Clang and LLVM, this is a common pattern:

Size = sizeof(DeclRefExpr) + SomeExtraStuff;
void *Mem = Context.Allocate(Size, llvm::alignOf<DeclRefExpr>());
return new (Mem) DeclRefExpr(...);

The annoying thing is that because the default placement-new operator has a nothrow specification, the compiler will insert a null check of Mem before calling the DeclRefExpr constructor. This null check is redundant for us, because we expect the allocation functions to never return null.

By annotating the allocator functions with returns_nonnull, we can optimize away these checks. Compiling clang with a recent version of Clang and measuring with:

$ perf stat -r20 bin/clang.patch -fsyntax-only -w /tmp/gcc.c && perf stat -r20 bin/clang.orig -fsyntax-only -w /tmp/gcc.c

Shows a 2.4% speed-up (+- 0.8%).

The pattern occurs in LLVM too. Measuring with -O3 (and now using bzip2.c instead because it's smaller):

$ perf stat -r20 bin/clang.patch -O3 -w /tmp/bzip2.c  &&  perf stat -r20 bin/clang.orig -O3 -w /tmp/bzip2.c

Shows 4.4 % speed-up (+- 1%).

If anyone knows of a similar attribute we can use for MSVC, or some other technique to get rid off the null check there, please let me know.

[chandlerc]

Regardless of whether we can add more portable tricks, this seems like a strict improvement in the allocation API. Awesome speedups too!

include/llvm/Support/Allocator.h

93 ↗

(On Diff #12707)

Why is this attribute in a different location?

[hans]

include/llvm/Support/Allocator.h

93 ↗

(On Diff #12707)

Oops, that was not intentional.

[hans]

Closed by commit rL216192 (authored by @hans).

llvm/trunk/include/llvm/Support/Allocator.h

Deallocate(T *Ptr, size_t Num = 1) {
     Deallocate(static_cast<const void *>(Ptr), Num * sizeof(T));
   }
 };
 
 class MallocAllocator : public AllocatorBase<MallocAllocator> {
 public:
   void Reset() {}
 
-  void *Allocate(size_t Size, size_t /*Alignment*/) { return malloc(Size); }
+  LLVM_ATTRIBUTE_RETURNS_NONNULL void *Allocate(size_t Size,
+                                                size_t /*Alignment*/) {
+    return malloc(Size);
+  }
 
   // Pull in base class overloads.
   using AllocatorBase<MallocAllocator>::Allocate;
 
   void Deallocate(const void *Ptr, size_t /*Size*/) {
     free(const_cast<void *>(Ptr));
   }
 
void Reset() {
     // Deallocate all but the first slab, and all custome sized slabs.
     DeallocateSlabs(std::next(Slabs.begin()), Slabs.end());
     Slabs.erase(std::next(Slabs.begin()), Slabs.end());
     DeallocateCustomSizedSlabs();
     CustomSizedSlabs.clear();
   }
 
   /// \brief Allocate space at the specified alignment.
-  void *Allocate(size_t Size, size_t Alignment) {
+  LLVM_ATTRIBUTE_RETURNS_NONNULL void *Allocate(size_t Size, size_t Alignment) {
     assert(Alignment > 0 && "0-byte alignnment is not allowed. Use 1 instead.");
 
     // Keep track of how many bytes we've allocated.
     BytesAllocated += Size;
 
     // Allocate the aligned space, going forwards from CurPtr.
     char *Ptr = alignPtr(CurPtr, Alignment);
 

llvm/trunk/include/llvm/Support/Compiler.h

 #ifdef __GNUC__
 #define LLVM_ATTRIBUTE_NORETURN __attribute__((noreturn))
 #elif defined(_MSC_VER)
 #define LLVM_ATTRIBUTE_NORETURN __declspec(noreturn)
 #else
 #define LLVM_ATTRIBUTE_NORETURN
 #endif
 
+#if __has_attribute(returns_nonnull) || __GNUC_PREREQ(4, 9)
+#define LLVM_ATTRIBUTE_RETURNS_NONNULL __attribute__((returns_nonnull))
+#else
+#define LLVM_ATTRIBUTE_RETURNS_NONNULL
+#endif
+
 /// LLVM_EXTENSION - Support compilers where we have a keyword to suppress
 /// pedantic diagnostics.
 #ifdef __GNUC__
 #define LLVM_EXTENSION __extension__
 #else
 #define LLVM_EXTENSION
 #endif