diff options
21 files changed, 101 insertions, 30 deletions
diff --git a/llvm/include/llvm/ADT/BitVector.h b/llvm/include/llvm/ADT/BitVector.h index 99147fec4d4..600369c4ce2 100644 --- a/llvm/include/llvm/ADT/BitVector.h +++ b/llvm/include/llvm/ADT/BitVector.h @@ -828,7 +828,8 @@ private: } MutableArrayRef<BitWord> allocate(size_t NumWords) { - BitWord *RawBits = (BitWord *)std::malloc(NumWords * sizeof(BitWord)); + BitWord *RawBits = static_cast<BitWord *>( + llvm::malloc(NumWords * sizeof(BitWord))); return MutableArrayRef<BitWord>(RawBits, NumWords); } @@ -867,8 +868,8 @@ private: void grow(unsigned NewSize) { size_t NewCapacity = std::max<size_t>(NumBitWords(NewSize), Bits.size() * 2); assert(NewCapacity > 0 && "realloc-ing zero space"); - BitWord *NewBits = - (BitWord *)std::realloc(Bits.data(), NewCapacity * sizeof(BitWord)); + BitWord *NewBits = static_cast<BitWord *>( + llvm::realloc(Bits.data(), NewCapacity * sizeof(BitWord))); Bits = MutableArrayRef<BitWord>(NewBits, NewCapacity); clear_unused_bits(); } diff --git a/llvm/include/llvm/ADT/SparseMultiSet.h b/llvm/include/llvm/ADT/SparseMultiSet.h index c91e0d70f65..6ba2623ce5f 100644 --- a/llvm/include/llvm/ADT/SparseMultiSet.h +++ b/llvm/include/llvm/ADT/SparseMultiSet.h @@ -211,7 +211,7 @@ public: // The Sparse array doesn't actually need to be initialized, so malloc // would be enough here, but that will cause tools like valgrind to // complain about branching on uninitialized data. - Sparse = reinterpret_cast<SparseT*>(calloc(U, sizeof(SparseT))); + Sparse = static_cast<SparseT*>(llvm::calloc(U, sizeof(SparseT))); Universe = U; } diff --git a/llvm/include/llvm/ADT/SparseSet.h b/llvm/include/llvm/ADT/SparseSet.h index 25ade883192..3e3a1133ef3 100644 --- a/llvm/include/llvm/ADT/SparseSet.h +++ b/llvm/include/llvm/ADT/SparseSet.h @@ -22,6 +22,7 @@ #include "llvm/ADT/STLExtras.h" #include "llvm/ADT/SmallVector.h" +#include "llvm/Support/Allocator.h" #include <cassert> #include <cstdint> #include <cstdlib> @@ -163,7 +164,7 @@ public: // The Sparse array doesn't actually need to be initialized, so malloc // would be enough here, but that will cause tools like valgrind to // complain about branching on uninitialized data. - Sparse = reinterpret_cast<SparseT*>(calloc(U, sizeof(SparseT))); + Sparse = static_cast<SparseT*>(llvm::calloc(U, sizeof(SparseT))); Universe = U; } diff --git a/llvm/include/llvm/Support/Allocator.h b/llvm/include/llvm/Support/Allocator.h index 7f9c39345b4..399f34f1bd7 100644 --- a/llvm/include/llvm/Support/Allocator.h +++ b/llvm/include/llvm/Support/Allocator.h @@ -439,6 +439,33 @@ public: 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 *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 *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 *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> diff --git a/llvm/include/llvm/Support/ErrorHandling.h b/llvm/include/llvm/Support/ErrorHandling.h index acd89873328..39cbfed2436 100644 --- a/llvm/include/llvm/Support/ErrorHandling.h +++ b/llvm/include/llvm/Support/ErrorHandling.h @@ -100,6 +100,8 @@ void install_bad_alloc_error_handler(fatal_error_handler_t handler, /// Restores default bad alloc error handling behavior. void remove_bad_alloc_error_handler(); +void install_out_of_memory_new_handler(); + /// Reports a bad alloc error, calling any user defined bad alloc /// error handler. In contrast to the generic 'report_fatal_error' /// functions, this function is expected to return, e.g. the user diff --git a/llvm/include/llvm/Support/OnDiskHashTable.h b/llvm/include/llvm/Support/OnDiskHashTable.h index e9c28daf03b..65a8e9f0ad0 100644 --- a/llvm/include/llvm/Support/OnDiskHashTable.h +++ b/llvm/include/llvm/Support/OnDiskHashTable.h @@ -95,7 +95,8 @@ private: /// \brief Resize the hash table, moving the old entries into the new buckets. void resize(size_t NewSize) { - Bucket *NewBuckets = (Bucket *)std::calloc(NewSize, sizeof(Bucket)); + Bucket *NewBuckets = static_cast<Bucket *>( + llvm::calloc(NewSize, sizeof(Bucket))); // Populate NewBuckets with the old entries. for (size_t I = 0; I < NumBuckets; ++I) for (Item *E = Buckets[I].Head; E;) { @@ -226,7 +227,7 @@ public: NumBuckets = 64; // Note that we do not need to run the constructors of the individual // Bucket objects since 'calloc' returns bytes that are all 0. - Buckets = (Bucket *)std::calloc(NumBuckets, sizeof(Bucket)); + Buckets = static_cast<Bucket *>(llvm::calloc(NumBuckets, sizeof(Bucket))); } ~OnDiskChainedHashTableGenerator() { std::free(Buckets); } diff --git a/llvm/lib/CodeGen/InterferenceCache.cpp b/llvm/lib/CodeGen/InterferenceCache.cpp index 72227cc7bba..2bc56c509b9 100644 --- a/llvm/lib/CodeGen/InterferenceCache.cpp +++ b/llvm/lib/CodeGen/InterferenceCache.cpp @@ -48,8 +48,8 @@ void InterferenceCache::reinitPhysRegEntries() { if (PhysRegEntriesCount == TRI->getNumRegs()) return; free(PhysRegEntries); PhysRegEntriesCount = TRI->getNumRegs(); - PhysRegEntries = (unsigned char*) - calloc(PhysRegEntriesCount, sizeof(unsigned char)); + PhysRegEntries = static_cast<unsigned char*>( + llvm::calloc(PhysRegEntriesCount, sizeof(unsigned char))); } void InterferenceCache::init(MachineFunction *mf, diff --git a/llvm/lib/CodeGen/LiveIntervalUnion.cpp b/llvm/lib/CodeGen/LiveIntervalUnion.cpp index 3e742a6c2f2..84b3294fbb8 100644 --- a/llvm/lib/CodeGen/LiveIntervalUnion.cpp +++ b/llvm/lib/CodeGen/LiveIntervalUnion.cpp @@ -187,7 +187,7 @@ void LiveIntervalUnion::Array::init(LiveIntervalUnion::Allocator &Alloc, clear(); Size = NSize; LIUs = static_cast<LiveIntervalUnion*>( - malloc(sizeof(LiveIntervalUnion)*NSize)); + llvm::malloc(sizeof(LiveIntervalUnion)*NSize)); for (unsigned i = 0; i != Size; ++i) new(LIUs + i) LiveIntervalUnion(Alloc); } diff --git a/llvm/lib/CodeGen/RegisterPressure.cpp b/llvm/lib/CodeGen/RegisterPressure.cpp index bc1af1594c2..9f8c7288e25 100644 --- a/llvm/lib/CodeGen/RegisterPressure.cpp +++ b/llvm/lib/CodeGen/RegisterPressure.cpp @@ -635,7 +635,8 @@ void PressureDiffs::init(unsigned N) { } Max = Size; free(PDiffArray); - PDiffArray = reinterpret_cast<PressureDiff*>(calloc(N, sizeof(PressureDiff))); + PDiffArray = static_cast<PressureDiff*>( + llvm::calloc(N, sizeof(PressureDiff))); } void PressureDiffs::addInstruction(unsigned Idx, diff --git a/llvm/lib/ExecutionEngine/Interpreter/Execution.cpp b/llvm/lib/ExecutionEngine/Interpreter/Execution.cpp index 96844439e72..f641f5023bc 100644 --- a/llvm/lib/ExecutionEngine/Interpreter/Execution.cpp +++ b/llvm/lib/ExecutionEngine/Interpreter/Execution.cpp @@ -974,7 +974,7 @@ void Interpreter::visitAllocaInst(AllocaInst &I) { unsigned MemToAlloc = std::max(1U, NumElements * TypeSize); // Allocate enough memory to hold the type... - void *Memory = malloc(MemToAlloc); + void *Memory = llvm::malloc(MemToAlloc); DEBUG(dbgs() << "Allocated Type: " << *Ty << " (" << TypeSize << " bytes) x " << NumElements << " (Total: " << MemToAlloc << ") at " diff --git a/llvm/lib/Object/Object.cpp b/llvm/lib/Object/Object.cpp index 1d2859cfbe9..8ba093bf224 100644 --- a/llvm/lib/Object/Object.cpp +++ b/llvm/lib/Object/Object.cpp @@ -228,7 +228,7 @@ uint64_t LLVMGetRelocationType(LLVMRelocationIteratorRef RI) { const char *LLVMGetRelocationTypeName(LLVMRelocationIteratorRef RI) { SmallVector<char, 0> ret; (*unwrap(RI))->getTypeName(ret); - char *str = static_cast<char*>(malloc(ret.size())); + char *str = static_cast<char*>(llvm::malloc(ret.size())); std::copy(ret.begin(), ret.end(), str); return str; } diff --git a/llvm/lib/Support/ErrorHandling.cpp b/llvm/lib/Support/ErrorHandling.cpp index fb8ae4c1cd5..cb14749cc42 100644 --- a/llvm/lib/Support/ErrorHandling.cpp +++ b/llvm/lib/Support/ErrorHandling.cpp @@ -175,6 +175,39 @@ void llvm::report_bad_alloc_error(const char *Reason, bool GenCrashDiag) { #endif } +#ifdef LLVM_ENABLE_EXCEPTIONS +// Do not set custom new handler if exceptions are enabled. In this case OOM +// errors are handled by throwing 'std::bad_alloc'. +void llvm::install_out_of_memory_new_handler() { +} +#else +// Causes crash on allocation failure. It is called prior to the handler set by +// 'install_bad_alloc_error_handler'. +static void out_of_memory_new_handler() { + llvm::report_bad_alloc_error("Allocation failed"); +} + +// Installs new handler that causes crash on allocation failure. It does not +// need to be called explicitly, if this file is linked to application, because +// in this case it is called during construction of 'new_handler_installer'. +void llvm::install_out_of_memory_new_handler() { + static bool out_of_memory_new_handler_installed = false; + if (!out_of_memory_new_handler_installed) { + std::set_new_handler(out_of_memory_new_handler); + out_of_memory_new_handler_installed = true; + } +} + +// Static object that causes installation of 'out_of_memory_new_handler' before +// execution of 'main'. +static class NewHandlerInstaller { +public: + NewHandlerInstaller() { + install_out_of_memory_new_handler(); + } +} new_handler_installer; +#endif + void llvm::llvm_unreachable_internal(const char *msg, const char *file, unsigned line) { // This code intentionally doesn't call the ErrorHandler callback, because diff --git a/llvm/lib/Support/FoldingSet.cpp b/llvm/lib/Support/FoldingSet.cpp index 94237954903..7b1da136b9b 100644 --- a/llvm/lib/Support/FoldingSet.cpp +++ b/llvm/lib/Support/FoldingSet.cpp @@ -214,7 +214,8 @@ static void **GetBucketFor(unsigned Hash, void **Buckets, unsigned NumBuckets) { /// AllocateBuckets - Allocated initialized bucket memory. static void **AllocateBuckets(unsigned NumBuckets) { - void **Buckets = static_cast<void**>(calloc(NumBuckets+1, sizeof(void*))); + void **Buckets = static_cast<void**>( + llvm::calloc(NumBuckets+1, sizeof(void*))); if (Buckets == nullptr) report_bad_alloc_error("Allocation of Buckets failed."); diff --git a/llvm/lib/Support/RWMutex.cpp b/llvm/lib/Support/RWMutex.cpp index 83c6d1d52b4..48866e336b5 100644 --- a/llvm/lib/Support/RWMutex.cpp +++ b/llvm/lib/Support/RWMutex.cpp @@ -11,6 +11,7 @@ // //===----------------------------------------------------------------------===// +#include "llvm/Support/Allocator.h" #include "llvm/Support/RWMutex.h" #include "llvm/Config/config.h" @@ -49,7 +50,7 @@ RWMutexImpl::RWMutexImpl() { // Declare the pthread_rwlock data structures pthread_rwlock_t* rwlock = - static_cast<pthread_rwlock_t*>(malloc(sizeof(pthread_rwlock_t))); + static_cast<pthread_rwlock_t*>(llvm::malloc(sizeof(pthread_rwlock_t))); #ifdef __APPLE__ // Workaround a bug/mis-feature in Darwin's pthread_rwlock_init. diff --git a/llvm/lib/Support/StringMap.cpp b/llvm/lib/Support/StringMap.cpp index 4341da2d97b..4a985b06838 100644 --- a/llvm/lib/Support/StringMap.cpp +++ b/llvm/lib/Support/StringMap.cpp @@ -57,10 +57,9 @@ void StringMapImpl::init(unsigned InitSize) { NumItems = 0; NumTombstones = 0; - TheTable = (StringMapEntryBase **)calloc(NewNumBuckets+1, - sizeof(StringMapEntryBase **) + - sizeof(unsigned)); - + TheTable = static_cast<StringMapEntryBase **>( + std::calloc(NewNumBuckets+1, + sizeof(StringMapEntryBase **) + sizeof(unsigned))); if (TheTable == nullptr) report_bad_alloc_error("Allocation of StringMap table failed."); @@ -219,10 +218,8 @@ unsigned StringMapImpl::RehashTable(unsigned BucketNo) { unsigned NewBucketNo = BucketNo; // Allocate one extra bucket which will always be non-empty. This allows the // iterators to stop at end. - StringMapEntryBase **NewTableArray = - (StringMapEntryBase **)calloc(NewSize+1, sizeof(StringMapEntryBase *) + - sizeof(unsigned)); - + StringMapEntryBase **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."); diff --git a/llvm/lib/Support/Unix/Signals.inc b/llvm/lib/Support/Unix/Signals.inc index aaf760c5b61..12b84fa4861 100644 --- a/llvm/lib/Support/Unix/Signals.inc +++ b/llvm/lib/Support/Unix/Signals.inc @@ -138,7 +138,7 @@ static void CreateSigAltStack() { return; stack_t AltStack = {}; - AltStack.ss_sp = reinterpret_cast<char *>(malloc(AltStackSize)); + AltStack.ss_sp = static_cast<char *>(llvm::malloc(AltStackSize)); NewAltStackPointer = AltStack.ss_sp; // Save to avoid reporting a leak. AltStack.ss_size = AltStackSize; if (sigaltstack(&AltStack, &OldAltStack) != 0) diff --git a/llvm/lib/Support/Windows/RWMutex.inc b/llvm/lib/Support/Windows/RWMutex.inc index ac60c2fc05b..6f99f591322 100644 --- a/llvm/lib/Support/Windows/RWMutex.inc +++ b/llvm/lib/Support/Windows/RWMutex.inc @@ -74,10 +74,10 @@ static bool loadSRW() { sys::RWMutexImpl::RWMutexImpl() { if (loadSRW()) { - data_ = calloc(1, sizeof(SRWLOCK)); + data_ = llvm::calloc(1, sizeof(SRWLOCK)); fpInitializeSRWLock(static_cast<PSRWLOCK>(data_)); } else { - data_ = calloc(1, sizeof(CRITICAL_SECTION)); + data_ = llvm::calloc(1, sizeof(CRITICAL_SECTION)); InitializeCriticalSection(static_cast<LPCRITICAL_SECTION>(data_)); } } diff --git a/llvm/tools/llvm-c-test/attributes.c b/llvm/tools/llvm-c-test/attributes.c index c6beab1d31b..c7bc0d3c87b 100644 --- a/llvm/tools/llvm-c-test/attributes.c +++ b/llvm/tools/llvm-c-test/attributes.c @@ -14,6 +14,7 @@ #include "llvm-c-test.h" +#include <assert.h> #include <stdlib.h> int llvm_test_function_attributes(void) { @@ -30,6 +31,7 @@ int llvm_test_function_attributes(void) { int AttrCount = LLVMGetAttributeCountAtIndex(F, Idx); LLVMAttributeRef *Attrs = (LLVMAttributeRef *)malloc(AttrCount * sizeof(LLVMAttributeRef)); + assert(Attrs); LLVMGetAttributesAtIndex(F, Idx, Attrs); free(Attrs); } @@ -61,6 +63,7 @@ int llvm_test_callsite_attributes(void) { int AttrCount = LLVMGetCallSiteAttributeCount(I, Idx); LLVMAttributeRef *Attrs = (LLVMAttributeRef *)malloc( AttrCount * sizeof(LLVMAttributeRef)); + assert(Attrs); LLVMGetCallSiteAttributes(I, Idx, Attrs); free(Attrs); } diff --git a/llvm/tools/llvm-c-test/echo.cpp b/llvm/tools/llvm-c-test/echo.cpp index 05d80363162..b09a391499d 100644 --- a/llvm/tools/llvm-c-test/echo.cpp +++ b/llvm/tools/llvm-c-test/echo.cpp @@ -90,7 +90,8 @@ struct TypeCloner { unsigned ParamCount = LLVMCountParamTypes(Src); LLVMTypeRef* Params = nullptr; if (ParamCount > 0) { - Params = (LLVMTypeRef*) malloc(ParamCount * sizeof(LLVMTypeRef)); + Params = static_cast<LLVMTypeRef*>( + llvm::malloc(ParamCount * sizeof(LLVMTypeRef))); LLVMGetParamTypes(Src, Params); for (unsigned i = 0; i < ParamCount; i++) Params[i] = Clone(Params[i]); diff --git a/llvm/unittests/Support/AllocatorTest.cpp b/llvm/unittests/Support/AllocatorTest.cpp index 4897c47eb28..b26c8a6ec3e 100644 --- a/llvm/unittests/Support/AllocatorTest.cpp +++ b/llvm/unittests/Support/AllocatorTest.cpp @@ -147,7 +147,7 @@ public: // Allocate space for the alignment, the slab, and a void* that goes right // before the slab. size_t Alignment = 4096; - void *MemBase = malloc(Size + Alignment - 1 + sizeof(void*)); + void *MemBase = llvm::malloc(Size + Alignment - 1 + sizeof(void*)); // Find the slab start. void *Slab = (void *)alignAddr((char*)MemBase + sizeof(void *), Alignment); diff --git a/llvm/unittests/Support/ManagedStatic.cpp b/llvm/unittests/Support/ManagedStatic.cpp index 07e324cdfb6..700b765f367 100644 --- a/llvm/unittests/Support/ManagedStatic.cpp +++ b/llvm/unittests/Support/ManagedStatic.cpp @@ -6,6 +6,8 @@ // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// + +#include "llvm/Support/Allocator.h" #include "llvm/Support/ManagedStatic.h" #include "llvm/Config/config.h" #ifdef HAVE_PTHREAD_H @@ -30,7 +32,7 @@ namespace test1 { // Valgrind's leak checker complains glibc's stack allocation. // To appease valgrind, we provide our own stack for each thread. void *allocate_stack(pthread_attr_t &a, size_t n = 65536) { - void *stack = malloc(n); + void *stack = llvm::malloc(n); pthread_attr_init(&a); #if defined(__linux__) pthread_attr_setstack(&a, stack, n); @@ -83,7 +85,7 @@ TEST(ManagedStaticTest, NestedStatics) { namespace CustomCreatorDeletor { struct CustomCreate { static void *call() { - void *Mem = std::malloc(sizeof(int)); + void *Mem = llvm::malloc(sizeof(int)); *((int *)Mem) = 42; return Mem; } |
