Introduce realloc(...)

Author: scopeInfinity

src/usr/include/stdlib.h

@@ -21,6 +21,7 @@ int abs(int a);
 int benchmark_get_heap_usage();
 int benchmark_get_heap_area();
 void *malloc(size_t size);
+void *realloc(void *ptr, size_t size);
 void free(void *ptr);
 
 void atexit(void (*)(void));

src/usr/include/string.h

@@ -12,7 +12,7 @@ int strcmpi(const char *l, const char *r);
 int strlen(const char *str);
 char *strcpy(char *dest, const char *src);
 char *strncpy(char *dest, const char *src, size_t n);
-void *memcpy(void *dest, const void *src, unsigned int n);
+void *memcpy(void *dest, const void *src, size_t n);
 void *memset(void *dest, const unsigned char c, size_t n);
 
 char *strchr(const char *str, char ch);

src/usr/lib/stdlib.c

@@ -265,6 +265,16 @@ static inline union heap_entry *heap_prev_block(union heap_entry *current,
     return block;
 }
 
+static inline union heap_entry *
+heap_block_from_usermemory(void *ptr, int verify_signature) {
+    union heap_entry *block = ptr - HEAP_HEADER_SIZE;
+    if (verify_signature) {
+        heap_assert(block->content.signature == HEAP_ENTRY_SIGNATURE,
+                    "heap_block_from_usermemory, invalid signature");
+    }
+    return block;
+}
+
 static inline union heap_entry *heap_push_back(union heap_entry *olast,
                                                size_t new_size) {
     heap_assert(olast->content.state == HEAP_BLOCK_LAST,
@@ -389,6 +399,10 @@ static inline union heap_entry *heap_get_free_block(size_t new_size) {
 
 void *malloc(size_t size) {
     heap_may_init();
+    if (size == 0) {
+        // do nothing
+        return NULL;
+    }
     // allocates in chunk of 4
     size = ((size + 3) >> 2) << 2;
     // allocate header
@@ -402,13 +416,13 @@ void *malloc(size_t size) {
 }
 
 void free(void *ptr) {
-    if (ptr == NULL)
-        return;
     heap_may_init();
+    if (ptr == NULL) {
+        // do nothing
+        return;
+    }
 
-    // current version of malloc is non-optimal and doesn't
-    // do any free operation.
-    union heap_entry *header = ptr - HEAP_HEADER_SIZE;
+    union heap_entry *header = heap_block_from_usermemory(ptr, 1);
     if (header->content.state != HEAP_BLOCK_ALLOCATED) {
         // trying to free unallocated memory
         return;
@@ -420,3 +434,28 @@ void free(void *ptr) {
     heap_freeblocks_merge(header);
 #endif
 }
+
+void *realloc(void *ptr, size_t size) {
+    heap_may_init();
+    if (ptr == NULL) {
+        return malloc(size);
+    }
+
+    union heap_entry *header = heap_block_from_usermemory(ptr, 1);
+    size_t old_size = header->content.size - HEAP_HEADER_SIZE;
+
+    if (old_size == size) {
+        // no need to allocate or free memory
+        return ptr;
+    }
+
+    // allocate memory for new data size
+    void *newdata = malloc(size);
+    // copy data
+    size_t copy_size = min(size, old_size);
+    memcpy(newdata, ptr, copy_size);
+    // free old data
+    free(ptr);
+
+    return newdata;
+}

src/usr/lib/string.c

@@ -67,7 +67,7 @@ char *strncpy(char *dst, const char *src, size_t n) {
     return og_dst;
 }
 
-void *memcpy(void *dst, const void *src, unsigned int n) {
+void *memcpy(void *dst, const void *src, size_t n) {
     void *og_dst = dst;
     while (n--) {
         *(char *)(dst++) = *(char *)(src++);

src/usr/local/src/test-stdlib.cpp

@@ -95,6 +95,34 @@ void test_malloc_free() {
     }
 }
 
+void test_realloc() {
+    // allocate memory
+    std::uint8_t *data =
+        (std::uint8_t *)std::realloc(NULL, sizeof(std::uint8_t) * 2);
+    ASSERT_TRUE(data);
+    data[0] = 100;
+    data[1] = 101;
+
+    // upsize memory
+    data = (std::uint8_t *)std::realloc(data, sizeof(std::uint8_t) * 4);
+    ASSERT_TRUE(data);
+    ASSERT_EQ(data[0], 100);
+    ASSERT_EQ(data[1], 101);
+    data[2] = 102;
+    data[3] = 103;
+
+    // downsize memory
+    data = (std::uint8_t *)std::realloc(data, sizeof(std::uint8_t) * 3);
+    ASSERT_TRUE(data);
+    ASSERT_EQ(data[0], 100);
+    ASSERT_EQ(data[1], 101);
+    ASSERT_EQ(data[2], 102);
+
+    // free memory
+    data = (std::uint8_t *)std::realloc(data, 0);
+    ASSERT_FALSE(data);
+}
+
 int main(int argc, char *argv[]) {
     TEST_INIT();
 
@@ -105,6 +133,7 @@ int main(int argc, char *argv[]) {
     RUN_TEST(test_itoa);
     RUN_TEST(test_ftoa);
     RUN_TEST(test_malloc_free);
+    RUN_TEST(test_realloc);
 
     TEST_SUMMARY();
     return 0;