0,0 → 1,227 |
/* 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 |
reallocf |
INDEX |
free |
INDEX |
memalign |
INDEX |
malloc_usable_size |
INDEX |
_malloc_r |
INDEX |
_realloc_r |
INDEX |
_reallocf_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 *reallocf(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 *_reallocf_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]>; |
|
char *reallocf(<[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]>; |
|
char *_reallocf_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 <<reallocf>> function behaves just like <<realloc>> except if the |
function is required to allocate new storage and this fails. In this |
case <<reallocf>> will free the original object passed in whereas |
<<realloc>> will not. |
|
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>>, <<_reallocf_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) */ |