// © 2016 and later: Unicode, Inc. and others. // License & terms of use: http://www.unicode.org/copyright.html /* ****************************************************************************** * * Copyright (C) 1997-2016, International Business Machines * Corporation and others. All Rights Reserved. * ****************************************************************************** * * File CMEMORY.H * * Contains stdlib.h/string.h memory functions * * @author Bertrand A. Damiba * * Modification History: * * Date Name Description * 6/20/98 Bertrand Created. * 05/03/99 stephen Changed from functions to macros. * ****************************************************************************** */ #ifndef CMEMORY_H #define CMEMORY_H #include "unicode/utypes.h" #include #include #include "unicode/localpointer.h" #if U_DEBUG && defined(UPRV_MALLOC_COUNT) #include #endif #define uprv_memcpy(dst, src, size) U_STANDARD_CPP_NAMESPACE memcpy(dst, src, size) #define uprv_memmove(dst, src, size) U_STANDARD_CPP_NAMESPACE memmove(dst, src, size) /** * \def UPRV_LENGTHOF * Convenience macro to determine the length of a fixed array at compile-time. * @param array A fixed length array * @return The length of the array, in elements * @internal */ #define UPRV_LENGTHOF(array) (int32_t)(sizeof(array)/sizeof((array)[0])) #define uprv_memset(buffer, mark, size) U_STANDARD_CPP_NAMESPACE memset(buffer, mark, size) #define uprv_memcmp(buffer1, buffer2, size) U_STANDARD_CPP_NAMESPACE memcmp(buffer1, buffer2,size) #define uprv_memchr(ptr, value, num) U_STANDARD_CPP_NAMESPACE memchr(ptr, value, num) U_CAPI void * U_EXPORT2 uprv_malloc(size_t s) U_MALLOC_ATTR U_ALLOC_SIZE_ATTR(1); U_CAPI void * U_EXPORT2 uprv_realloc(void *mem, size_t size) U_ALLOC_SIZE_ATTR(2); U_CAPI void U_EXPORT2 uprv_free(void *mem); U_CAPI void * U_EXPORT2 uprv_calloc(size_t num, size_t size) U_MALLOC_ATTR U_ALLOC_SIZE_ATTR2(1,2); /** * Get the least significant bits of a pointer (a memory address). * For example, with a mask of 3, the macro gets the 2 least significant bits, * which will be 0 if the pointer is 32-bit (4-byte) aligned. * * uintptr_t is the most appropriate integer type to cast to. */ #define U_POINTER_MASK_LSB(ptr, mask) ((uintptr_t)(ptr) & (mask)) /** * Create & return an instance of "type" in statically allocated storage. * e.g. * static std::mutex *myMutex = STATIC_NEW(std::mutex); * To destroy an object created in this way, invoke the destructor explicitly, e.g. * myMutex->~mutex(); * DO NOT use delete. * DO NOT use with class UMutex, which has specific support for static instances. * * STATIC_NEW is intended for use when * - We want a static (or global) object. * - We don't want it to ever be destructed, or to explicitly control destruction, * to avoid use-after-destruction problems. * - We want to avoid an ordinary heap allocated object, * to avoid the possibility of memory allocation failures, and * to avoid memory leak reports, from valgrind, for example. * This is defined as a macro rather than a template function because each invocation * must define distinct static storage for the object being returned. */ #define STATIC_NEW(type) [] () { \ alignas(type) static char storage[sizeof(type)]; \ return new(storage) type();} () /** * Heap clean up function, called from u_cleanup() * Clears any user heap functions from u_setMemoryFunctions() * Does NOT deallocate any remaining allocated memory. */ U_CFUNC UBool cmemory_cleanup(void); /** * A function called by uhash_remove, * uhash_close, or uhash_put to delete * an existing key or value. * @param obj A key or value stored in a hashtable * @see uprv_deleteUObject */ typedef void U_CALLCONV UObjectDeleter(void* obj); /** * Deleter for UObject instances. * Works for all subclasses of UObject because it has a virtual destructor. */ U_CAPI void U_EXPORT2 uprv_deleteUObject(void *obj); #ifdef __cplusplus #include #include "unicode/uobject.h" U_NAMESPACE_BEGIN /** * "Smart pointer" class, deletes memory via uprv_free(). * For most methods see the LocalPointerBase base class. * Adds operator[] for array item access. * * @see LocalPointerBase */ template class LocalMemory : public LocalPointerBase { public: using LocalPointerBase::operator*; using LocalPointerBase::operator->; /** * Constructor takes ownership. * @param p simple pointer to an array of T items that is adopted */ explicit LocalMemory(T *p=NULL) : LocalPointerBase(p) {} /** * Move constructor, leaves src with isNull(). * @param src source smart pointer */ LocalMemory(LocalMemory &&src) U_NOEXCEPT : LocalPointerBase(src.ptr) { src.ptr=NULL; } /** * Destructor deletes the memory it owns. */ ~LocalMemory() { uprv_free(LocalPointerBase::ptr); } /** * Move assignment operator, leaves src with isNull(). * The behavior is undefined if *this and src are the same object. * @param src source smart pointer * @return *this */ LocalMemory &operator=(LocalMemory &&src) U_NOEXCEPT { uprv_free(LocalPointerBase::ptr); LocalPointerBase::ptr=src.ptr; src.ptr=NULL; return *this; } /** * Swap pointers. * @param other other smart pointer */ void swap(LocalMemory &other) U_NOEXCEPT { T *temp=LocalPointerBase::ptr; LocalPointerBase::ptr=other.ptr; other.ptr=temp; } /** * Non-member LocalMemory swap function. * @param p1 will get p2's pointer * @param p2 will get p1's pointer */ friend inline void swap(LocalMemory &p1, LocalMemory &p2) U_NOEXCEPT { p1.swap(p2); } /** * Deletes the array it owns, * and adopts (takes ownership of) the one passed in. * @param p simple pointer to an array of T items that is adopted */ void adoptInstead(T *p) { uprv_free(LocalPointerBase::ptr); LocalPointerBase::ptr=p; } /** * Deletes the array it owns, allocates a new one and reset its bytes to 0. * Returns the new array pointer. * If the allocation fails, then the current array is unchanged and * this method returns NULL. * @param newCapacity must be >0 * @return the allocated array pointer, or NULL if the allocation failed */ inline T *allocateInsteadAndReset(int32_t newCapacity=1); /** * Deletes the array it owns and allocates a new one, copying length T items. * Returns the new array pointer. * If the allocation fails, then the current array is unchanged and * this method returns NULL. * @param newCapacity must be >0 * @param length number of T items to be copied from the old array to the new one; * must be no more than the capacity of the old array, * which the caller must track because the LocalMemory does not track it * @return the allocated array pointer, or NULL if the allocation failed */ inline T *allocateInsteadAndCopy(int32_t newCapacity=1, int32_t length=0); /** * Array item access (writable). * No index bounds check. * @param i array index * @return reference to the array item */ T &operator[](ptrdiff_t i) const { return LocalPointerBase::ptr[i]; } }; template inline T *LocalMemory::allocateInsteadAndReset(int32_t newCapacity) { if(newCapacity>0) { T *p=(T *)uprv_malloc(newCapacity*sizeof(T)); if(p!=NULL) { uprv_memset(p, 0, newCapacity*sizeof(T)); uprv_free(LocalPointerBase::ptr); LocalPointerBase::ptr=p; } return p; } else { return NULL; } } template inline T *LocalMemory::allocateInsteadAndCopy(int32_t newCapacity, int32_t length) { if(newCapacity>0) { T *p=(T *)uprv_malloc(newCapacity*sizeof(T)); if(p!=NULL) { if(length>0) { if(length>newCapacity) { length=newCapacity; } uprv_memcpy(p, LocalPointerBase::ptr, (size_t)length*sizeof(T)); } uprv_free(LocalPointerBase::ptr); LocalPointerBase::ptr=p; } return p; } else { return NULL; } } /** * Simple array/buffer management class using uprv_malloc() and uprv_free(). * Provides an internal array with fixed capacity. Can alias another array * or allocate one. * * The array address is properly aligned for type T. It might not be properly * aligned for types larger than T (or larger than the largest subtype of T). * * Unlike LocalMemory and LocalArray, this class never adopts * (takes ownership of) another array. * * WARNING: MaybeStackArray only works with primitive (plain-old data) types. * It does NOT know how to call a destructor! If you work with classes with * destructors, consider: * * - LocalArray in localpointer.h if you know the length ahead of time * - MaybeStackVector if you know the length at runtime */ template class MaybeStackArray { public: // No heap allocation. Use only on the stack. static void* U_EXPORT2 operator new(size_t) U_NOEXCEPT = delete; static void* U_EXPORT2 operator new[](size_t) U_NOEXCEPT = delete; #if U_HAVE_PLACEMENT_NEW static void* U_EXPORT2 operator new(size_t, void*) U_NOEXCEPT = delete; #endif /** * Default constructor initializes with internal T[stackCapacity] buffer. */ MaybeStackArray() : ptr(stackArray), capacity(stackCapacity), needToRelease(false) {} /** * Automatically allocates the heap array if the argument is larger than the stack capacity. * Intended for use when an approximate capacity is known at compile time but the true * capacity is not known until runtime. */ MaybeStackArray(int32_t newCapacity, UErrorCode status) : MaybeStackArray() { if (U_FAILURE(status)) { return; } if (capacity < newCapacity) { if (resize(newCapacity) == nullptr) { status = U_MEMORY_ALLOCATION_ERROR; } } } /** * Destructor deletes the array (if owned). */ ~MaybeStackArray() { releaseArray(); } /** * Move constructor: transfers ownership or copies the stack array. */ MaybeStackArray(MaybeStackArray &&src) U_NOEXCEPT; /** * Move assignment: transfers ownership or copies the stack array. */ MaybeStackArray &operator=(MaybeStackArray &&src) U_NOEXCEPT; /** * Returns the array capacity (number of T items). * @return array capacity */ int32_t getCapacity() const { return capacity; } /** * Access without ownership change. * @return the array pointer */ T *getAlias() const { return ptr; } /** * Returns the array limit. Simple convenience method. * @return getAlias()+getCapacity() */ T *getArrayLimit() const { return getAlias()+capacity; } // No "operator T *() const" because that can make // expressions like mbs[index] ambiguous for some compilers. /** * Array item access (const). * No index bounds check. * @param i array index * @return reference to the array item */ const T &operator[](ptrdiff_t i) const { return ptr[i]; } /** * Array item access (writable). * No index bounds check. * @param i array index * @return reference to the array item */ T &operator[](ptrdiff_t i) { return ptr[i]; } /** * Deletes the array (if owned) and aliases another one, no transfer of ownership. * If the arguments are illegal, then the current array is unchanged. * @param otherArray must not be NULL * @param otherCapacity must be >0 */ void aliasInstead(T *otherArray, int32_t otherCapacity) { if(otherArray!=NULL && otherCapacity>0) { releaseArray(); ptr=otherArray; capacity=otherCapacity; needToRelease=false; } } /** * Deletes the array (if owned) and allocates a new one, copying length T items. * Returns the new array pointer. * If the allocation fails, then the current array is unchanged and * this method returns NULL. * @param newCapacity can be less than or greater than the current capacity; * must be >0 * @param length number of T items to be copied from the old array to the new one * @return the allocated array pointer, or NULL if the allocation failed */ inline T *resize(int32_t newCapacity, int32_t length=0); /** * Gives up ownership of the array if owned, or else clones it, * copying length T items; resets itself to the internal stack array. * Returns NULL if the allocation failed. * @param length number of T items to copy when cloning, * and capacity of the clone when cloning * @param resultCapacity will be set to the returned array's capacity (output-only) * @return the array pointer; * caller becomes responsible for deleting the array */ inline T *orphanOrClone(int32_t length, int32_t &resultCapacity); protected: // Resizes the array to the size of src, then copies the contents of src. void copyFrom(const MaybeStackArray &src, UErrorCode &status) { if (U_FAILURE(status)) { return; } if (this->resize(src.capacity, 0) == NULL) { status = U_MEMORY_ALLOCATION_ERROR; return; } uprv_memcpy(this->ptr, src.ptr, (size_t)capacity * sizeof(T)); } private: T *ptr; int32_t capacity; UBool needToRelease; T stackArray[stackCapacity]; void releaseArray() { if(needToRelease) { uprv_free(ptr); } } void resetToStackArray() { ptr=stackArray; capacity=stackCapacity; needToRelease=false; } /* No comparison operators with other MaybeStackArray's. */ bool operator==(const MaybeStackArray & /*other*/) = delete; bool operator!=(const MaybeStackArray & /*other*/) = delete; /* No ownership transfer: No copy constructor, no assignment operator. */ MaybeStackArray(const MaybeStackArray & /*other*/) = delete; void operator=(const MaybeStackArray & /*other*/) = delete; }; template icu::MaybeStackArray::MaybeStackArray( MaybeStackArray && src) U_NOEXCEPT : ptr(src.ptr), capacity(src.capacity), needToRelease(src.needToRelease) { if (src.ptr == src.stackArray) { ptr = stackArray; uprv_memcpy(stackArray, src.stackArray, sizeof(T) * src.capacity); } else { src.resetToStackArray(); // take ownership away from src } } template inline MaybeStackArray & MaybeStackArray::operator=(MaybeStackArray && src) U_NOEXCEPT { releaseArray(); // in case this instance had its own memory allocated capacity = src.capacity; needToRelease = src.needToRelease; if (src.ptr == src.stackArray) { ptr = stackArray; uprv_memcpy(stackArray, src.stackArray, sizeof(T) * src.capacity); } else { ptr = src.ptr; src.resetToStackArray(); // take ownership away from src } return *this; } template inline T *MaybeStackArray::resize(int32_t newCapacity, int32_t length) { if(newCapacity>0) { #if U_DEBUG && defined(UPRV_MALLOC_COUNT) ::fprintf(::stderr, "MaybeStackArray (resize) alloc %d * %lu\n", newCapacity, sizeof(T)); #endif T *p=(T *)uprv_malloc(newCapacity*sizeof(T)); if(p!=NULL) { if(length>0) { if(length>capacity) { length=capacity; } if(length>newCapacity) { length=newCapacity; } uprv_memcpy(p, ptr, (size_t)length*sizeof(T)); } releaseArray(); ptr=p; capacity=newCapacity; needToRelease=true; } return p; } else { return NULL; } } template inline T *MaybeStackArray::orphanOrClone(int32_t length, int32_t &resultCapacity) { T *p; if(needToRelease) { p=ptr; } else if(length<=0) { return NULL; } else { if(length>capacity) { length=capacity; } p=(T *)uprv_malloc(length*sizeof(T)); #if U_DEBUG && defined(UPRV_MALLOC_COUNT) ::fprintf(::stderr,"MaybeStacArray (orphan) alloc %d * %lu\n", length,sizeof(T)); #endif if(p==NULL) { return NULL; } uprv_memcpy(p, ptr, (size_t)length*sizeof(T)); } resultCapacity=length; resetToStackArray(); return p; } /** * Variant of MaybeStackArray that allocates a header struct and an array * in one contiguous memory block, using uprv_malloc() and uprv_free(). * Provides internal memory with fixed array capacity. Can alias another memory * block or allocate one. * The stackCapacity is the number of T items in the internal memory, * not counting the H header. * Unlike LocalMemory and LocalArray, this class never adopts * (takes ownership of) another memory block. */ template class MaybeStackHeaderAndArray { public: // No heap allocation. Use only on the stack. static void* U_EXPORT2 operator new(size_t) U_NOEXCEPT = delete; static void* U_EXPORT2 operator new[](size_t) U_NOEXCEPT = delete; #if U_HAVE_PLACEMENT_NEW static void* U_EXPORT2 operator new(size_t, void*) U_NOEXCEPT = delete; #endif /** * Default constructor initializes with internal H+T[stackCapacity] buffer. */ MaybeStackHeaderAndArray() : ptr(&stackHeader), capacity(stackCapacity), needToRelease(false) {} /** * Destructor deletes the memory (if owned). */ ~MaybeStackHeaderAndArray() { releaseMemory(); } /** * Returns the array capacity (number of T items). * @return array capacity */ int32_t getCapacity() const { return capacity; } /** * Access without ownership change. * @return the header pointer */ H *getAlias() const { return ptr; } /** * Returns the array start. * @return array start, same address as getAlias()+1 */ T *getArrayStart() const { return reinterpret_cast(getAlias()+1); } /** * Returns the array limit. * @return array limit */ T *getArrayLimit() const { return getArrayStart()+capacity; } /** * Access without ownership change. Same as getAlias(). * A class instance can be used directly in expressions that take a T *. * @return the header pointer */ operator H *() const { return ptr; } /** * Array item access (writable). * No index bounds check. * @param i array index * @return reference to the array item */ T &operator[](ptrdiff_t i) { return getArrayStart()[i]; } /** * Deletes the memory block (if owned) and aliases another one, no transfer of ownership. * If the arguments are illegal, then the current memory is unchanged. * @param otherArray must not be NULL * @param otherCapacity must be >0 */ void aliasInstead(H *otherMemory, int32_t otherCapacity) { if(otherMemory!=NULL && otherCapacity>0) { releaseMemory(); ptr=otherMemory; capacity=otherCapacity; needToRelease=false; } } /** * Deletes the memory block (if owned) and allocates a new one, * copying the header and length T array items. * Returns the new header pointer. * If the allocation fails, then the current memory is unchanged and * this method returns NULL. * @param newCapacity can be less than or greater than the current capacity; * must be >0 * @param length number of T items to be copied from the old array to the new one * @return the allocated pointer, or NULL if the allocation failed */ inline H *resize(int32_t newCapacity, int32_t length=0); /** * Gives up ownership of the memory if owned, or else clones it, * copying the header and length T array items; resets itself to the internal memory. * Returns NULL if the allocation failed. * @param length number of T items to copy when cloning, * and array capacity of the clone when cloning * @param resultCapacity will be set to the returned array's capacity (output-only) * @return the header pointer; * caller becomes responsible for deleting the array */ inline H *orphanOrClone(int32_t length, int32_t &resultCapacity); private: H *ptr; int32_t capacity; UBool needToRelease; // stackHeader must precede stackArray immediately. H stackHeader; T stackArray[stackCapacity]; void releaseMemory() { if(needToRelease) { uprv_free(ptr); } } /* No comparison operators with other MaybeStackHeaderAndArray's. */ bool operator==(const MaybeStackHeaderAndArray & /*other*/) {return false;} bool operator!=(const MaybeStackHeaderAndArray & /*other*/) {return true;} /* No ownership transfer: No copy constructor, no assignment operator. */ MaybeStackHeaderAndArray(const MaybeStackHeaderAndArray & /*other*/) {} void operator=(const MaybeStackHeaderAndArray & /*other*/) {} }; template inline H *MaybeStackHeaderAndArray::resize(int32_t newCapacity, int32_t length) { if(newCapacity>=0) { #if U_DEBUG && defined(UPRV_MALLOC_COUNT) ::fprintf(::stderr,"MaybeStackHeaderAndArray alloc %d + %d * %ul\n", sizeof(H),newCapacity,sizeof(T)); #endif H *p=(H *)uprv_malloc(sizeof(H)+newCapacity*sizeof(T)); if(p!=NULL) { if(length<0) { length=0; } else if(length>0) { if(length>capacity) { length=capacity; } if(length>newCapacity) { length=newCapacity; } } uprv_memcpy(p, ptr, sizeof(H)+(size_t)length*sizeof(T)); releaseMemory(); ptr=p; capacity=newCapacity; needToRelease=true; } return p; } else { return NULL; } } template inline H *MaybeStackHeaderAndArray::orphanOrClone(int32_t length, int32_t &resultCapacity) { H *p; if(needToRelease) { p=ptr; } else { if(length<0) { length=0; } else if(length>capacity) { length=capacity; } #if U_DEBUG && defined(UPRV_MALLOC_COUNT) ::fprintf(::stderr,"MaybeStackHeaderAndArray (orphan) alloc %ul + %d * %lu\n", sizeof(H),length,sizeof(T)); #endif p=(H *)uprv_malloc(sizeof(H)+length*sizeof(T)); if(p==NULL) { return NULL; } uprv_memcpy(p, ptr, sizeof(H)+(size_t)length*sizeof(T)); } resultCapacity=length; ptr=&stackHeader; capacity=stackCapacity; needToRelease=false; return p; } /** * A simple memory management class that creates new heap allocated objects (of * any class that has a public constructor), keeps track of them and eventually * deletes them all in its own destructor. * * A typical use-case would be code like this: * * MemoryPool pool; * * MyType* o1 = pool.create(); * if (o1 != nullptr) { * foo(o1); * } * * MyType* o2 = pool.create(1, 2, 3); * if (o2 != nullptr) { * bar(o2); * } * * // MemoryPool will take care of deleting the MyType objects. * * It doesn't do anything more than that, and is intentionally kept minimalist. */ template class MemoryPool : public UMemory { public: MemoryPool() : fCount(0), fPool() {} ~MemoryPool() { for (int32_t i = 0; i < fCount; ++i) { delete fPool[i]; } } MemoryPool(const MemoryPool&) = delete; MemoryPool& operator=(const MemoryPool&) = delete; MemoryPool(MemoryPool&& other) U_NOEXCEPT : fCount(other.fCount), fPool(std::move(other.fPool)) { other.fCount = 0; } MemoryPool& operator=(MemoryPool&& other) U_NOEXCEPT { // Since `this` may contain instances that need to be deleted, we can't // just throw them away and replace them with `other`. The normal way of // dealing with this in C++ is to swap `this` and `other`, rather than // simply overwrite: the destruction of `other` can then take care of // running MemoryPool::~MemoryPool() over the still-to-be-deallocated // instances. std::swap(fCount, other.fCount); std::swap(fPool, other.fPool); return *this; } /** * Creates a new object of typename T, by forwarding any and all arguments * to the typename T constructor. * * @param args Arguments to be forwarded to the typename T constructor. * @return A pointer to the newly created object, or nullptr on error. */ template T* create(Args&&... args) { int32_t capacity = fPool.getCapacity(); if (fCount == capacity && fPool.resize(capacity == stackCapacity ? 4 * capacity : 2 * capacity, capacity) == nullptr) { return nullptr; } return fPool[fCount++] = new T(std::forward(args)...); } template T* createAndCheckErrorCode(UErrorCode &status, Args &&... args) { if (U_FAILURE(status)) { return nullptr; } T *pointer = this->create(args...); if (U_SUCCESS(status) && pointer == nullptr) { status = U_MEMORY_ALLOCATION_ERROR; } return pointer; } /** * @return Number of elements that have been allocated. */ int32_t count() const { return fCount; } protected: int32_t fCount; MaybeStackArray fPool; }; /** * An internal Vector-like implementation based on MemoryPool. * * Heap-allocates each element and stores pointers. * * To append an item to the vector, use emplaceBack. * * MaybeStackVector vector; * MyType* element = vector.emplaceBack(); * if (!element) { * status = U_MEMORY_ALLOCATION_ERROR; * } * // do stuff with element * * To loop over the vector, use a for loop with indices: * * for (int32_t i = 0; i < vector.length(); i++) { * MyType* element = vector[i]; * } */ template class MaybeStackVector : protected MemoryPool { public: template T* emplaceBack(Args&&... args) { return this->create(args...); } template T *emplaceBackAndCheckErrorCode(UErrorCode &status, Args &&... args) { return this->createAndCheckErrorCode(status, args...); } int32_t length() const { return this->fCount; } T** getAlias() { return this->fPool.getAlias(); } const T *const *getAlias() const { return this->fPool.getAlias(); } /** * Array item access (read-only). * No index bounds check. * @param i array index * @return reference to the array item */ const T* operator[](ptrdiff_t i) const { return this->fPool[i]; } /** * Array item access (writable). * No index bounds check. * @param i array index * @return reference to the array item */ T* operator[](ptrdiff_t i) { return this->fPool[i]; } }; U_NAMESPACE_END #endif /* __cplusplus */ #endif /* CMEMORY_H */