Knight KE / Mbed OS Game_Master

Important changes to repositories hosted on mbed.com

Mbed hosted mercurial repositories are deprecated and are due to be permanently deleted in July 2026.

To keep a copy of this software download the repository Zip archive or clone locally using Mercurial.

It is also possible to export all your personal repositories from the account settings page.

mbed-os/platform/mbed_alloc_wrappers.cpp@0:9b3d4731edbb, 2018-06-21 (annotated)

Committer:
WFKnight
Date:
Thu Jun 21 13:51:43 2018 +0000
Revision:
0:9b3d4731edbb
UART, RTOS, LED

Who changed what in which revision?

UserRevisionLine numberNew contents of line
WFKnight 0:9b3d4731edbb 1 /* mbed Microcontroller Library
WFKnight 0:9b3d4731edbb 2 * Copyright (c) 2006-2016 ARM Limited
WFKnight 0:9b3d4731edbb 3 *
WFKnight 0:9b3d4731edbb 4 * Licensed under the Apache License, Version 2.0 (the "License");
WFKnight 0:9b3d4731edbb 5 * you may not use this file except in compliance with the License.
WFKnight 0:9b3d4731edbb 6 * You may obtain a copy of the License at
WFKnight 0:9b3d4731edbb 7 *
WFKnight 0:9b3d4731edbb 8 * http://www.apache.org/licenses/LICENSE-2.0
WFKnight 0:9b3d4731edbb 9 *
WFKnight 0:9b3d4731edbb 10 * Unless required by applicable law or agreed to in writing, software
WFKnight 0:9b3d4731edbb 11 * distributed under the License is distributed on an "AS IS" BASIS,
WFKnight 0:9b3d4731edbb 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
WFKnight 0:9b3d4731edbb 13 * See the License for the specific language governing permissions and
WFKnight 0:9b3d4731edbb 14 * limitations under the License.
WFKnight 0:9b3d4731edbb 15 */
WFKnight 0:9b3d4731edbb 16
WFKnight 0:9b3d4731edbb 17 #include "platform/mbed_mem_trace.h"
WFKnight 0:9b3d4731edbb 18 #include "platform/mbed_stats.h"
WFKnight 0:9b3d4731edbb 19 #include "platform/mbed_toolchain.h"
WFKnight 0:9b3d4731edbb 20 #include "platform/SingletonPtr.h"
WFKnight 0:9b3d4731edbb 21 #include "platform/PlatformMutex.h"
WFKnight 0:9b3d4731edbb 22 #include <stddef.h>
WFKnight 0:9b3d4731edbb 23 #include <stdio.h>
WFKnight 0:9b3d4731edbb 24 #include <string.h>
WFKnight 0:9b3d4731edbb 25 #include <stdlib.h>
WFKnight 0:9b3d4731edbb 26
WFKnight 0:9b3d4731edbb 27 /* There are two memory tracers in mbed OS:
WFKnight 0:9b3d4731edbb 28
WFKnight 0:9b3d4731edbb 29 - the first can be used to detect the maximum heap usage at runtime. It is
WFKnight 0:9b3d4731edbb 30 activated by defining the MBED_HEAP_STATS_ENABLED macro.
WFKnight 0:9b3d4731edbb 31 - the second can be used to trace each memory call by automatically invoking
WFKnight 0:9b3d4731edbb 32 a callback on each memory operation (see hal/api/mbed_mem_trace.h). It is
WFKnight 0:9b3d4731edbb 33 activated by defining the MBED_MEM_TRACING_ENABLED macro.
WFKnight 0:9b3d4731edbb 34
WFKnight 0:9b3d4731edbb 35 Both tracers can be activated and deactivated in any combination. If both tracers
WFKnight 0:9b3d4731edbb 36 are active, the second one (MBED_MEM_TRACING_ENABLED) will trace the first one's
WFKnight 0:9b3d4731edbb 37 (MBED_HEAP_STATS_ENABLED) memory calls.*/
WFKnight 0:9b3d4731edbb 38
WFKnight 0:9b3d4731edbb 39 /******************************************************************************/
WFKnight 0:9b3d4731edbb 40 /* Implementation of the runtime max heap usage checker */
WFKnight 0:9b3d4731edbb 41 /******************************************************************************/
WFKnight 0:9b3d4731edbb 42
WFKnight 0:9b3d4731edbb 43 /* Size must be a multiple of 8 to keep alignment */
WFKnight 0:9b3d4731edbb 44 typedef struct {
WFKnight 0:9b3d4731edbb 45 uint32_t size;
WFKnight 0:9b3d4731edbb 46 uint32_t pad;
WFKnight 0:9b3d4731edbb 47 } alloc_info_t;
WFKnight 0:9b3d4731edbb 48
WFKnight 0:9b3d4731edbb 49 #ifdef MBED_HEAP_STATS_ENABLED
WFKnight 0:9b3d4731edbb 50 static SingletonPtr<PlatformMutex> malloc_stats_mutex;
WFKnight 0:9b3d4731edbb 51 static mbed_stats_heap_t heap_stats = {0, 0, 0, 0, 0};
WFKnight 0:9b3d4731edbb 52 #endif
WFKnight 0:9b3d4731edbb 53
WFKnight 0:9b3d4731edbb 54 void mbed_stats_heap_get(mbed_stats_heap_t *stats)
WFKnight 0:9b3d4731edbb 55 {
WFKnight 0:9b3d4731edbb 56 #ifdef MBED_HEAP_STATS_ENABLED
WFKnight 0:9b3d4731edbb 57 extern uint32_t mbed_heap_size;
WFKnight 0:9b3d4731edbb 58 heap_stats.reserved_size = mbed_heap_size;
WFKnight 0:9b3d4731edbb 59
WFKnight 0:9b3d4731edbb 60 malloc_stats_mutex->lock();
WFKnight 0:9b3d4731edbb 61 memcpy(stats, &heap_stats, sizeof(mbed_stats_heap_t));
WFKnight 0:9b3d4731edbb 62 malloc_stats_mutex->unlock();
WFKnight 0:9b3d4731edbb 63 #else
WFKnight 0:9b3d4731edbb 64 memset(stats, 0, sizeof(mbed_stats_heap_t));
WFKnight 0:9b3d4731edbb 65 #endif
WFKnight 0:9b3d4731edbb 66 }
WFKnight 0:9b3d4731edbb 67
WFKnight 0:9b3d4731edbb 68 /******************************************************************************/
WFKnight 0:9b3d4731edbb 69 /* GCC memory allocation wrappers */
WFKnight 0:9b3d4731edbb 70 /******************************************************************************/
WFKnight 0:9b3d4731edbb 71
WFKnight 0:9b3d4731edbb 72 #if defined(TOOLCHAIN_GCC)
WFKnight 0:9b3d4731edbb 73
WFKnight 0:9b3d4731edbb 74 #ifdef FEATURE_UVISOR
WFKnight 0:9b3d4731edbb 75 #include "uvisor-lib/uvisor-lib.h"
WFKnight 0:9b3d4731edbb 76 #endif/* FEATURE_UVISOR */
WFKnight 0:9b3d4731edbb 77
WFKnight 0:9b3d4731edbb 78 extern "C" {
WFKnight 0:9b3d4731edbb 79 void * __real__malloc_r(struct _reent * r, size_t size);
WFKnight 0:9b3d4731edbb 80 void * __real__memalign_r(struct _reent * r, size_t alignment, size_t bytes);
WFKnight 0:9b3d4731edbb 81 void * __real__realloc_r(struct _reent * r, void * ptr, size_t size);
WFKnight 0:9b3d4731edbb 82 void __real__free_r(struct _reent * r, void * ptr);
WFKnight 0:9b3d4731edbb 83 void* __real__calloc_r(struct _reent * r, size_t nmemb, size_t size);
WFKnight 0:9b3d4731edbb 84 void* malloc_wrapper(struct _reent * r, size_t size, void * caller);
WFKnight 0:9b3d4731edbb 85 void free_wrapper(struct _reent * r, void * ptr, void* caller);
WFKnight 0:9b3d4731edbb 86 }
WFKnight 0:9b3d4731edbb 87
WFKnight 0:9b3d4731edbb 88 // TODO: memory tracing doesn't work with uVisor enabled.
WFKnight 0:9b3d4731edbb 89 #if !defined(FEATURE_UVISOR)
WFKnight 0:9b3d4731edbb 90
WFKnight 0:9b3d4731edbb 91 extern "C" void * __wrap__malloc_r(struct _reent * r, size_t size) {
WFKnight 0:9b3d4731edbb 92 return malloc_wrapper(r, size, MBED_CALLER_ADDR());
WFKnight 0:9b3d4731edbb 93 }
WFKnight 0:9b3d4731edbb 94
WFKnight 0:9b3d4731edbb 95 extern "C" void * malloc_wrapper(struct _reent * r, size_t size, void * caller) {
WFKnight 0:9b3d4731edbb 96 void *ptr = NULL;
WFKnight 0:9b3d4731edbb 97 #ifdef MBED_MEM_TRACING_ENABLED
WFKnight 0:9b3d4731edbb 98 mbed_mem_trace_lock();
WFKnight 0:9b3d4731edbb 99 #endif
WFKnight 0:9b3d4731edbb 100 #ifdef MBED_HEAP_STATS_ENABLED
WFKnight 0:9b3d4731edbb 101 malloc_stats_mutex->lock();
WFKnight 0:9b3d4731edbb 102 alloc_info_t *alloc_info = (alloc_info_t*)__real__malloc_r(r, size + sizeof(alloc_info_t));
WFKnight 0:9b3d4731edbb 103 if (alloc_info != NULL) {
WFKnight 0:9b3d4731edbb 104 alloc_info->size = size;
WFKnight 0:9b3d4731edbb 105 ptr = (void*)(alloc_info + 1);
WFKnight 0:9b3d4731edbb 106 heap_stats.current_size += size;
WFKnight 0:9b3d4731edbb 107 heap_stats.total_size += size;
WFKnight 0:9b3d4731edbb 108 heap_stats.alloc_cnt += 1;
WFKnight 0:9b3d4731edbb 109 if (heap_stats.current_size > heap_stats.max_size) {
WFKnight 0:9b3d4731edbb 110 heap_stats.max_size = heap_stats.current_size;
WFKnight 0:9b3d4731edbb 111 }
WFKnight 0:9b3d4731edbb 112 } else {
WFKnight 0:9b3d4731edbb 113 heap_stats.alloc_fail_cnt += 1;
WFKnight 0:9b3d4731edbb 114 }
WFKnight 0:9b3d4731edbb 115 malloc_stats_mutex->unlock();
WFKnight 0:9b3d4731edbb 116 #else // #ifdef MBED_HEAP_STATS_ENABLED
WFKnight 0:9b3d4731edbb 117 ptr = __real__malloc_r(r, size);
WFKnight 0:9b3d4731edbb 118 #endif // #ifdef MBED_HEAP_STATS_ENABLED
WFKnight 0:9b3d4731edbb 119 #ifdef MBED_MEM_TRACING_ENABLED
WFKnight 0:9b3d4731edbb 120 mbed_mem_trace_malloc(ptr, size, caller);
WFKnight 0:9b3d4731edbb 121 mbed_mem_trace_unlock();
WFKnight 0:9b3d4731edbb 122 #endif // #ifdef MBED_MEM_TRACING_ENABLED
WFKnight 0:9b3d4731edbb 123 return ptr;
WFKnight 0:9b3d4731edbb 124 }
WFKnight 0:9b3d4731edbb 125
WFKnight 0:9b3d4731edbb 126 extern "C" void * __wrap__realloc_r(struct _reent * r, void * ptr, size_t size) {
WFKnight 0:9b3d4731edbb 127 void *new_ptr = NULL;
WFKnight 0:9b3d4731edbb 128 #ifdef MBED_MEM_TRACING_ENABLED
WFKnight 0:9b3d4731edbb 129 mbed_mem_trace_lock();
WFKnight 0:9b3d4731edbb 130 #endif
WFKnight 0:9b3d4731edbb 131 #ifdef MBED_HEAP_STATS_ENABLED
WFKnight 0:9b3d4731edbb 132 // Implement realloc_r with malloc and free.
WFKnight 0:9b3d4731edbb 133 // The function realloc_r can't be used here directly since
WFKnight 0:9b3d4731edbb 134 // it can call into __wrap__malloc_r (returns ptr + 4) or
WFKnight 0:9b3d4731edbb 135 // resize memory directly (returns ptr + 0).
WFKnight 0:9b3d4731edbb 136
WFKnight 0:9b3d4731edbb 137 // Note - no lock needed since malloc and free are thread safe
WFKnight 0:9b3d4731edbb 138
WFKnight 0:9b3d4731edbb 139 // Get old size
WFKnight 0:9b3d4731edbb 140 uint32_t old_size = 0;
WFKnight 0:9b3d4731edbb 141 if (ptr != NULL) {
WFKnight 0:9b3d4731edbb 142 alloc_info_t *alloc_info = ((alloc_info_t*)ptr) - 1;
WFKnight 0:9b3d4731edbb 143 old_size = alloc_info->size;
WFKnight 0:9b3d4731edbb 144 }
WFKnight 0:9b3d4731edbb 145
WFKnight 0:9b3d4731edbb 146 // Allocate space
WFKnight 0:9b3d4731edbb 147 if (size != 0) {
WFKnight 0:9b3d4731edbb 148 new_ptr = malloc(size);
WFKnight 0:9b3d4731edbb 149 }
WFKnight 0:9b3d4731edbb 150
WFKnight 0:9b3d4731edbb 151 // If the new buffer has been allocated copy the data to it
WFKnight 0:9b3d4731edbb 152 // and free the old buffer
WFKnight 0:9b3d4731edbb 153 if (new_ptr != NULL) {
WFKnight 0:9b3d4731edbb 154 uint32_t copy_size = (old_size < size) ? old_size : size;
WFKnight 0:9b3d4731edbb 155 memcpy(new_ptr, (void*)ptr, copy_size);
WFKnight 0:9b3d4731edbb 156 free(ptr);
WFKnight 0:9b3d4731edbb 157 }
WFKnight 0:9b3d4731edbb 158 #else // #ifdef MBED_HEAP_STATS_ENABLED
WFKnight 0:9b3d4731edbb 159 new_ptr = __real__realloc_r(r, ptr, size);
WFKnight 0:9b3d4731edbb 160 #endif // #ifdef MBED_HEAP_STATS_ENABLED
WFKnight 0:9b3d4731edbb 161 #ifdef MBED_MEM_TRACING_ENABLED
WFKnight 0:9b3d4731edbb 162 mbed_mem_trace_realloc(new_ptr, ptr, size, MBED_CALLER_ADDR());
WFKnight 0:9b3d4731edbb 163 mbed_mem_trace_unlock();
WFKnight 0:9b3d4731edbb 164 #endif // #ifdef MBED_MEM_TRACING_ENABLED
WFKnight 0:9b3d4731edbb 165 return new_ptr;
WFKnight 0:9b3d4731edbb 166 }
WFKnight 0:9b3d4731edbb 167
WFKnight 0:9b3d4731edbb 168 extern "C" void __wrap__free_r(struct _reent * r, void * ptr) {
WFKnight 0:9b3d4731edbb 169 free_wrapper(r, ptr, MBED_CALLER_ADDR());
WFKnight 0:9b3d4731edbb 170 }
WFKnight 0:9b3d4731edbb 171
WFKnight 0:9b3d4731edbb 172 extern "C" void free_wrapper(struct _reent * r, void * ptr, void * caller) {
WFKnight 0:9b3d4731edbb 173 #ifdef MBED_MEM_TRACING_ENABLED
WFKnight 0:9b3d4731edbb 174 mbed_mem_trace_lock();
WFKnight 0:9b3d4731edbb 175 #endif
WFKnight 0:9b3d4731edbb 176 #ifdef MBED_HEAP_STATS_ENABLED
WFKnight 0:9b3d4731edbb 177 malloc_stats_mutex->lock();
WFKnight 0:9b3d4731edbb 178 alloc_info_t *alloc_info = NULL;
WFKnight 0:9b3d4731edbb 179 if (ptr != NULL) {
WFKnight 0:9b3d4731edbb 180 alloc_info = ((alloc_info_t*)ptr) - 1;
WFKnight 0:9b3d4731edbb 181 heap_stats.current_size -= alloc_info->size;
WFKnight 0:9b3d4731edbb 182 heap_stats.alloc_cnt -= 1;
WFKnight 0:9b3d4731edbb 183 }
WFKnight 0:9b3d4731edbb 184 __real__free_r(r, (void*)alloc_info);
WFKnight 0:9b3d4731edbb 185 malloc_stats_mutex->unlock();
WFKnight 0:9b3d4731edbb 186 #else // #ifdef MBED_HEAP_STATS_ENABLED
WFKnight 0:9b3d4731edbb 187 __real__free_r(r, ptr);
WFKnight 0:9b3d4731edbb 188 #endif // #ifdef MBED_HEAP_STATS_ENABLED
WFKnight 0:9b3d4731edbb 189 #ifdef MBED_MEM_TRACING_ENABLED
WFKnight 0:9b3d4731edbb 190 mbed_mem_trace_free(ptr, caller);
WFKnight 0:9b3d4731edbb 191 mbed_mem_trace_unlock();
WFKnight 0:9b3d4731edbb 192 #endif // #ifdef MBED_MEM_TRACING_ENABLED
WFKnight 0:9b3d4731edbb 193 }
WFKnight 0:9b3d4731edbb 194
WFKnight 0:9b3d4731edbb 195 extern "C" void * __wrap__calloc_r(struct _reent * r, size_t nmemb, size_t size) {
WFKnight 0:9b3d4731edbb 196 void *ptr = NULL;
WFKnight 0:9b3d4731edbb 197 #ifdef MBED_MEM_TRACING_ENABLED
WFKnight 0:9b3d4731edbb 198 mbed_mem_trace_lock();
WFKnight 0:9b3d4731edbb 199 #endif
WFKnight 0:9b3d4731edbb 200 #ifdef MBED_HEAP_STATS_ENABLED
WFKnight 0:9b3d4731edbb 201 // Note - no lock needed since malloc is thread safe
WFKnight 0:9b3d4731edbb 202
WFKnight 0:9b3d4731edbb 203 ptr = malloc(nmemb * size);
WFKnight 0:9b3d4731edbb 204 if (ptr != NULL) {
WFKnight 0:9b3d4731edbb 205 memset(ptr, 0, nmemb * size);
WFKnight 0:9b3d4731edbb 206 }
WFKnight 0:9b3d4731edbb 207 #else // #ifdef MBED_HEAP_STATS_ENABLED
WFKnight 0:9b3d4731edbb 208 ptr = __real__calloc_r(r, nmemb, size);
WFKnight 0:9b3d4731edbb 209 #endif // #ifdef MBED_HEAP_STATS_ENABLED
WFKnight 0:9b3d4731edbb 210 #ifdef MBED_MEM_TRACING_ENABLED
WFKnight 0:9b3d4731edbb 211 mbed_mem_trace_calloc(ptr, nmemb, size, MBED_CALLER_ADDR());
WFKnight 0:9b3d4731edbb 212 mbed_mem_trace_unlock();
WFKnight 0:9b3d4731edbb 213 #endif // #ifdef MBED_MEM_TRACING_ENABLED
WFKnight 0:9b3d4731edbb 214 return ptr;
WFKnight 0:9b3d4731edbb 215 }
WFKnight 0:9b3d4731edbb 216
WFKnight 0:9b3d4731edbb 217 extern "C" void * __wrap__memalign_r(struct _reent * r, size_t alignment, size_t bytes) {
WFKnight 0:9b3d4731edbb 218 return __real__memalign_r(r, alignment, bytes);
WFKnight 0:9b3d4731edbb 219 }
WFKnight 0:9b3d4731edbb 220
WFKnight 0:9b3d4731edbb 221 #endif // if !defined(FEATURE_UVISOR)
WFKnight 0:9b3d4731edbb 222
WFKnight 0:9b3d4731edbb 223
WFKnight 0:9b3d4731edbb 224 /******************************************************************************/
WFKnight 0:9b3d4731edbb 225 /* ARMCC / IAR memory allocation wrappers */
WFKnight 0:9b3d4731edbb 226 /******************************************************************************/
WFKnight 0:9b3d4731edbb 227
WFKnight 0:9b3d4731edbb 228 #elif defined(TOOLCHAIN_ARM) || defined(__ICCARM__)
WFKnight 0:9b3d4731edbb 229
WFKnight 0:9b3d4731edbb 230 #if defined(TOOLCHAIN_ARM)
WFKnight 0:9b3d4731edbb 231 #define SUPER_MALLOC $Super$$malloc
WFKnight 0:9b3d4731edbb 232 #define SUB_MALLOC $Sub$$malloc
WFKnight 0:9b3d4731edbb 233 #define SUPER_REALLOC $Super$$realloc
WFKnight 0:9b3d4731edbb 234 #define SUB_REALLOC $Sub$$realloc
WFKnight 0:9b3d4731edbb 235 #define SUPER_CALLOC $Super$$calloc
WFKnight 0:9b3d4731edbb 236 #define SUB_CALLOC $Sub$$calloc
WFKnight 0:9b3d4731edbb 237 #define SUPER_FREE $Super$$free
WFKnight 0:9b3d4731edbb 238 #define SUB_FREE $Sub$$free
WFKnight 0:9b3d4731edbb 239 #elif defined(__ICCARM__)
WFKnight 0:9b3d4731edbb 240 #define SUPER_MALLOC $Super$$__iar_dlmalloc
WFKnight 0:9b3d4731edbb 241 #define SUB_MALLOC $Sub$$__iar_dlmalloc
WFKnight 0:9b3d4731edbb 242 #define SUPER_REALLOC $Super$$__iar_dlrealloc
WFKnight 0:9b3d4731edbb 243 #define SUB_REALLOC $Sub$$__iar_dlrealloc
WFKnight 0:9b3d4731edbb 244 #define SUPER_CALLOC $Super$$__iar_dlcalloc
WFKnight 0:9b3d4731edbb 245 #define SUB_CALLOC $Sub$$__iar_dlcalloc
WFKnight 0:9b3d4731edbb 246 #define SUPER_FREE $Super$$__iar_dlfree
WFKnight 0:9b3d4731edbb 247 #define SUB_FREE $Sub$$__iar_dlfree
WFKnight 0:9b3d4731edbb 248 #endif
WFKnight 0:9b3d4731edbb 249
WFKnight 0:9b3d4731edbb 250 /* Enable hooking of memory function only if tracing is also enabled */
WFKnight 0:9b3d4731edbb 251 #if defined(MBED_MEM_TRACING_ENABLED) || defined(MBED_HEAP_STATS_ENABLED)
WFKnight 0:9b3d4731edbb 252
WFKnight 0:9b3d4731edbb 253 extern "C" {
WFKnight 0:9b3d4731edbb 254 void *SUPER_MALLOC(size_t size);
WFKnight 0:9b3d4731edbb 255 void *SUPER_REALLOC(void *ptr, size_t size);
WFKnight 0:9b3d4731edbb 256 void *SUPER_CALLOC(size_t nmemb, size_t size);
WFKnight 0:9b3d4731edbb 257 void SUPER_FREE(void *ptr);
WFKnight 0:9b3d4731edbb 258 void *malloc_wrapper(size_t size, void* caller);
WFKnight 0:9b3d4731edbb 259 void free_wrapper(void *ptr, void* caller);
WFKnight 0:9b3d4731edbb 260 }
WFKnight 0:9b3d4731edbb 261
WFKnight 0:9b3d4731edbb 262
WFKnight 0:9b3d4731edbb 263 extern "C" void* SUB_MALLOC(size_t size) {
WFKnight 0:9b3d4731edbb 264 return malloc_wrapper(size, MBED_CALLER_ADDR());
WFKnight 0:9b3d4731edbb 265 }
WFKnight 0:9b3d4731edbb 266
WFKnight 0:9b3d4731edbb 267 extern "C" void* malloc_wrapper(size_t size, void* caller) {
WFKnight 0:9b3d4731edbb 268 void *ptr = NULL;
WFKnight 0:9b3d4731edbb 269 #ifdef MBED_MEM_TRACING_ENABLED
WFKnight 0:9b3d4731edbb 270 mbed_mem_trace_lock();
WFKnight 0:9b3d4731edbb 271 #endif
WFKnight 0:9b3d4731edbb 272 #ifdef MBED_HEAP_STATS_ENABLED
WFKnight 0:9b3d4731edbb 273 malloc_stats_mutex->lock();
WFKnight 0:9b3d4731edbb 274 alloc_info_t *alloc_info = (alloc_info_t*)SUPER_MALLOC(size + sizeof(alloc_info_t));
WFKnight 0:9b3d4731edbb 275 if (alloc_info != NULL) {
WFKnight 0:9b3d4731edbb 276 alloc_info->size = size;
WFKnight 0:9b3d4731edbb 277 ptr = (void*)(alloc_info + 1);
WFKnight 0:9b3d4731edbb 278 heap_stats.current_size += size;
WFKnight 0:9b3d4731edbb 279 heap_stats.total_size += size;
WFKnight 0:9b3d4731edbb 280 heap_stats.alloc_cnt += 1;
WFKnight 0:9b3d4731edbb 281 if (heap_stats.current_size > heap_stats.max_size) {
WFKnight 0:9b3d4731edbb 282 heap_stats.max_size = heap_stats.current_size;
WFKnight 0:9b3d4731edbb 283 }
WFKnight 0:9b3d4731edbb 284 } else {
WFKnight 0:9b3d4731edbb 285 heap_stats.alloc_fail_cnt += 1;
WFKnight 0:9b3d4731edbb 286 }
WFKnight 0:9b3d4731edbb 287 malloc_stats_mutex->unlock();
WFKnight 0:9b3d4731edbb 288 #else // #ifdef MBED_HEAP_STATS_ENABLED
WFKnight 0:9b3d4731edbb 289 ptr = SUPER_MALLOC(size);
WFKnight 0:9b3d4731edbb 290 #endif // #ifdef MBED_HEAP_STATS_ENABLED
WFKnight 0:9b3d4731edbb 291 #ifdef MBED_MEM_TRACING_ENABLED
WFKnight 0:9b3d4731edbb 292 mbed_mem_trace_malloc(ptr, size, caller);
WFKnight 0:9b3d4731edbb 293 mbed_mem_trace_unlock();
WFKnight 0:9b3d4731edbb 294 #endif // #ifdef MBED_MEM_TRACING_ENABLED
WFKnight 0:9b3d4731edbb 295 return ptr;
WFKnight 0:9b3d4731edbb 296 }
WFKnight 0:9b3d4731edbb 297
WFKnight 0:9b3d4731edbb 298
WFKnight 0:9b3d4731edbb 299 extern "C" void* SUB_REALLOC(void *ptr, size_t size) {
WFKnight 0:9b3d4731edbb 300 void *new_ptr = NULL;
WFKnight 0:9b3d4731edbb 301 #ifdef MBED_MEM_TRACING_ENABLED
WFKnight 0:9b3d4731edbb 302 mbed_mem_trace_lock();
WFKnight 0:9b3d4731edbb 303 #endif
WFKnight 0:9b3d4731edbb 304 #ifdef MBED_HEAP_STATS_ENABLED
WFKnight 0:9b3d4731edbb 305 // Note - no lock needed since malloc and free are thread safe
WFKnight 0:9b3d4731edbb 306
WFKnight 0:9b3d4731edbb 307 // Get old size
WFKnight 0:9b3d4731edbb 308 uint32_t old_size = 0;
WFKnight 0:9b3d4731edbb 309 if (ptr != NULL) {
WFKnight 0:9b3d4731edbb 310 alloc_info_t *alloc_info = ((alloc_info_t*)ptr) - 1;
WFKnight 0:9b3d4731edbb 311 old_size = alloc_info->size;
WFKnight 0:9b3d4731edbb 312 }
WFKnight 0:9b3d4731edbb 313
WFKnight 0:9b3d4731edbb 314 // Allocate space
WFKnight 0:9b3d4731edbb 315 if (size != 0) {
WFKnight 0:9b3d4731edbb 316 new_ptr = malloc(size);
WFKnight 0:9b3d4731edbb 317 }
WFKnight 0:9b3d4731edbb 318
WFKnight 0:9b3d4731edbb 319 // If the new buffer has been allocated copy the data to it
WFKnight 0:9b3d4731edbb 320 // and free the old buffer
WFKnight 0:9b3d4731edbb 321 if (new_ptr != NULL) {
WFKnight 0:9b3d4731edbb 322 uint32_t copy_size = (old_size < size) ? old_size : size;
WFKnight 0:9b3d4731edbb 323 memcpy(new_ptr, (void*)ptr, copy_size);
WFKnight 0:9b3d4731edbb 324 free(ptr);
WFKnight 0:9b3d4731edbb 325 }
WFKnight 0:9b3d4731edbb 326 #else // #ifdef MBED_HEAP_STATS_ENABLED
WFKnight 0:9b3d4731edbb 327 new_ptr = SUPER_REALLOC(ptr, size);
WFKnight 0:9b3d4731edbb 328 #endif // #ifdef MBED_HEAP_STATS_ENABLED
WFKnight 0:9b3d4731edbb 329 #ifdef MBED_MEM_TRACING_ENABLED
WFKnight 0:9b3d4731edbb 330 mbed_mem_trace_realloc(new_ptr, ptr, size, MBED_CALLER_ADDR());
WFKnight 0:9b3d4731edbb 331 mbed_mem_trace_unlock();
WFKnight 0:9b3d4731edbb 332 #endif // #ifdef MBED_MEM_TRACING_ENABLED
WFKnight 0:9b3d4731edbb 333 return new_ptr;
WFKnight 0:9b3d4731edbb 334 }
WFKnight 0:9b3d4731edbb 335
WFKnight 0:9b3d4731edbb 336 extern "C" void *SUB_CALLOC(size_t nmemb, size_t size) {
WFKnight 0:9b3d4731edbb 337 void *ptr = NULL;
WFKnight 0:9b3d4731edbb 338 #ifdef MBED_MEM_TRACING_ENABLED
WFKnight 0:9b3d4731edbb 339 mbed_mem_trace_lock();
WFKnight 0:9b3d4731edbb 340 #endif
WFKnight 0:9b3d4731edbb 341 #ifdef MBED_HEAP_STATS_ENABLED
WFKnight 0:9b3d4731edbb 342 // Note - no lock needed since malloc is thread safe
WFKnight 0:9b3d4731edbb 343 ptr = malloc(nmemb * size);
WFKnight 0:9b3d4731edbb 344 if (ptr != NULL) {
WFKnight 0:9b3d4731edbb 345 memset(ptr, 0, nmemb * size);
WFKnight 0:9b3d4731edbb 346 }
WFKnight 0:9b3d4731edbb 347 #else // #ifdef MBED_HEAP_STATS_ENABLED
WFKnight 0:9b3d4731edbb 348 ptr = SUPER_CALLOC(nmemb, size);
WFKnight 0:9b3d4731edbb 349 #endif // #ifdef MBED_HEAP_STATS_ENABLED
WFKnight 0:9b3d4731edbb 350 #ifdef MBED_MEM_TRACING_ENABLED
WFKnight 0:9b3d4731edbb 351 mbed_mem_trace_calloc(ptr, nmemb, size, MBED_CALLER_ADDR());
WFKnight 0:9b3d4731edbb 352 mbed_mem_trace_unlock();
WFKnight 0:9b3d4731edbb 353 #endif // #ifdef MBED_MEM_TRACING_ENABLED
WFKnight 0:9b3d4731edbb 354 return ptr;
WFKnight 0:9b3d4731edbb 355 }
WFKnight 0:9b3d4731edbb 356
WFKnight 0:9b3d4731edbb 357 extern "C" void SUB_FREE(void *ptr) {
WFKnight 0:9b3d4731edbb 358 free_wrapper(ptr, MBED_CALLER_ADDR());
WFKnight 0:9b3d4731edbb 359 }
WFKnight 0:9b3d4731edbb 360
WFKnight 0:9b3d4731edbb 361 extern "C" void free_wrapper(void *ptr, void* caller) {
WFKnight 0:9b3d4731edbb 362 #ifdef MBED_MEM_TRACING_ENABLED
WFKnight 0:9b3d4731edbb 363 mbed_mem_trace_lock();
WFKnight 0:9b3d4731edbb 364 #endif
WFKnight 0:9b3d4731edbb 365 #ifdef MBED_HEAP_STATS_ENABLED
WFKnight 0:9b3d4731edbb 366 malloc_stats_mutex->lock();
WFKnight 0:9b3d4731edbb 367 alloc_info_t *alloc_info = NULL;
WFKnight 0:9b3d4731edbb 368 if (ptr != NULL) {
WFKnight 0:9b3d4731edbb 369 alloc_info = ((alloc_info_t*)ptr) - 1;
WFKnight 0:9b3d4731edbb 370 heap_stats.current_size -= alloc_info->size;
WFKnight 0:9b3d4731edbb 371 heap_stats.alloc_cnt -= 1;
WFKnight 0:9b3d4731edbb 372 }
WFKnight 0:9b3d4731edbb 373 SUPER_FREE((void*)alloc_info);
WFKnight 0:9b3d4731edbb 374 malloc_stats_mutex->unlock();
WFKnight 0:9b3d4731edbb 375 #else // #ifdef MBED_HEAP_STATS_ENABLED
WFKnight 0:9b3d4731edbb 376 SUPER_FREE(ptr);
WFKnight 0:9b3d4731edbb 377 #endif // #ifdef MBED_HEAP_STATS_ENABLED
WFKnight 0:9b3d4731edbb 378 #ifdef MBED_MEM_TRACING_ENABLED
WFKnight 0:9b3d4731edbb 379 mbed_mem_trace_free(ptr, caller);
WFKnight 0:9b3d4731edbb 380 mbed_mem_trace_unlock();
WFKnight 0:9b3d4731edbb 381 #endif // #ifdef MBED_MEM_TRACING_ENABLED
WFKnight 0:9b3d4731edbb 382 }
WFKnight 0:9b3d4731edbb 383
WFKnight 0:9b3d4731edbb 384 #endif // #if defined(MBED_MEM_TRACING_ENABLED) || defined(MBED_HEAP_STATS_ENABLED)
WFKnight 0:9b3d4731edbb 385
WFKnight 0:9b3d4731edbb 386 /******************************************************************************/
WFKnight 0:9b3d4731edbb 387 /* Allocation wrappers for other toolchains are not supported yet */
WFKnight 0:9b3d4731edbb 388 /******************************************************************************/
WFKnight 0:9b3d4731edbb 389
WFKnight 0:9b3d4731edbb 390 #else
WFKnight 0:9b3d4731edbb 391
WFKnight 0:9b3d4731edbb 392 #ifdef MBED_MEM_TRACING_ENABLED
WFKnight 0:9b3d4731edbb 393 #error Memory tracing is not supported with the current toolchain.
WFKnight 0:9b3d4731edbb 394 #endif
WFKnight 0:9b3d4731edbb 395
WFKnight 0:9b3d4731edbb 396 #ifdef MBED_HEAP_STATS_ENABLED
WFKnight 0:9b3d4731edbb 397 #error Heap statistics are not supported with the current toolchain.
WFKnight 0:9b3d4731edbb 398 #endif
WFKnight 0:9b3d4731edbb 399
WFKnight 0:9b3d4731edbb 400 #endif // #if defined(TOOLCHAIN_GCC)