// Protocol Buffers - Google's data interchange format // Copyright 2023 Google LLC. All rights reserved. // // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file or at // https://developers.google.com/open-source/licenses/bsd #ifndef UPB_MEM_INTERNAL_ARENA_H_ #define UPB_MEM_INTERNAL_ARENA_H_ #include #include #include // Must be last. #include "upb/port/def.inc" // This is QUITE an ugly hack, which specifies the number of pointers needed // to equal (or exceed) the storage required for one upb_Arena. // // We need this because the decoder inlines a upb_Arena for performance but // the full struct is not visible outside of arena.c. Yes, I know, it's awful. #define UPB_ARENA_SIZE_HACK 7 // LINT.IfChange(upb_Array) struct upb_Arena { char* UPB_ONLYBITS(ptr); char* UPB_ONLYBITS(end); }; // LINT.ThenChange(//depot/google3/third_party/upb/bits/typescript/arena.ts:upb_Array) #ifdef __cplusplus extern "C" { #endif void UPB_PRIVATE(_upb_Arena_SwapIn)(struct upb_Arena* des, const struct upb_Arena* src); void UPB_PRIVATE(_upb_Arena_SwapOut)(struct upb_Arena* des, const struct upb_Arena* src); UPB_INLINE size_t UPB_PRIVATE(_upb_ArenaHas)(const struct upb_Arena* a) { return (size_t)(a->UPB_ONLYBITS(end) - a->UPB_ONLYBITS(ptr)); } UPB_INLINE void* UPB_PRIVATE(_upb_Arena_Malloc)(struct upb_Arena* a, size_t size) { void* UPB_PRIVATE(_upb_Arena_SlowMalloc)(struct upb_Arena * a, size_t size); size = UPB_ALIGN_MALLOC(size); const size_t span = size + UPB_ASAN_GUARD_SIZE; if (UPB_UNLIKELY(UPB_PRIVATE(_upb_ArenaHas)(a) < span)) { return UPB_PRIVATE(_upb_Arena_SlowMalloc)(a, span); } // We have enough space to do a fast malloc. void* ret = a->UPB_ONLYBITS(ptr); UPB_ASSERT(UPB_ALIGN_MALLOC((uintptr_t)ret) == (uintptr_t)ret); UPB_ASSERT(UPB_ALIGN_MALLOC(size) == size); UPB_UNPOISON_MEMORY_REGION(ret, size); a->UPB_ONLYBITS(ptr) += span; return ret; } UPB_INLINE void* UPB_PRIVATE(_upb_Arena_Realloc)(struct upb_Arena* a, void* ptr, size_t oldsize, size_t size) { oldsize = UPB_ALIGN_MALLOC(oldsize); size = UPB_ALIGN_MALLOC(size); bool is_most_recent_alloc = (uintptr_t)ptr + oldsize == (uintptr_t)a->UPB_ONLYBITS(ptr); if (is_most_recent_alloc) { ptrdiff_t diff = size - oldsize; if ((ptrdiff_t)UPB_PRIVATE(_upb_ArenaHas)(a) >= diff) { a->UPB_ONLYBITS(ptr) += diff; return ptr; } } else if (size <= oldsize) { return ptr; } void* ret = UPB_PRIVATE(_upb_Arena_Malloc)(a, size); if (ret && oldsize > 0) { memcpy(ret, ptr, UPB_MIN(oldsize, size)); } return ret; } UPB_INLINE void UPB_PRIVATE(_upb_Arena_ShrinkLast)(struct upb_Arena* a, void* ptr, size_t oldsize, size_t size) { oldsize = UPB_ALIGN_MALLOC(oldsize); size = UPB_ALIGN_MALLOC(size); // Must be the last alloc. UPB_ASSERT((char*)ptr + oldsize == a->UPB_ONLYBITS(ptr) - UPB_ASAN_GUARD_SIZE); UPB_ASSERT(size <= oldsize); a->UPB_ONLYBITS(ptr) = (char*)ptr + size; } #ifdef __cplusplus } /* extern "C" */ #endif #include "upb/port/undef.inc" #endif /* UPB_MEM_INTERNAL_ARENA_H_ */