SkMalloc.h File Reference

#include <cstring>
#include "include/private/base/SkAPI.h"

Go to the source code of this file.

Enumerations
enum	{ SK_MALLOC_ZERO_INITIALIZE = 1 << 0 , SK_MALLOC_THROW = 1 << 1 }

Functions
SK_API void	sk_free (void *)
SK_API void	sk_out_of_memory (void)
SK_API void *	sk_malloc_flags (size_t size, unsigned flags)
SK_API void *	sk_realloc_throw (void *buffer, size_t size)
SK_API size_t	sk_malloc_size (void *addr, size_t size)
static void *	sk_malloc_throw (size_t size)
static void *	sk_calloc_throw (size_t size)
static void *	sk_calloc_canfail (size_t size)
SK_API void *	sk_calloc_throw (size_t count, size_t elemSize)
SK_API void *	sk_malloc_throw (size_t count, size_t elemSize)
SK_API void *	sk_realloc_throw (void *buffer, size_t count, size_t elemSize)
static void *	sk_malloc_canfail (size_t size)
SK_API void *	sk_malloc_canfail (size_t count, size_t elemSize)
static void	sk_bzero (void *buffer, size_t size)
static void *	sk_careful_memcpy (void *dst, const void *src, size_t len)
static void *	sk_careful_memmove (void *dst, const void *src, size_t len)
static int	sk_careful_memcmp (const void *a, const void *b, size_t len)

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
SK_MALLOC_ZERO_INITIALIZE	If this bit is set, the returned buffer must be zero-initialized. If this bit is not set the buffer can be uninitialized.
SK_MALLOC_THROW	If this bit is set, the implementation must throw/crash/quit if the request cannot be fulfilled. If this bit is not set, then it should return nullptr on failure.

Definition at line 29 of file SkMalloc.h.

     {
    /**
     *  If this bit is set, the returned buffer must be zero-initialized. If this bit is not set
     *  the buffer can be uninitialized.
     */
    SK_MALLOC_ZERO_INITIALIZE   = 1 << 0,
 
    /**
     *  If this bit is set, the implementation must throw/crash/quit if the request cannot
     *  be fulfilled. If this bit is not set, then it should return nullptr on failure.
     */
    SK_MALLOC_THROW             = 1 << 1,
};

Function Documentation

sk_bzero()

static void sk_bzero ( void *  buffer, size_t  size  )

inlinestatic

Definition at line 105 of file SkMalloc.h.

                                                       {
    // Please c.f. sk_careful_memcpy.  It's undefined behavior to call memset(null, 0, 0).
    if (size) {
        memset(buffer, 0, size);
    }
}

sk_calloc_canfail()

static void * sk_calloc_canfail ( size_t  size )

inlinestatic

Definition at line 75 of file SkMalloc.h.

                                                   {
#if defined(SK_BUILD_FOR_FUZZER)
    // To reduce the chance of OOM, pretend we can't allocate more than 200kb.
    if (size > 200000) {
        return nullptr;
    }
#endif
    return sk_malloc_flags(size, SK_MALLOC_ZERO_INITIALIZE);
}

sk_calloc_throw() [1/2]

SK_API void * sk_calloc_throw	(	size_t	count,
		size_t	elemSize
	)

Definition at line 8 of file SkMalloc.cpp.

                                                     {
    return sk_calloc_throw(SkSafeMath::Mul(count, elemSize));
}

sk_calloc_throw() [2/2]

static void * sk_calloc_throw ( size_t  size )

inlinestatic

Definition at line 71 of file SkMalloc.h.

                                                 {
    return sk_malloc_flags(size, SK_MALLOC_THROW | SK_MALLOC_ZERO_INITIALIZE);
}

sk_careful_memcmp()

static int sk_careful_memcmp ( const void *  a, const void *  b, size_t  len  )

inlinestatic

Definition at line 143 of file SkMalloc.h.

                                                                              {
    // When we pass >0 len we had better already be passing valid pointers.
    // So we just need to skip calling memcmp when len == 0.
    if (len == 0) {
        return 0;   // we treat zero-length buffers as "equal"
    }
    return memcmp(a, b, len);
}

sk_careful_memcpy()

static void * sk_careful_memcpy ( void *  dst, const void *  src, size_t  len  )

inlinestatic

sk_careful_memcpy() is just like memcpy(), but guards against undefined behavior.

It is undefined behavior to call memcpy() with null dst or src, even if len is 0. If an optimizer is "smart" enough, it can exploit this to do unexpected things. memcpy(dst, src, 0); if (src) { printf("%x\n", *src); } In this code the compiler can assume src is not null and omit the if (src) {...} check, unconditionally running the printf, crashing the program if src really is null. Of the compilers we pay attention to only GCC performs this optimization in practice.

Definition at line 125 of file SkMalloc.h.

                                                                              {
    // When we pass >0 len we had better already be passing valid pointers.
    // So we just need to skip calling memcpy when len == 0.
    if (len) {
        memcpy(dst,src,len);
    }
    return dst;
}

sk_careful_memmove()

static void * sk_careful_memmove ( void *  dst, const void *  src, size_t  len  )

inlinestatic

Definition at line 134 of file SkMalloc.h.

                                                                               {
    // When we pass >0 len we had better already be passing valid pointers.
    // So we just need to skip calling memcpy when len == 0.
    if (len) {
        memmove(dst,src,len);
    }
    return dst;
}

sk_free()

SK_API void sk_free

(

void *

p

)

Free memory returned by sk_malloc(). It is safe to pass null.

Definition at line 83 of file SkMemory_malloc.cpp.

                      {
    // The guard here produces a performance improvement across many tests, and many platforms.
    // Removing the check was tried in skia cl 588037.
    if (p != nullptr) {
        free(p);
    }
}

sk_malloc_canfail() [1/2]

SK_API void * sk_malloc_canfail	(	size_t	count,
		size_t	elemSize
	)

Definition at line 20 of file SkMalloc.cpp.

                                                       {
    return sk_malloc_canfail(SkSafeMath::Mul(count, elemSize));
}

sk_malloc_canfail() [2/2]

static void * sk_malloc_canfail ( size_t  size )

inlinestatic

These variants return nullptr on failure

Definition at line 93 of file SkMalloc.h.

                                                   {
#if defined(SK_BUILD_FOR_FUZZER)
    // To reduce the chance of OOM, pretend we can't allocate more than 200kb.
    if (size > 200000) {
        return nullptr;
    }
#endif
    return sk_malloc_flags(size, 0);
}

sk_malloc_flags()

SK_API void * sk_malloc_flags	(	size_t	size,
		unsigned	flags
	)

Return a block of memory (at least 4-byte aligned) of at least the specified size. If the requested memory cannot be returned, either return nullptr or throw/exit, depending on the SK_MALLOC_THROW bit. If the allocation succeeds, the memory will be zero-initialized if the SK_MALLOC_ZERO_INITIALIZE bit was set.

To free the memory, call sk_free()

Definition at line 91 of file SkMemory_malloc.cpp.

                                                   {
    void* p;
    if (flags & SK_MALLOC_ZERO_INITIALIZE) {
        p = calloc(size, 1);
    } else {
#if defined(SK_BUILD_FOR_ANDROID_FRAMEWORK) && defined(__BIONIC__)
        /* TODO: After b/169449588 is fixed, we will want to change this to restore
         *       original behavior instead of always disabling the flag.
         * TODO: After b/158870657 is fixed and scudo is used globally, we can assert when an
         *       an error is returned.
         */
        // malloc() generally doesn't initialize its memory and that's a huge security hole,
        // so Android has replaced its malloc() with one that zeros memory,
        // but that's a huge performance hit for HWUI, so turn it back off again.
        (void)mallopt(M_THREAD_DISABLE_MEM_INIT, 1);
#endif
        p = malloc(size);
#if defined(SK_BUILD_FOR_ANDROID_FRAMEWORK) && defined(__BIONIC__)
        (void)mallopt(M_THREAD_DISABLE_MEM_INIT, 0);
#endif
    }
    if (flags & SK_MALLOC_THROW) {
        return throw_on_failure(size, p);
    } else {
        return p;
    }
}

sk_malloc_size()

SK_API size_t sk_malloc_size	(	void *	addr,
		size_t	size
	)

Return the size of the block of memory allocated in reality for a given pointer. The pointer passed must have been allocated using the sk_malloc_* or sk_realloc_* functions. The "size" parameter indicates the size originally requested when the memory block was allocated, and the value returned by this function must be bigger or equal to it.

Definition at line 119 of file SkMemory_malloc.cpp.

                                               {
    size_t completeSize = size;
 
    // Use the OS specific calls to find the actual capacity.
    #if defined(SK_BUILD_FOR_MAC) || defined(SK_BUILD_FOR_IOS)
        // TODO: remove the max, when the chrome implementation of malloc_size doesn't return 0.
        completeSize = std::max(malloc_size(addr), size);
    #elif defined(SK_BUILD_FOR_ANDROID) && __ANDROID_API__ >= 17
        completeSize = malloc_usable_size(addr);
        SkASSERT(completeSize >= size);
    #elif defined(SK_BUILD_FOR_UNIX)
        completeSize = malloc_usable_size(addr);
        SkASSERT(completeSize >= size);
    #elif defined(SK_BUILD_FOR_WIN)
        completeSize = _msize(addr);
        SkASSERT(completeSize >= size);
    #endif
 
    return completeSize;
}

sk_malloc_throw() [1/2]

SK_API void * sk_malloc_throw	(	size_t	count,
		size_t	elemSize
	)

Definition at line 12 of file SkMalloc.cpp.

                                                     {
    return sk_malloc_throw(SkSafeMath::Mul(count, elemSize));
}

sk_malloc_throw() [2/2]

static void * sk_malloc_throw ( size_t  size )

inlinestatic

Definition at line 67 of file SkMalloc.h.

                                                 {
    return sk_malloc_flags(size, SK_MALLOC_THROW);
}

sk_out_of_memory()

SK_API void sk_out_of_memory

(

void

)

Called internally if we run out of memory. The platform implementation must not return, but should either throw an exception or otherwise exit.

Definition at line 66 of file SkMemory_malloc.cpp.

                            {
    SkDEBUGFAIL("sk_out_of_memory");
#if defined(SK_BUILD_FOR_AFL_FUZZ)
    exit(1);
#else
    abort();
#endif
}

sk_realloc_throw() [1/2]

SK_API void * sk_realloc_throw	(	void *	buffer,
		size_t	count,
		size_t	elemSize
	)

Definition at line 16 of file SkMalloc.cpp.

                                                                    {
    return sk_realloc_throw(buffer, SkSafeMath::Mul(count, elemSize));
}

sk_realloc_throw() [2/2]

SK_API void * sk_realloc_throw	(	void *	buffer,
		size_t	size
	)

Same as standard realloc(), but this one never returns null on failure. It will throw if it fails. If size is 0, it will call sk_free on buffer and return null. (This behavior is implementation- defined for normal realloc. We follow what glibc does.)

Definition at line 75 of file SkMemory_malloc.cpp.

                                                {
    if (size == 0) {
        sk_free(addr);
        return nullptr;
    }
    return throw_on_failure(size, realloc(addr, size));
}