msp430: provide oneway-malloc implicitly

For MSP430 boards oneway-malloc is already used *if* `malloc.h` was
included. The problem is that `malloc.h` is not a standard header, even
though it is common. `stdlib.h` in the right place to look for
`malloc()` and friends.

This change removes this discrepancy. `malloc()` is just named like
that, without the leading underscore. The symbols now are weak, which
means that they won't override library functions if MSP's standard
library will provide these functions at some point. (Unlikely, since
using `malloc()` on tiny systems is less then optimal ...)

Closes #1061 and #863.

core/include/oneway_malloc.h

-/*
- * Copyright (C) 2013 Freie Universität Berlin
- *
- * This file is subject to the terms and conditions of the GNU Lesser General
- * Public License. See the file LICENSE in the top level directory for more
- * details.
- */
-
-/**
- * @addtogroup  core_util
- * @{
- *
- * @file        oneway_malloc.h
- * @brief       Simple malloc wrapper for sbrk
- *
- * @author      Freie Universität Berlin, Computer Systems & Telematics
- * @author      Kaspar Schleiser <kaspar@schleiser.de>
- *
- * @detail      Simple malloc implementation for plattforms
- *              without malloc in libc, e.g. msb430.
- */
-
-#ifndef _MALLOC_H_
-#define _MALLOC_H_
-
-#include <stddef.h>
-
-/**
- * @brief Allocates a block of `size` bytes of memory
- *
- * @param[in] Size of the memory block, in bytes.
- *
- * @return On success, a pointer to the memory block allocated by the function.
- * @return NULL otherwise.
- */
-void *_malloc(size_t size);
-
-/**
- * @brief Changes the size of the memory block pointed to by ptr.
- *
- * @param[in] Pointer to a memory block previously allocated with malloc,
- *            calloc or realloc.
- *
- * @param[in] New size for the memory block, in bytes.
- *
- * @return A pointer to the reallocated memory block, which may be either
- *         the same as ptr or a new location.
- */
-void *_realloc(void *ptr, size_t size);
-
-/**
- * @brief Allocates a block of memory for an array of num elements,
- *        each of them size bytes long, and initializes all its bits to zero.
- *
- * @param[in] Number of elements to allocate.
- * @param[in] Size of each element.
- *
- * @return On success, a pointer to the memory block allocated by the function.
- *         If the function failed to allocate the requested block of memory,
- *         a null pointer is returned.
- */
-void *_calloc(int size, size_t cnt);
-
-/**
- * @brief  A block of memory previously allocated by a call to malloc,
- *         calloc or realloc is deallocated, making it available again
- *         for further allocations.
- *
- * @param[in] Pointer to a memory block previously allocated with malloc,
- *            calloc or realloc.
- */
-void _free(void *ptr);
-
-/** @} */
-#endif /* _MALLOC_H_ */

cpu/msp430-common/Makefile.include

 INCLUDES += -I$(RIOTBASE)/cpu/msp430-common/include/
+
+DEFAULT_MODULE += oneway_malloc

sys/Makefile

@@ -89,6 +89,9 @@ endif
 ifneq (,$(filter quad_math,$(USEMODULE)))
     DIRS += quad_math
 endif
+ifneq (,$(filter oneway_malloc,$(USEMODULE)))
+    DIRS += oneway-malloc
+endif
 
 all: $(BINDIR)$(MODULE).a
 	@for i in $(DIRS) ; do "$(MAKE)" -C $$i || exit 1; done ;

sys/Makefile.include

@@ -43,3 +43,7 @@ endif
 ifneq (,$(filter pthread,$(USEMODULE)))
     USEMODULE_INCLUDES += $(RIOTBASE)/sys/posix/pthread/include
 endif
+
+ifneq (,$(filter oneway_malloc,$(USEMODULE)))
+    USEMODULE_INCLUDES += $(RIOTBASE)/sys/oneway-malloc/include
+endif

sys/oneway-malloc/Makefile

+MODULE = oneway_malloc
+
+include $(RIOTBASE)/Makefile.base

cpu/msp430-common/include/malloc.h → sys/oneway-malloc/include/malloc.h

 #ifndef __MALLOC_H
 #define __MALLOC_H
 
-#include "oneway_malloc.h"
+#include <stdlib.h>
 
-#define malloc _malloc
-#define calloc _calloc
-#define realloc _realloc
-#define free _free
+void *malloc(size_t size);
+void *realloc(void *ptr, size_t size);
+void *calloc(int size, size_t cnt);
+void free(void *ptr);
 
 #endif /* __MALLOC_H */

core/oneway_malloc.c → sys/oneway-malloc/oneway-malloc.c

@@ -7,7 +7,8 @@
  */
 
 /**
- * @ingroup     core_util
+ * @addtogroup oneway_malloc
+ * @ingroup sys
  * @{
  *
  * @file        oneway_malloc.c
@@ -18,50 +19,60 @@
  * @}
  */
 
-#include <stdio.h>
 #include <string.h>
-#include <stdlib.h>
+
+#include "malloc.h"
 
 #define ENABLE_DEBUG    (0)
 #include "debug.h"
 
 extern void *sbrk(int incr);
 
-void *_malloc(size_t size)
+void __attribute__((weak)) *malloc(size_t size)
 {
-    void *ptr = sbrk(size);
+    if (size != 0) {
+        void *ptr = sbrk(size);
 
-    DEBUG("_malloc(): allocating block of size %u at 0x%X.\n", (unsigned int) size, (unsigned int)ptr);
+        DEBUG("malloc(): allocating block of size %u at %p.\n", (unsigned int) size, ptr);
 
-    if (ptr != (void*) - 1) {
-        return ptr;
-    }
-    else {
-        return NULL;
+        if (ptr != (void*) -1) {
+            return ptr;
+        }
     }
+    return NULL;
 }
 
-void *_realloc(void *ptr, size_t size)
+void __attribute__((weak)) *realloc(void *ptr, size_t size)
 {
-    void *newptr = _malloc(size);
-    memcpy(newptr, ptr, size);
-    free(ptr);
-    return newptr;
+    if (ptr == NULL) {
+        return malloc(size);
+    }
+    else if (size == 0) {
+        free(ptr);
+        return NULL;
+    }
+    else {
+        void *newptr = malloc(size);
+        if (newptr) {
+            memcpy(newptr, ptr, size);
+        }
+        return newptr;
+    }
 }
 
-void *_calloc(int size, size_t cnt)
+void __attribute__((weak)) *calloc(int size, size_t cnt)
 {
-    void *mem = _malloc(size * cnt);
+    void *mem = malloc(size * cnt);
     if (mem) {
         memset(mem, 0, size * cnt);
     }
     return mem;
 }
 
-void _free(void *ptr)
+void __attribute__((weak)) free(void *ptr)
 {
     /* who cares about pointers? */
     (void) ptr;
 
-    DEBUG("_free(): block at 0x%X lost.\n", (unsigned int)ptr);
+    DEBUG("free(): block at %p lost.\n", ptr);
 }