First version
[3rdparty/ote_partner/tlk.git] / lib / libc / malloc.c
1 /*
2  * Copyright (c) 2008 Travis Geiselbrecht
3  * Copyright (c) 2014, NVIDIA CORPORATION. All rights reserved
4  *
5  * Permission is hereby granted, free of charge, to any person obtaining
6  * a copy of this software and associated documentation files
7  * (the "Software"), to deal in the Software without restriction,
8  * including without limitation the rights to use, copy, modify, merge,
9  * publish, distribute, sublicense, and/or sell copies of the Software,
10  * and to permit persons to whom the Software is furnished to do so,
11  * subject to the following conditions:
12  *
13  * The above copyright notice and this permission notice shall be
14  * included in all copies or substantial portions of the Software.
15  *
16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
17  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
18  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
19  * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
20  * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
21  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
22  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
23  */
24 #include <debug.h>
25 #include <malloc.h>
26 #include <assert.h>
27 #include <string.h>
28 #include <lib/heap.h>
29
30 #define DEBUG_GUARD_SIZE_BYTES                  12
31 #define DEBUG_GUARD_HEADER_SIZE_BYTES           8
32 #define DEBUG_GUARD_FOOTER_SIZE_BYTES           4
33
34 #define DEBUG_GUARD_HEADER              0xDEADBEEF
35 #define DEBUG_GUARD_FOOTER              0xDEADF00D
36
37 void *malloc(size_t size)
38 {
39         uint8_t *ptr = (uint8_t *)heap_alloc(size + DEBUG_GUARD_SIZE_BYTES, 0);
40         uint32_t *ptr_tmp;
41
42         if (!ptr)
43                 return NULL;
44
45         ptr_tmp = (uint32_t *)ptr;
46         *ptr_tmp++ = DEBUG_GUARD_HEADER;
47         *ptr_tmp++ = size;
48         ptr_tmp = (uint32_t *)(ptr + DEBUG_GUARD_HEADER_SIZE_BYTES + size);
49         *(ptr_tmp) = DEBUG_GUARD_FOOTER;
50
51         return (void *)(ptr + DEBUG_GUARD_HEADER_SIZE_BYTES);
52 }
53
54 void *memalign(size_t boundary, size_t size)
55 {
56         return heap_alloc(size, boundary);
57 }
58
59 void *calloc(size_t count, size_t size)
60 {
61         void *ptr;
62         size_t realsize = count * size;
63
64         ptr = malloc(realsize);
65         memset(ptr, 0, realsize);
66
67         return ptr;
68 }
69
70 void *realloc(void *ptr, size_t size)
71 {
72         if (!ptr)
73                 return malloc(size);
74
75         // XXX better implementation
76         void *p = malloc(size);
77         if (!p)
78                 return NULL;
79
80         memcpy(p, ptr, size); // XXX wrong
81         free(ptr);
82
83         return p;
84 }
85
86 void free(void *ptr)
87 {
88         uint32_t *ptr_tmp = (uint32_t *)(ptr - DEBUG_GUARD_HEADER_SIZE_BYTES);
89
90         ASSERT(*ptr_tmp++ == DEBUG_GUARD_HEADER);
91         ptr_tmp = (uint32_t *)(ptr + *ptr_tmp);
92         ASSERT(*ptr_tmp == DEBUG_GUARD_FOOTER);
93
94         return heap_free(ptr - DEBUG_GUARD_HEADER_SIZE_BYTES);
95 }