diff options
Diffstat (limited to 'newlib/libc/stdlib/malloc.c')
| -rw-r--r-- | newlib/libc/stdlib/malloc.c | 206 |
1 files changed, 0 insertions, 206 deletions
diff --git a/newlib/libc/stdlib/malloc.c b/newlib/libc/stdlib/malloc.c deleted file mode 100644 index 83453ab8d..000000000 --- a/newlib/libc/stdlib/malloc.c +++ /dev/null @@ -1,206 +0,0 @@ -/* VxWorks provides its own version of malloc, and we can't use this - one because VxWorks does not provide sbrk. So we have a hook to - not compile this code. */ - -/* The routines here are simple cover fns to the routines that do the real - work (the reentrant versions). */ -/* FIXME: Does the warning below (see WARNINGS) about non-reentrancy still - apply? A first guess would be "no", but how about reentrancy in the *same* - thread? */ - -#ifdef MALLOC_PROVIDED - -int _dummy_malloc = 1; - -#else - -/* -FUNCTION -<<malloc>>, <<realloc>>, <<free>>---manage memory - -INDEX - malloc -INDEX - realloc -INDEX - free -INDEX - memalign -INDEX - malloc_usable_size -INDEX - _malloc_r -INDEX - _realloc_r -INDEX - _free_r -INDEX - _memalign_r -INDEX - _malloc_usable_size_r - -ANSI_SYNOPSIS - #include <stdlib.h> - void *malloc(size_t <[nbytes]>); - void *realloc(void *<[aptr]>, size_t <[nbytes]>); - void free(void *<[aptr]>); - - void *memalign(size_t <[align]>, size_t <[nbytes]>); - - size_t malloc_usable_size(void *<[aptr]>); - - void *_malloc_r(void *<[reent]>, size_t <[nbytes]>); - void *_realloc_r(void *<[reent]>, - void *<[aptr]>, size_t <[nbytes]>); - void _free_r(void *<[reent]>, void *<[aptr]>); - - void *_memalign_r(void *<[reent]>, - size_t <[align]>, size_t <[nbytes]>); - - size_t _malloc_usable_size_r(void *<[reent]>, void *<[aptr]>); - -TRAD_SYNOPSIS - #include <stdlib.h> - char *malloc(<[nbytes]>) - size_t <[nbytes]>; - - char *realloc(<[aptr]>, <[nbytes]>) - char *<[aptr]>; - size_t <[nbytes]>; - - void free(<[aptr]>) - char *<[aptr]>; - - char *memalign(<[align]>, <[nbytes]>) - size_t <[align]>; - size_t <[nbytes]>; - - size_t malloc_usable_size(<[aptr]>) - char *<[aptr]>; - - char *_malloc_r(<[reent]>,<[nbytes]>) - char *<[reent]>; - size_t <[nbytes]>; - - char *_realloc_r(<[reent]>, <[aptr]>, <[nbytes]>) - char *<[reent]>; - char *<[aptr]>; - size_t <[nbytes]>; - - void _free_r(<[reent]>, <[aptr]>) - char *<[reent]>; - char *<[aptr]>; - - char *_memalign_r(<[reent]>, <[align]>, <[nbytes]>) - char *<[reent]>; - size_t <[align]>; - size_t <[nbytes]>; - - size_t malloc_usable_size(<[reent]>, <[aptr]>) - char *<[reent]>; - char *<[aptr]>; - -DESCRIPTION -These functions manage a pool of system memory. - -Use <<malloc>> to request allocation of an object with at least -<[nbytes]> bytes of storage available. If the space is available, -<<malloc>> returns a pointer to a newly allocated block as its result. - -If you already have a block of storage allocated by <<malloc>>, but -you no longer need all the space allocated to it, you can make it -smaller by calling <<realloc>> with both the object pointer and the -new desired size as arguments. <<realloc>> guarantees that the -contents of the smaller object match the beginning of the original object. - -Similarly, if you need more space for an object, use <<realloc>> to -request the larger size; again, <<realloc>> guarantees that the -beginning of the new, larger object matches the contents of the -original object. - -When you no longer need an object originally allocated by <<malloc>> -or <<realloc>> (or the related function <<calloc>>), return it to the -memory storage pool by calling <<free>> with the address of the object -as the argument. You can also use <<realloc>> for this purpose by -calling it with <<0>> as the <[nbytes]> argument. - -The <<memalign>> function returns a block of size <[nbytes]> aligned -to a <[align]> boundary. The <[align]> argument must be a power of -two. - -The <<malloc_usable_size>> function takes a pointer to a block -allocated by <<malloc>>. It returns the amount of space that is -available in the block. This may or may not be more than the size -requested from <<malloc>>, due to alignment or minimum size -constraints. - -The alternate functions <<_malloc_r>>, <<_realloc_r>>, <<_free_r>>, -<<_memalign_r>>, and <<_malloc_usable_size_r>> are reentrant versions. -The extra argument <[reent]> is a pointer to a reentrancy structure. - -If you have multiple threads of execution which may call any of these -routines, or if any of these routines may be called reentrantly, then -you must provide implementations of the <<__malloc_lock>> and -<<__malloc_unlock>> functions for your system. See the documentation -for those functions. - -These functions operate by calling the function <<_sbrk_r>> or -<<sbrk>>, which allocates space. You may need to provide one of these -functions for your system. <<_sbrk_r>> is called with a positive -value to allocate more space, and with a negative value to release -previously allocated space if it is no longer required. -@xref{Stubs}. - -RETURNS -<<malloc>> returns a pointer to the newly allocated space, if -successful; otherwise it returns <<NULL>>. If your application needs -to generate empty objects, you may use <<malloc(0)>> for this purpose. - -<<realloc>> returns a pointer to the new block of memory, or <<NULL>> -if a new block could not be allocated. <<NULL>> is also the result -when you use `<<realloc(<[aptr]>,0)>>' (which has the same effect as -`<<free(<[aptr]>)>>'). You should always check the result of -<<realloc>>; successful reallocation is not guaranteed even when -you request a smaller object. - -<<free>> does not return a result. - -<<memalign>> returns a pointer to the newly allocated space. - -<<malloc_usable_size>> returns the usable size. - -PORTABILITY -<<malloc>>, <<realloc>>, and <<free>> are specified by the ANSI C -standard, but other conforming implementations of <<malloc>> may -behave differently when <[nbytes]> is zero. - -<<memalign>> is part of SVR4. - -<<malloc_usable_size>> is not portable. - -Supporting OS subroutines required: <<sbrk>>. */ - -#include <_ansi.h> -#include <reent.h> -#include <stdlib.h> -#include <malloc.h> - -#ifndef _REENT_ONLY - -_PTR -_DEFUN (malloc, (nbytes), - size_t nbytes) /* get a block */ -{ - return _malloc_r (_REENT, nbytes); -} - -void -_DEFUN (free, (aptr), - _PTR aptr) -{ - _free_r (_REENT, aptr); -} - -#endif - -#endif /* ! defined (MALLOC_PROVIDED) */ |