Use uniform mechanism for OOM errors handling

[sepavloff]

Summary

In r325551 many calls of malloc/calloc/realloc were replaces with calls of
their safe counterparts defined in the namespace llvm. There functions
generate crash if memory cannot be allocated, such behavior facilitates
handling of out of memory errors on Windows.

If the result of *alloc function were checked for success, the function was
not replaced with the safe variant. In these cases the calling function made
the error handling, like:

T *NewElts = static_cast<T*>(malloc(NewCapacity*sizeof(T)));
if (NewElts == nullptr)
  report_bad_alloc_error("Allocation of SmallVector element failed.");

Actually knowledge about the function where OOM occurred is useless. Moreover
having a single entry point for OOM handling is convenient for investigation
of memory problems. This change removes custom OOM errors handling and
replaces them with calls to functions llvm::safe_*alloc.

Declarations of safe_*alloc are moved to a separate include file, to avoid
cyclic dependency in SmallVector.h

[rnk]

lgtm

Factoring all this checking out seems like a win.

include/llvm/Support/MemAlloc.h

25 ↗

(On Diff #148784)

I'm not totally happy with the name "safe" here. They're really no "safer", they just have a different failure mode that is hookable. I kind of like mallocOrDie or malloc_or_die, which is the naming used by the sanitizer libraries. Let's leave it alone for now, though.

[lebedev.ri]

It would seem this is slightly incorrect.

$ ninja -j1
[1/4533] Linking CXX shared library lib/libLLVMDemangle.so.7svn
FAILED: lib/libLLVMDemangle.so.7svn 
: && /usr/bin/clang++-6.0 -fPIC -g0 -fPIC -fvisibility-inlines-hidden -Werror -Werror=date-time -Werror=unguarded-availability-new -std=c++11 -Wall -W -Wno-unused-parameter -Wwrite-strings -Wcast-qual -Wmissing-field-initializers -pedantic -Wno-long-long -Wcovered-switch-default -Wnon-virtual-dtor -Wdelete-non-virtual-dtor -Wstring-conversion -fdiagnostics-color -ffunction-sections -fdata-sections -O3 -g0  -Wl,-z,defs -Wl,-z,nodelete -fuse-ld=lld -Wl,--color-diagnostics   -Wl,-O3 -Wl,--gc-sections -shared -Wl,-soname,libLLVMDemangle.so.7 -o lib/libLLVMDemangle.so.7svn lib/Demangle/CMakeFiles/LLVMDemangle.dir/ItaniumDemangle.cpp.o  -Wl,-rpath,"\$ORIGIN/../lib" && :
/usr/lib/llvm-6.0/bin/ld.lld: error: undefined symbol: llvm::report_bad_alloc_error(char const*, bool)
>>> referenced by ItaniumDemangle.cpp
>>>               lib/Demangle/CMakeFiles/LLVMDemangle.dir/ItaniumDemangle.cpp.o:(llvm::itaniumDemangle(char const*, char*, unsigned long*, int*))

/usr/lib/llvm-6.0/bin/ld.lld: error: undefined symbol: llvm::report_bad_alloc_error(char const*, bool)
>>> referenced by ItaniumDemangle.cpp
>>>               lib/Demangle/CMakeFiles/LLVMDemangle.dir/ItaniumDemangle.cpp.o:(llvm::printNode((anonymous namespace)::Node*, char*, unsigned long*))

/usr/lib/llvm-6.0/bin/ld.lld: error: undefined symbol: llvm::report_bad_alloc_error(char const*, bool)
>>> referenced by ItaniumDemangle.cpp
>>>               lib/Demangle/CMakeFiles/LLVMDemangle.dir/ItaniumDemangle.cpp.o:(llvm::ItaniumPartialDemangler::getFunctionDeclContextName(char*, unsigned long*) const)

/usr/lib/llvm-6.0/bin/ld.lld: error: undefined symbol: llvm::report_bad_alloc_error(char const*, bool)
>>> referenced by ItaniumDemangle.cpp
>>>               lib/Demangle/CMakeFiles/LLVMDemangle.dir/ItaniumDemangle.cpp.o:(llvm::ItaniumPartialDemangler::getFunctionDeclContextName(char*, unsigned long*) const)

/usr/lib/llvm-6.0/bin/ld.lld: error: undefined symbol: llvm::report_bad_alloc_error(char const*, bool)
>>> referenced by ItaniumDemangle.cpp
>>>               lib/Demangle/CMakeFiles/LLVMDemangle.dir/ItaniumDemangle.cpp.o:(llvm::ItaniumPartialDemangler::getFunctionDeclContextName(char*, unsigned long*) const)

/usr/lib/llvm-6.0/bin/ld.lld: error: undefined symbol: llvm::report_bad_alloc_error(char const*, bool)
>>> referenced by ItaniumDemangle.cpp
>>>               lib/Demangle/CMakeFiles/LLVMDemangle.dir/ItaniumDemangle.cpp.o:(llvm::ItaniumPartialDemangler::getFunctionParameters(char*, unsigned long*) const)

/usr/lib/llvm-6.0/bin/ld.lld: error: undefined symbol: llvm::report_bad_alloc_error(char const*, bool)
>>> referenced by ItaniumDemangle.cpp
>>>               lib/Demangle/CMakeFiles/LLVMDemangle.dir/ItaniumDemangle.cpp.o:(llvm::ItaniumPartialDemangler::getFunctionParameters(char*, unsigned long*) const)

/usr/lib/llvm-6.0/bin/ld.lld: error: undefined symbol: llvm::report_bad_alloc_error(char const*, bool)
>>> referenced by ItaniumDemangle.cpp
>>>               lib/Demangle/CMakeFiles/LLVMDemangle.dir/ItaniumDemangle.cpp.o:(llvm::ItaniumPartialDemangler::getFunctionParameters(char*, unsigned long*) const)

/usr/lib/llvm-6.0/bin/ld.lld: error: undefined symbol: llvm::report_bad_alloc_error(char const*, bool)
>>> referenced by ItaniumDemangle.cpp
>>>               lib/Demangle/CMakeFiles/LLVMDemangle.dir/ItaniumDemangle.cpp.o:(llvm::ItaniumPartialDemangler::getFunctionParameters(char*, unsigned long*) const)

/usr/lib/llvm-6.0/bin/ld.lld: error: undefined symbol: llvm::report_bad_alloc_error(char const*, bool)
>>> referenced by ItaniumDemangle.cpp
>>>               lib/Demangle/CMakeFiles/LLVMDemangle.dir/ItaniumDemangle.cpp.o:(llvm::ItaniumPartialDemangler::getFunctionReturnType(char*, unsigned long*) const)

/usr/lib/llvm-6.0/bin/ld.lld: error: undefined symbol: llvm::report_bad_alloc_error(char const*, bool)
>>> referenced by ItaniumDemangle.cpp
>>>               lib/Demangle/CMakeFiles/LLVMDemangle.dir/ItaniumDemangle.cpp.o:((anonymous namespace)::PODSmallVector<(anonymous namespace)::Node*, 32ul>::push_back((anonymous namespace)::Node* const&))

/usr/lib/llvm-6.0/bin/ld.lld: error: undefined symbol: llvm::report_bad_alloc_error(char const*, bool)
>>> referenced by ItaniumDemangle.cpp
>>>               lib/Demangle/CMakeFiles/LLVMDemangle.dir/ItaniumDemangle.cpp.o:((anonymous namespace)::PODSmallVector<(anonymous namespace)::Node*, 32ul>::push_back((anonymous namespace)::Node* const&))

/usr/lib/llvm-6.0/bin/ld.lld: error: undefined symbol: llvm::report_bad_alloc_error(char const*, bool)
>>> referenced by ItaniumDemangle.cpp
>>>               lib/Demangle/CMakeFiles/LLVMDemangle.dir/ItaniumDemangle.cpp.o:((anonymous namespace)::SpecialName::printLeft((anonymous namespace)::OutputStream&) const)

/usr/lib/llvm-6.0/bin/ld.lld: error: undefined symbol: llvm::report_bad_alloc_error(char const*, bool)
>>> referenced by ItaniumDemangle.cpp
>>>               lib/Demangle/CMakeFiles/LLVMDemangle.dir/ItaniumDemangle.cpp.o:((anonymous namespace)::CtorVtableSpecialName::printLeft((anonymous namespace)::OutputStream&) const)

/usr/lib/llvm-6.0/bin/ld.lld: error: undefined symbol: llvm::report_bad_alloc_error(char const*, bool)
>>> referenced by ItaniumDemangle.cpp
>>>               lib/Demangle/CMakeFiles/LLVMDemangle.dir/ItaniumDemangle.cpp.o:((anonymous namespace)::CtorVtableSpecialName::printLeft((anonymous namespace)::OutputStream&) const)

/usr/lib/llvm-6.0/bin/ld.lld: error: undefined symbol: llvm::report_bad_alloc_error(char const*, bool)
>>> referenced by ItaniumDemangle.cpp
>>>               lib/Demangle/CMakeFiles/LLVMDemangle.dir/ItaniumDemangle.cpp.o:((anonymous namespace)::Db::parseTemplateArgs(bool))

/usr/lib/llvm-6.0/bin/ld.lld: error: undefined symbol: llvm::report_bad_alloc_error(char const*, bool)
>>> referenced by ItaniumDemangle.cpp
>>>               lib/Demangle/CMakeFiles/LLVMDemangle.dir/ItaniumDemangle.cpp.o:((anonymous namespace)::Db::parseTemplateArgs(bool))

/usr/lib/llvm-6.0/bin/ld.lld: error: undefined symbol: llvm::report_bad_alloc_error(char const*, bool)
>>> referenced by ItaniumDemangle.cpp
>>>               lib/Demangle/CMakeFiles/LLVMDemangle.dir/ItaniumDemangle.cpp.o:((anonymous namespace)::Db::parseTemplateParam())

/usr/lib/llvm-6.0/bin/ld.lld: error: undefined symbol: llvm::report_bad_alloc_error(char const*, bool)
>>> referenced by ItaniumDemangle.cpp
>>>               lib/Demangle/CMakeFiles/LLVMDemangle.dir/ItaniumDemangle.cpp.o:((anonymous namespace)::Db::parseTemplateParam())

/usr/lib/llvm-6.0/bin/ld.lld: error: undefined symbol: llvm::report_bad_alloc_error(char const*, bool)
>>> referenced by ItaniumDemangle.cpp
>>>               lib/Demangle/CMakeFiles/LLVMDemangle.dir/ItaniumDemangle.cpp.o:((anonymous namespace)::NameType::printLeft((anonymous namespace)::OutputStream&) const)

/usr/lib/llvm-6.0/bin/ld.lld: error: too many errors emitted, stopping now (use -error-limit=0 to see all errors)
clang: error: linker command failed with exit code 1 (use -v to see invocation)
ninja: build stopped: subcommand failed.

If i try to fix it:

diff --git a/lib/Demangle/CMakeLists.txt b/lib/Demangle/CMakeLists.txt
index 74e37654f07..e03b555e3a6 100644
--- a/lib/Demangle/CMakeLists.txt
+++ b/lib/Demangle/CMakeLists.txt
@@ -1,3 +1,6 @@
 add_llvm_library(LLVMDemangle
   ItaniumDemangle.cpp
+
+  LINK_LIBS
+  LLVMSupport
 )

It does not work:

Configuring done
CMake Error: The inter-target dependency graph contains the following strongly connected component (cycle):
  "LLVMDemangle" of type SHARED_LIBRARY
    depends on "LLVMSupport" (weak)
  "LLVMSupport" of type SHARED_LIBRARY
    depends on "LLVMDemangle" (weak)
At least one of these targets is not a STATIC_LIBRARY.  Cyclic dependencies are allowed only among static libraries.
CMake Project parsing failed.

So this somehow introduced a cycle into dependency graph?

@dblaikie,@rnk,@sepavloff Thoughts on temporarily reverting for now?

[rnk]

I would revert the changes to the demangler library only, if possible, and
just leave that as a special case. I assume we do some weird stuff to call
report_fatal_error without introducing a circular dependency.

llvm/trunk/include/llvm/ADT/SmallVector.h

 
 #ifndef LLVM_ADT_SMALLVECTOR_H
 #define LLVM_ADT_SMALLVECTOR_H
 
 #include "llvm/ADT/iterator_range.h"
 #include "llvm/Support/AlignOf.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/MathExtras.h"
+#include "llvm/Support/MemAlloc.h"
 #include "llvm/Support/type_traits.h"
 #include "llvm/Support/ErrorHandling.h"
 #include <algorithm>
 #include <cassert>
 #include <cstddef>
 #include <cstdlib>
 #include <cstring>
 #include <initializer_list>

 template <typename T, bool isPodLike>
 void SmallVectorTemplateBase<T, isPodLike>::grow(size_t MinSize) {
   size_t CurCapacity = this->capacity();
   size_t CurSize = this->size();
   // Always grow, even from zero.
   size_t NewCapacity = size_t(NextPowerOf2(CurCapacity+2));
   if (NewCapacity < MinSize)
     NewCapacity = MinSize;
-  T *NewElts = static_cast<T*>(malloc(NewCapacity*sizeof(T)));
-  if (NewElts == nullptr)
-    report_bad_alloc_error("Allocation of SmallVector element failed.");
+  T *NewElts = static_cast<T*>(llvm::safe_malloc(NewCapacity*sizeof(T)));
 
   // Move the elements over.
   this->uninitialized_move(this->begin(), this->end(), NewElts);
 
   // Destroy the original elements.
   destroy_range(this->begin(), this->end());
 
   // If this wasn't grown from the inline copy, deallocate the old space.

llvm/trunk/include/llvm/ADT/StringMap.h

static StringMapEntry *Create(StringRef Key, AllocatorTy &Allocator,
 
     // Allocate a new item with space for the string at the end and a null
     // terminator.
     size_t AllocSize = sizeof(StringMapEntry) + KeyLength + 1;
     size_t Alignment = alignof(StringMapEntry);
 
     StringMapEntry *NewItem =
       static_cast<StringMapEntry*>(Allocator.Allocate(AllocSize,Alignment));
-
-    if (NewItem == nullptr)
-      report_bad_alloc_error("Allocation of StringMap entry failed.");
+    assert(NewItem && "Unhandled out-of-memory");
 
     // Construct the value.
     new (NewItem) StringMapEntry(KeyLength, std::forward<InitTy>(InitVals)...);
 
     // Copy the string information.
     char *StrBuffer = const_cast<char*>(NewItem->getKeyData());
     if (KeyLength > 0)
       memcpy(StrBuffer, Key.data(), KeyLength);

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

 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_SUPPORT_ALLOCATOR_H
 #define LLVM_SUPPORT_ALLOCATOR_H
 
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/Support/Compiler.h"
-#include "llvm/Support/MathExtras.h"
 #include "llvm/Support/ErrorHandling.h"
+#include "llvm/Support/MathExtras.h"
+#include "llvm/Support/MemAlloc.h"
 #include <algorithm>
 #include <cassert>
 #include <cstddef>
 #include <cstdint>
 #include <cstdlib>
 #include <iterator>
 #include <type_traits>
 #include <utility>

 };
 
 class MallocAllocator : public AllocatorBase<MallocAllocator> {
 public:
   void Reset() {}
 
   LLVM_ATTRIBUTE_RETURNS_NONNULL void *Allocate(size_t Size,
                                                 size_t /*Alignment*/) {
-    void* memPtr =  malloc(Size);
-    if (memPtr == nullptr) 
-      report_bad_alloc_error("Allocation in MallocAllocator failed.");
-
-    return memPtr;
+    return safe_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 DestroyAll() {
 
     Allocator.Reset();
   }
 
   /// Allocate space for an array of objects without constructing them.
   T *Allocate(size_t num = 1) { return Allocator.Allocate<T>(num); }
 };
 
-/// \{
-/// Counterparts of allocation functions defined in namespace 'std', which crash
-/// on allocation failure instead of returning null pointer.
-
-LLVM_ATTRIBUTE_RETURNS_NONNULL inline void *safe_malloc(size_t Sz) {
-  void *Result = std::malloc(Sz);
-  if (Result == nullptr)
-    report_bad_alloc_error("Allocation failed.");
-  return Result;
-}
-
-LLVM_ATTRIBUTE_RETURNS_NONNULL inline void *safe_calloc(size_t Count,
-                                                        size_t Sz) {
-  void *Result = std::calloc(Count, Sz);
-  if (Result == nullptr)
-    report_bad_alloc_error("Allocation failed.");
-  return Result;
-}
-
-LLVM_ATTRIBUTE_RETURNS_NONNULL inline void *safe_realloc(void *Ptr, size_t Sz) {
-  void *Result = std::realloc(Ptr, Sz);
-  if (Result == nullptr)
-    report_bad_alloc_error("Allocation failed.");
-  return Result;
-}
-
-/// \}
-
 } // end namespace llvm
 
 template <typename AllocatorT, size_t SlabSize, size_t SizeThreshold>
 void *operator new(size_t Size,
                    llvm::BumpPtrAllocatorImpl<AllocatorT, SlabSize,
                                               SizeThreshold> &Allocator) {
   struct S {
     char c;

llvm/trunk/include/llvm/Support/MemAlloc.h

+//===- MemAlloc.h - Memory allocation functions -----------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+/// \file
+///
+/// This file defines counterparts of C library allocation functions defined in
+/// the namespace 'std'. The new allocation functions crash on allocation
+/// failure instead of returning null pointer.
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_SUPPORT_MEMALLOC_H
+#define LLVM_SUPPORT_MEMALLOC_H
+
+#include "llvm/Support/Compiler.h"
+#include "llvm/Support/ErrorHandling.h"
+
+namespace llvm {
+
+LLVM_ATTRIBUTE_RETURNS_NONNULL inline void *safe_malloc(size_t Sz) {
+  void *Result = std::malloc(Sz);
+  if (Result == nullptr)
+    report_bad_alloc_error("Allocation failed");
+  return Result;
+}
+
+LLVM_ATTRIBUTE_RETURNS_NONNULL inline void *safe_calloc(size_t Count,
+                                                        size_t Sz) {
+  void *Result = std::calloc(Count, Sz);
+  if (Result == nullptr)
+    report_bad_alloc_error("Allocation failed");
+  return Result;
+}
+
+LLVM_ATTRIBUTE_RETURNS_NONNULL inline void *safe_realloc(void *Ptr, size_t Sz) {
+  void *Result = std::realloc(Ptr, Sz);
+  if (Result == nullptr)
+    report_bad_alloc_error("Allocation failed");
+  return Result;
+}
+
+}
+#endif

llvm/trunk/lib/Demangle/ItaniumDemangle.cpp

 //===------------------------- ItaniumDemangle.cpp ------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // FIXME: (possibly) incomplete list of features that clang mangles that this
 // file does not yet support:
 //   - C++ modules TS
 
 #include "llvm/Demangle/Demangle.h"
-
 #include "llvm/Demangle/Compiler.h"
+#include "llvm/Support/MemAlloc.h"
 
 #include <algorithm>
 #include <cassert>
 #include <cctype>
 #include <cstdio>
 #include <cstdlib>
 #include <cstring>
 #include <numeric>
class OutputStream {
   size_t BufferCapacity;
 
   // Ensure there is at least n more positions in buffer.
   void grow(size_t N) {
     if (N + CurrentPosition >= BufferCapacity) {
       BufferCapacity *= 2;
       if (BufferCapacity < N + CurrentPosition)
         BufferCapacity = N + CurrentPosition;
-      Buffer = static_cast<char *>(std::realloc(Buffer, BufferCapacity));
+      Buffer = static_cast<char *>(llvm::safe_realloc(Buffer, BufferCapacity));
     }
   }
 
 public:
   OutputStream(char *StartBuf, size_t Size)
       : Buffer(StartBuf), CurrentPosition(0), BufferCapacity(Size) {}
   OutputStream() = default;
   void reset(char *Buffer_, size_t BufferCapacity_) {
public:
 
   virtual StringView getBaseName() const { return StringView(); }
 
   // Silence compiler warnings, this dtor will never be called.
   virtual ~Node() = default;
 
 #ifndef NDEBUG
   LLVM_DUMP_METHOD void dump() const {
-    char *Buffer = static_cast<char*>(std::malloc(1024));
+    char *Buffer = static_cast<char*>(llvm::safe_malloc(1024));
     OutputStream S(Buffer, 1024);
     print(S);
     S += '\0';
     printf("Symbol dump for %p: %s\n", (const void*)this, S.getBuffer());
     std::free(S.getBuffer());
   }
 #endif
 };
void clearInline() {
     First = Inline;
     Last = Inline;
     Cap = Inline + N;
   }
 
   void reserve(size_t NewCap) {
     size_t S = size();
     if (isInline()) {
-      auto* Tmp = static_cast<T*>(std::malloc(NewCap * sizeof(T)));
+      auto* Tmp = static_cast<T*>(llvm::safe_malloc(NewCap * sizeof(T)));
       std::copy(First, Last, Tmp);
       First = Tmp;
     } else
-      First = static_cast<T*>(std::realloc(First, NewCap * sizeof(T)));
+      First = static_cast<T*>(llvm::safe_realloc(First, NewCap * sizeof(T)));
     Last = First + S;
     Cap = First + NewCap;
   }
 
 public:
   PODSmallVector() : First(Inline), Last(First), Cap(Inline + N) {}
 
   PODSmallVector(const PODSmallVector&) = delete;

llvm/trunk/lib/IR/DataLayout.cpp

const StructLayout *DataLayout::getStructLayout(StructType *Ty) const {
 
   StructLayoutMap *STM = static_cast<StructLayoutMap*>(LayoutMap);
   StructLayout *&SL = (*STM)[Ty];
   if (SL) return SL;
 
   // Otherwise, create the struct layout.  Because it is variable length, we
   // malloc it, then use placement new.
   int NumElts = Ty->getNumElements();
-  StructLayout *L =
-    (StructLayout *)malloc(sizeof(StructLayout)+(NumElts-1) * sizeof(uint64_t));
-  if (L == nullptr)
-    report_bad_alloc_error("Allocation of StructLayout elements failed.");
+  StructLayout *L = (StructLayout *)
+      safe_malloc(sizeof(StructLayout)+(NumElts-1) * sizeof(uint64_t));
 
   // Set SL before calling StructLayout's ctor.  The ctor could cause other
   // entries to be added to TheMap, invalidating our reference.
   SL = L;
 
   new (L) StructLayout(Ty, *this);
 
   return L;

llvm/trunk/lib/Support/FoldingSet.cpp

 static void **GetBucketFor(unsigned Hash, void **Buckets, unsigned NumBuckets) {
   // NumBuckets is always a power of 2.
   unsigned BucketNum = Hash & (NumBuckets-1);
   return Buckets + BucketNum;
 }
 
 /// AllocateBuckets - Allocated initialized bucket memory.
 static void **AllocateBuckets(unsigned NumBuckets) {
-  void **Buckets = static_cast<void**>(calloc(NumBuckets+1, sizeof(void*)));
-
-  if (Buckets == nullptr)
-    report_bad_alloc_error("Allocation of Buckets failed.");
-  
+  void **Buckets = static_cast<void**>(safe_calloc(NumBuckets + 1,
+                                                   sizeof(void*)));
   // Set the very last bucket to be a non-null "pointer".
   Buckets[NumBuckets] = reinterpret_cast<void*>(-1);
   return Buckets;
 }
 
 //===----------------------------------------------------------------------===//
 // FoldingSetBase Implementation
 

llvm/trunk/lib/Support/Mutex.cpp

 using namespace sys;
 
 // Construct a Mutex using pthread calls
 MutexImpl::MutexImpl( bool recursive)
   : data_(nullptr)
 {
   // Declare the pthread_mutex data structures
   pthread_mutex_t* mutex =
-    static_cast<pthread_mutex_t*>(malloc(sizeof(pthread_mutex_t)));
-
-  if (mutex == nullptr)
-    report_bad_alloc_error("Mutex allocation failed");
+    static_cast<pthread_mutex_t*>(safe_malloc(sizeof(pthread_mutex_t)));
 
   pthread_mutexattr_t attr;
 
   // Initialize the mutex attributes
   int errorcode = pthread_mutexattr_init(&attr);
   assert(errorcode == 0); (void)errorcode;
 
   // Initialize the mutex as a recursive mutex, if requested, or normal

llvm/trunk/lib/Support/SmallPtrSet.cpp

void SmallPtrSetImplBase::shrink_and_clear() {
   free(CurArray);
 
   // Reduce the number of buckets.
   unsigned Size = size();
   CurArraySize = Size > 16 ? 1 << (Log2_32_Ceil(Size) + 1) : 32;
   NumNonEmpty = NumTombstones = 0;
 
   // Install the new array.  Clear all the buckets to empty.
-  CurArray = (const void**)malloc(sizeof(void*) * CurArraySize);
-  if (CurArray == nullptr)
-    report_bad_alloc_error("Allocation of SmallPtrSet bucket array failed.");
+  CurArray = (const void**)safe_malloc(sizeof(void*) * CurArraySize);
 
   memset(CurArray, -1, CurArraySize*sizeof(void*));
 }
 
 std::pair<const void *const *, bool>
 SmallPtrSetImplBase::insert_imp_big(const void *Ptr) {
   if (LLVM_UNLIKELY(size() * 4 >= CurArraySize * 3)) {
     // If more than 3/4 of the array is full, grow.

 /// Grow - Allocate a larger backing store for the buckets and move it over.
 ///
 void SmallPtrSetImplBase::Grow(unsigned NewSize) {
   const void **OldBuckets = CurArray;
   const void **OldEnd = EndPointer();
   bool WasSmall = isSmall();
 
   // Install the new array.  Clear all the buckets to empty.
-  const void **NewBuckets = (const void**) malloc(sizeof(void*) * NewSize);
-  if (NewBuckets == nullptr)
-    report_bad_alloc_error("Allocation of SmallPtrSet bucket array failed.");
+  const void **NewBuckets = (const void**) safe_malloc(sizeof(void*) * NewSize);
 
   // Reset member only if memory was allocated successfully
   CurArray = NewBuckets;
   CurArraySize = NewSize;
   memset(CurArray, -1, NewSize*sizeof(void*));
 
   // Copy over all valid entries.
   for (const void **BucketPtr = OldBuckets; BucketPtr != OldEnd; ++BucketPtr) {
SmallPtrSetImplBase::SmallPtrSetImplBase(const void **SmallStorage,
                                          const SmallPtrSetImplBase &that) {
   SmallArray = SmallStorage;
 
   // If we're becoming small, prepare to insert into our stack space
   if (that.isSmall()) {
     CurArray = SmallArray;
   // Otherwise, allocate new heap space (unless we were the same size)
   } else {
-    CurArray = (const void**)malloc(sizeof(void*) * that.CurArraySize);
-    if (CurArray == nullptr)
-      report_bad_alloc_error("Allocation of SmallPtrSet bucket array failed.");
+    CurArray = (const void**)safe_malloc(sizeof(void*) * that.CurArraySize);
   }
 
   // Copy over the that array.
   CopyHelper(that);
 }
 
 SmallPtrSetImplBase::SmallPtrSetImplBase(const void **SmallStorage,
                                          unsigned SmallSize,
void SmallPtrSetImplBase::CopyFrom(const SmallPtrSetImplBase &RHS) {
   // If we're becoming small, prepare to insert into our stack space
   if (RHS.isSmall()) {
     if (!isSmall())
       free(CurArray);
     CurArray = SmallArray;
   // Otherwise, allocate new heap space (unless we were the same size)
   } else if (CurArraySize != RHS.CurArraySize) {
     if (isSmall())
-      CurArray = (const void**)malloc(sizeof(void*) * RHS.CurArraySize);
+      CurArray = (const void**)safe_malloc(sizeof(void*) * RHS.CurArraySize);
     else {
-      const void **T = (const void**)realloc(CurArray,
+      const void **T = (const void**)safe_realloc(CurArray,
                                              sizeof(void*) * RHS.CurArraySize);
-      if (!T)
-        free(CurArray);
       CurArray = T;
     }
-    if (CurArray == nullptr)
-      report_bad_alloc_error("Allocation of SmallPtrSet bucket array failed.");
   }
 
   CopyHelper(RHS);
 }
 
 void SmallPtrSetImplBase::CopyHelper(const SmallPtrSetImplBase &RHS) {
   // Copy over the new array size
   CurArraySize = RHS.CurArraySize;

llvm/trunk/lib/Support/SmallVector.cpp

void SmallVectorBase::grow_pod(void *FirstEl, size_t MinSizeInBytes,
                                size_t TSize) {
   size_t CurSizeBytes = size_in_bytes();
   size_t NewCapacityInBytes = 2 * capacity_in_bytes() + TSize; // Always grow.
   if (NewCapacityInBytes < MinSizeInBytes)
     NewCapacityInBytes = MinSizeInBytes;
 
   void *NewElts;
   if (BeginX == FirstEl) {
-    NewElts = malloc(NewCapacityInBytes);
-    if (NewElts == nullptr)
-      report_bad_alloc_error("Allocation of SmallVector element failed.");
+    NewElts = safe_malloc(NewCapacityInBytes);
 
     // Copy the elements over.  No need to run dtors on PODs.
     memcpy(NewElts, this->BeginX, CurSizeBytes);
   } else {
     // If this wasn't grown from the inline copy, grow the allocated space.
-    NewElts = realloc(this->BeginX, NewCapacityInBytes);
-    if (NewElts == nullptr)
-      report_bad_alloc_error("Reallocation of SmallVector element failed.");
+    NewElts = safe_realloc(this->BeginX, NewCapacityInBytes);
   }
 
   this->EndX = (char*)NewElts+CurSizeBytes;
   this->BeginX = NewElts;
   this->CapacityX = (char*)this->BeginX + NewCapacityInBytes;
 }

llvm/trunk/lib/Support/StringMap.cpp

void StringMapImpl::init(unsigned InitSize) {
   assert((InitSize & (InitSize-1)) == 0 &&
          "Init Size must be a power of 2 or zero!");
 
   unsigned NewNumBuckets = InitSize ? InitSize : 16;
   NumItems = 0;
   NumTombstones = 0;
 
   TheTable = static_cast<StringMapEntryBase **>(
-      std::calloc(NewNumBuckets+1,
+      safe_calloc(NewNumBuckets+1,
                   sizeof(StringMapEntryBase **) + sizeof(unsigned)));
-  if (TheTable == nullptr)
-    report_bad_alloc_error("Allocation of StringMap table failed.");
 
   // Set the member only if TheTable was successfully allocated
   NumBuckets = NewNumBuckets;
 
   // Allocate one extra bucket, set it to look filled so the iterators stop at
   // end.
   TheTable[NumBuckets] = (StringMapEntryBase*)2;
 }
unsigned StringMapImpl::RehashTable(unsigned BucketNo) {
   } else {
     return BucketNo;
   }
 
   unsigned NewBucketNo = BucketNo;
   // Allocate one extra bucket which will always be non-empty.  This allows the
   // iterators to stop at end.
   auto NewTableArray = static_cast<StringMapEntryBase **>(
-      std::calloc(NewSize+1, sizeof(StringMapEntryBase *) + sizeof(unsigned)));
-  if (NewTableArray == nullptr)
-    report_bad_alloc_error("Allocation of StringMap hash table failed.");
+      safe_calloc(NewSize+1, sizeof(StringMapEntryBase *) + sizeof(unsigned)));
 
   unsigned *NewHashArray = (unsigned *)(NewTableArray + NewSize + 1);
   NewTableArray[NewSize] = (StringMapEntryBase*)2;
 
   // Rehash all the items into their new buckets.  Luckily :) we already have
   // the hash values available, so we don't have to rehash any strings.
   for (unsigned I = 0, E = NumBuckets; I != E; ++I) {
     StringMapEntryBase *Bucket = TheTable[I];