Index: llvm/trunk/include/llvm/ADT/SmallVector.h =================================================================== --- llvm/trunk/include/llvm/ADT/SmallVector.h +++ llvm/trunk/include/llvm/ADT/SmallVector.h @@ -18,6 +18,7 @@ #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 @@ -238,9 +239,7 @@ size_t NewCapacity = size_t(NextPowerOf2(CurCapacity+2)); if (NewCapacity < MinSize) NewCapacity = MinSize; - T *NewElts = static_cast(malloc(NewCapacity*sizeof(T))); - if (NewElts == nullptr) - report_bad_alloc_error("Allocation of SmallVector element failed."); + T *NewElts = static_cast(llvm::safe_malloc(NewCapacity*sizeof(T))); // Move the elements over. this->uninitialized_move(this->begin(), this->end(), NewElts); Index: llvm/trunk/include/llvm/ADT/StringMap.h =================================================================== --- llvm/trunk/include/llvm/ADT/StringMap.h +++ llvm/trunk/include/llvm/ADT/StringMap.h @@ -164,9 +164,7 @@ StringMapEntry *NewItem = static_cast(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(InitVals)...); Index: llvm/trunk/include/llvm/Support/Allocator.h =================================================================== --- llvm/trunk/include/llvm/Support/Allocator.h +++ llvm/trunk/include/llvm/Support/Allocator.h @@ -23,8 +23,9 @@ #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 #include #include @@ -95,11 +96,7 @@ 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. @@ -439,34 +436,6 @@ T *Allocate(size_t num = 1) { return Allocator.Allocate(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 Index: llvm/trunk/include/llvm/Support/MemAlloc.h =================================================================== --- llvm/trunk/include/llvm/Support/MemAlloc.h +++ llvm/trunk/include/llvm/Support/MemAlloc.h @@ -0,0 +1,48 @@ +//===- 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 Index: llvm/trunk/lib/Demangle/ItaniumDemangle.cpp =================================================================== --- llvm/trunk/lib/Demangle/ItaniumDemangle.cpp +++ llvm/trunk/lib/Demangle/ItaniumDemangle.cpp @@ -12,8 +12,8 @@ // - C++ modules TS #include "llvm/Demangle/Demangle.h" - #include "llvm/Demangle/Compiler.h" +#include "llvm/Support/MemAlloc.h" #include #include @@ -89,7 +89,7 @@ BufferCapacity *= 2; if (BufferCapacity < N + CurrentPosition) BufferCapacity = N + CurrentPosition; - Buffer = static_cast(std::realloc(Buffer, BufferCapacity)); + Buffer = static_cast(llvm::safe_realloc(Buffer, BufferCapacity)); } } @@ -274,7 +274,7 @@ #ifndef NDEBUG LLVM_DUMP_METHOD void dump() const { - char *Buffer = static_cast(std::malloc(1024)); + char *Buffer = static_cast(llvm::safe_malloc(1024)); OutputStream S(Buffer, 1024); print(S); S += '\0'; @@ -1947,11 +1947,11 @@ void reserve(size_t NewCap) { size_t S = size(); if (isInline()) { - auto* Tmp = static_cast(std::malloc(NewCap * sizeof(T))); + auto* Tmp = static_cast(llvm::safe_malloc(NewCap * sizeof(T))); std::copy(First, Last, Tmp); First = Tmp; } else - First = static_cast(std::realloc(First, NewCap * sizeof(T))); + First = static_cast(llvm::safe_realloc(First, NewCap * sizeof(T))); Last = First + S; Cap = First + NewCap; } Index: llvm/trunk/lib/IR/DataLayout.cpp =================================================================== --- llvm/trunk/lib/IR/DataLayout.cpp +++ llvm/trunk/lib/IR/DataLayout.cpp @@ -596,10 +596,8 @@ // 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. Index: llvm/trunk/lib/Support/FoldingSet.cpp =================================================================== --- llvm/trunk/lib/Support/FoldingSet.cpp +++ llvm/trunk/lib/Support/FoldingSet.cpp @@ -214,11 +214,8 @@ /// AllocateBuckets - Allocated initialized bucket memory. static void **AllocateBuckets(unsigned NumBuckets) { - void **Buckets = static_cast(calloc(NumBuckets+1, sizeof(void*))); - - if (Buckets == nullptr) - report_bad_alloc_error("Allocation of Buckets failed."); - + void **Buckets = static_cast(safe_calloc(NumBuckets + 1, + sizeof(void*))); // Set the very last bucket to be a non-null "pointer". Buckets[NumBuckets] = reinterpret_cast(-1); return Buckets; Index: llvm/trunk/lib/Support/Mutex.cpp =================================================================== --- llvm/trunk/lib/Support/Mutex.cpp +++ llvm/trunk/lib/Support/Mutex.cpp @@ -47,10 +47,7 @@ { // Declare the pthread_mutex data structures pthread_mutex_t* mutex = - static_cast(malloc(sizeof(pthread_mutex_t))); - - if (mutex == nullptr) - report_bad_alloc_error("Mutex allocation failed"); + static_cast(safe_malloc(sizeof(pthread_mutex_t))); pthread_mutexattr_t attr; Index: llvm/trunk/lib/Support/SmallPtrSet.cpp =================================================================== --- llvm/trunk/lib/Support/SmallPtrSet.cpp +++ llvm/trunk/lib/Support/SmallPtrSet.cpp @@ -32,9 +32,7 @@ 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*)); } @@ -100,9 +98,7 @@ 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; @@ -132,9 +128,7 @@ 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. @@ -163,16 +157,12 @@ // 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); Index: llvm/trunk/lib/Support/SmallVector.cpp =================================================================== --- llvm/trunk/lib/Support/SmallVector.cpp +++ llvm/trunk/lib/Support/SmallVector.cpp @@ -25,17 +25,13 @@ 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; Index: llvm/trunk/lib/Support/StringMap.cpp =================================================================== --- llvm/trunk/lib/Support/StringMap.cpp +++ llvm/trunk/lib/Support/StringMap.cpp @@ -59,10 +59,8 @@ NumTombstones = 0; TheTable = static_cast( - 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; @@ -220,9 +218,7 @@ // Allocate one extra bucket which will always be non-empty. This allows the // iterators to stop at end. auto NewTableArray = static_cast( - 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;