From b549cc38c8404c58642ada75c0b24907702cc005 Mon Sep 17 00:00:00 2001 From: Herb Derby Date: Mon, 27 Mar 2017 13:35:15 -0400 Subject: Change SkMemory to the more accurately named SkMalloc. Change-Id: I6b08a74234b99bac866bad71014b94f7ec2d4bc8 Reviewed-on: https://skia-review.googlesource.com/10188 Commit-Queue: Herb Derby Reviewed-by: Brian Salomon --- include/private/SkMalloc.h | 84 +++++++++++++++++++++++++++++++++++++++++++ include/private/SkMemory.h | 84 ------------------------------------------- include/private/SkTDArray.h | 2 +- include/private/SkTemplates.h | 2 +- 4 files changed, 86 insertions(+), 86 deletions(-) create mode 100644 include/private/SkMalloc.h delete mode 100644 include/private/SkMemory.h (limited to 'include/private') diff --git a/include/private/SkMalloc.h b/include/private/SkMalloc.h new file mode 100644 index 0000000000..58e11f657c --- /dev/null +++ b/include/private/SkMalloc.h @@ -0,0 +1,84 @@ +/* + * Copyright 2017 Google Inc. + * + * Use of this source code is governed by a BSD-style license that can be + * found in the LICENSE file. + */ + +#ifndef SkMalloc_DEFINED +#define SkMalloc_DEFINED + +#include +#include + +#include "SkPreConfig.h" + +/* + memory wrappers to be implemented by the porting layer (platform) +*/ + +enum { + SK_MALLOC_TEMP = 0x01, //!< hint to sk_malloc that the requested memory will be freed in the scope of the stack frame + SK_MALLOC_THROW = 0x02 //!< instructs sk_malloc to call sk_throw if the memory cannot be allocated. +}; +/** 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 null (if SK_MALLOC_TEMP bit is clear) or throw an exception + (if SK_MALLOC_TEMP bit is set). To free the memory, call sk_free(). +*/ +SK_API extern void* sk_malloc_flags(size_t size, unsigned flags); +/** Same as sk_malloc(), but hard coded to pass SK_MALLOC_THROW as the flag +*/ +SK_API extern void* sk_malloc_throw(size_t size); +/** Same as standard realloc(), but this one never returns null on failure. It will throw + an exception if it fails. +*/ +SK_API extern void* sk_realloc_throw(void* buffer, size_t size); +/** Free memory returned by sk_malloc(). It is safe to pass null. +*/ +SK_API extern void sk_free(void*); + +/** Much like calloc: returns a pointer to at least size zero bytes, or NULL on failure. + */ +SK_API extern void* sk_calloc(size_t size); + +/** Same as sk_calloc, but throws an exception instead of returning NULL on failure. + */ +SK_API extern void* sk_calloc_throw(size_t size); + +/** Called internally if we run out of memory. The platform implementation must + not return, but should either throw an exception or otherwise exit. +*/ +SK_API extern void sk_out_of_memory(void); + +// bzero is safer than memset, but we can't rely on it, so... sk_bzero() +static inline void sk_bzero(void* buffer, size_t size) { + // Please c.f. sk_careful_memcpy. It's undefined behavior to call memset(null, 0, 0). + if (size) { + memset(buffer, 0, size); + } +} + +/** + * 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. + */ +static inline void* sk_careful_memcpy(void* dst, const void* src, size_t len) { + // 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; +} + +#endif // SkMalloc_DEFINED diff --git a/include/private/SkMemory.h b/include/private/SkMemory.h deleted file mode 100644 index 02ad0ce52e..0000000000 --- a/include/private/SkMemory.h +++ /dev/null @@ -1,84 +0,0 @@ -/* - * Copyright 2017 Google Inc. - * - * Use of this source code is governed by a BSD-style license that can be - * found in the LICENSE file. - */ - -#ifndef SkMemory_DEFINED -#define SkMemory_DEFINED - -#include -#include - -#include "SkPreConfig.h" - -/* - memory wrappers to be implemented by the porting layer (platform) -*/ - -enum { - SK_MALLOC_TEMP = 0x01, //!< hint to sk_malloc that the requested memory will be freed in the scope of the stack frame - SK_MALLOC_THROW = 0x02 //!< instructs sk_malloc to call sk_throw if the memory cannot be allocated. -}; -/** 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 null (if SK_MALLOC_TEMP bit is clear) or throw an exception - (if SK_MALLOC_TEMP bit is set). To free the memory, call sk_free(). -*/ -SK_API extern void* sk_malloc_flags(size_t size, unsigned flags); -/** Same as sk_malloc(), but hard coded to pass SK_MALLOC_THROW as the flag -*/ -SK_API extern void* sk_malloc_throw(size_t size); -/** Same as standard realloc(), but this one never returns null on failure. It will throw - an exception if it fails. -*/ -SK_API extern void* sk_realloc_throw(void* buffer, size_t size); -/** Free memory returned by sk_malloc(). It is safe to pass null. -*/ -SK_API extern void sk_free(void*); - -/** Much like calloc: returns a pointer to at least size zero bytes, or NULL on failure. - */ -SK_API extern void* sk_calloc(size_t size); - -/** Same as sk_calloc, but throws an exception instead of returning NULL on failure. - */ -SK_API extern void* sk_calloc_throw(size_t size); - -/** Called internally if we run out of memory. The platform implementation must - not return, but should either throw an exception or otherwise exit. -*/ -SK_API extern void sk_out_of_memory(void); - -// bzero is safer than memset, but we can't rely on it, so... sk_bzero() -static inline void sk_bzero(void* buffer, size_t size) { - // Please c.f. sk_careful_memcpy. It's undefined behavior to call memset(null, 0, 0). - if (size) { - memset(buffer, 0, size); - } -} - -/** - * 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. - */ -static inline void* sk_careful_memcpy(void* dst, const void* src, size_t len) { - // 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; -} - -#endif //SkMemory_DEFINED diff --git a/include/private/SkTDArray.h b/include/private/SkTDArray.h index acf69b58b4..4c58d478fe 100644 --- a/include/private/SkTDArray.h +++ b/include/private/SkTDArray.h @@ -11,7 +11,7 @@ #define SkTDArray_DEFINED #include "SkTypes.h" -#include "SkMemory.h" +#include "SkMalloc.h" template class SkTDArray { public: diff --git a/include/private/SkTemplates.h b/include/private/SkTemplates.h index e8dd04e6c5..351fcccfc3 100644 --- a/include/private/SkTemplates.h +++ b/include/private/SkTemplates.h @@ -11,7 +11,7 @@ #define SkTemplates_DEFINED #include "SkMath.h" -#include "SkMemory.h" +#include "SkMalloc.h" #include "SkTLogic.h" #include "SkTypes.h" #include -- cgit v1.2.3