Home | History | Annotate | Line # | Download | only in Support 
      1 //===- MemAlloc.h - Memory allocation functions -----------------*- C++ -*-===//
      2 //
      3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
      4 // See https://llvm.org/LICENSE.txt for license information.
      5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
      6 //
      7 //===----------------------------------------------------------------------===//
      8 /// \file
      9 ///
     10 /// This file defines counterparts of C library allocation functions defined in
     11 /// the namespace 'std'. The new allocation functions crash on allocation
     12 /// failure instead of returning null pointer.
     13 ///
     14 //===----------------------------------------------------------------------===//
     15 
     16 #ifndef LLVM_SUPPORT_MEMALLOC_H
     17 #define LLVM_SUPPORT_MEMALLOC_H
     18 
     19 #include "llvm/Support/Compiler.h"
     20 #include "llvm/Support/ErrorHandling.h"
     21 #include <cstdlib>
     22 
     23 namespace llvm {
     24 
     25 LLVM_ATTRIBUTE_RETURNS_NONNULL inline void *safe_malloc(size_t Sz) {
     26   void *Result = std::malloc(Sz);
     27   if (Result == nullptr) {
     28     // It is implementation-defined whether allocation occurs if the space
     29     // requested is zero (ISO/IEC 9899:2018 7.22.3). Retry, requesting
     30     // non-zero, if the space requested was zero.
     31     if (Sz == 0)
     32       return safe_malloc(1);
     33     report_bad_alloc_error("Allocation failed");
     34   }
     35   return Result;
     36 }
     37 
     38 LLVM_ATTRIBUTE_RETURNS_NONNULL inline void *safe_calloc(size_t Count,
     39                                                         size_t Sz) {
     40   void *Result = std::calloc(Count, Sz);
     41   if (Result == nullptr) {
     42     // It is implementation-defined whether allocation occurs if the space
     43     // requested is zero (ISO/IEC 9899:2018 7.22.3). Retry, requesting
     44     // non-zero, if the space requested was zero.
     45     if (Count == 0 || Sz == 0)
     46       return safe_malloc(1);
     47     report_bad_alloc_error("Allocation failed");
     48   }
     49   return Result;
     50 }
     51 
     52 LLVM_ATTRIBUTE_RETURNS_NONNULL inline void *safe_realloc(void *Ptr, size_t Sz) {
     53   void *Result = std::realloc(Ptr, Sz);
     54   if (Result == nullptr) {
     55     // It is implementation-defined whether allocation occurs if the space
     56     // requested is zero (ISO/IEC 9899:2018 7.22.3). Retry, requesting
     57     // non-zero, if the space requested was zero.
     58     if (Sz == 0)
     59       return safe_malloc(1);
     60     report_bad_alloc_error("Allocation failed");
     61   }
     62   return Result;
     63 }
     64 
     65 /// Allocate a buffer of memory with the given size and alignment.
     66 ///
     67 /// When the compiler supports aligned operator new, this will use it to to
     68 /// handle even over-aligned allocations.
     69 ///
     70 /// However, this doesn't make any attempt to leverage the fancier techniques
     71 /// like posix_memalign due to portability. It is mostly intended to allow
     72 /// compatibility with platforms that, after aligned allocation was added, use
     73 /// reduced default alignment.
     74 LLVM_ATTRIBUTE_RETURNS_NONNULL LLVM_ATTRIBUTE_RETURNS_NOALIAS void *
     75 allocate_buffer(size_t Size, size_t Alignment);
     76 
     77 /// Deallocate a buffer of memory with the given size and alignment.
     78 ///
     79 /// If supported, this will used the sized delete operator. Also if supported,
     80 /// this will pass the alignment to the delete operator.
     81 ///
     82 /// The pointer must have been allocated with the corresponding new operator,
     83 /// most likely using the above helper.
     84 void deallocate_buffer(void *Ptr, size_t Size, size_t Alignment);
     85 
     86 } // namespace llvm
     87 #endif
     88