[444] | 1 | /* |
---|
| 2 | FUNCTION |
---|
| 3 | <<vec_malloc>>, <<vec_realloc>>, <<vec_free>>---manage vector memory |
---|
| 4 | |
---|
| 5 | INDEX |
---|
| 6 | vec_malloc |
---|
| 7 | INDEX |
---|
| 8 | vec_realloc |
---|
| 9 | INDEX |
---|
| 10 | vec_free |
---|
| 11 | INDEX |
---|
| 12 | _vec_malloc_r |
---|
| 13 | INDEX |
---|
| 14 | _vec_realloc_r |
---|
| 15 | INDEX |
---|
| 16 | _vec_free_r |
---|
| 17 | |
---|
| 18 | SYNOPSIS |
---|
| 19 | #include <stdlib.h> |
---|
| 20 | void *vec_malloc(size_t <[nbytes]>); |
---|
| 21 | void *vec_realloc(void *<[aptr]>, size_t <[nbytes]>); |
---|
| 22 | void vec_free(void *<[aptr]>); |
---|
| 23 | |
---|
| 24 | |
---|
| 25 | void *_vec_malloc_r(void *<[reent]>, size_t <[nbytes]>); |
---|
| 26 | void *_vec_realloc_r(void *<[reent]>, |
---|
| 27 | void *<[aptr]>, size_t <[nbytes]>); |
---|
| 28 | void _vec_free_r(void *<[reent]>, void *<[aptr]>); |
---|
| 29 | |
---|
| 30 | DESCRIPTION |
---|
| 31 | These functions manage a pool of system memory that is 16-byte aligned.. |
---|
| 32 | |
---|
| 33 | Use <<vec_malloc>> to request allocation of an object with at least |
---|
| 34 | <[nbytes]> bytes of storage available and is 16-byte aligned. If the space is |
---|
| 35 | available, <<vec_malloc>> returns a pointer to a newly allocated block as its result. |
---|
| 36 | |
---|
| 37 | If you already have a block of storage allocated by <<vec_malloc>>, but |
---|
| 38 | you no longer need all the space allocated to it, you can make it |
---|
| 39 | smaller by calling <<vec_realloc>> with both the object pointer and the |
---|
| 40 | new desired size as arguments. <<vec_realloc>> guarantees that the |
---|
| 41 | contents of the smaller object match the beginning of the original object. |
---|
| 42 | |
---|
| 43 | Similarly, if you need more space for an object, use <<vec_realloc>> to |
---|
| 44 | request the larger size; again, <<vec_realloc>> guarantees that the |
---|
| 45 | beginning of the new, larger object matches the contents of the |
---|
| 46 | original object. |
---|
| 47 | |
---|
| 48 | When you no longer need an object originally allocated by <<vec_malloc>> |
---|
| 49 | or <<vec_realloc>> (or the related function <<vec_calloc>>), return it to the |
---|
| 50 | memory storage pool by calling <<vec_free>> with the address of the object |
---|
| 51 | as the argument. You can also use <<vec_realloc>> for this purpose by |
---|
| 52 | calling it with <<0>> as the <[nbytes]> argument. |
---|
| 53 | |
---|
| 54 | The alternate functions <<_vec_malloc_r>>, <<_vec_realloc_r>>, <<_vec_free_r>>, |
---|
| 55 | are reentrant versions. The extra argument <[reent]> is a pointer to a reentrancy |
---|
| 56 | structure. |
---|
| 57 | |
---|
| 58 | If you have multiple threads of execution which may call any of these |
---|
| 59 | routines, or if any of these routines may be called reentrantly, then |
---|
| 60 | you must provide implementations of the <<__vec_malloc_lock>> and |
---|
| 61 | <<__vec_malloc_unlock>> functions for your system. See the documentation |
---|
| 62 | for those functions. |
---|
| 63 | |
---|
| 64 | These functions operate by calling the function <<_sbrk_r>> or |
---|
| 65 | <<sbrk>>, which allocates space. You may need to provide one of these |
---|
| 66 | functions for your system. <<_sbrk_r>> is called with a positive |
---|
| 67 | value to allocate more space, and with a negative value to release |
---|
| 68 | previously allocated space if it is no longer required. |
---|
| 69 | @xref{Stubs}. |
---|
| 70 | |
---|
| 71 | RETURNS |
---|
| 72 | <<vec_malloc>> returns a pointer to the newly allocated space, if |
---|
| 73 | successful; otherwise it returns <<NULL>>. If your application needs |
---|
| 74 | to generate empty objects, you may use <<vec_malloc(0)>> for this purpose. |
---|
| 75 | |
---|
| 76 | <<vec_realloc>> returns a pointer to the new block of memory, or <<NULL>> |
---|
| 77 | if a new block could not be allocated. <<NULL>> is also the result |
---|
| 78 | when you use `<<vec_realloc(<[aptr]>,0)>>' (which has the same effect as |
---|
| 79 | `<<vec_free(<[aptr]>)>>'). You should always check the result of |
---|
| 80 | <<vec_realloc>>; successful vec_reallocation is not guaranteed even when |
---|
| 81 | you request a smaller object. |
---|
| 82 | |
---|
| 83 | <<vec_free>> does not return a result. |
---|
| 84 | |
---|
| 85 | PORTABILITY |
---|
| 86 | <<vec_malloc>>, <<vec_realloc>>, and <<vec_free>> are all extensions |
---|
| 87 | specified in the AltiVec Programming Interface Manual. |
---|
| 88 | |
---|
| 89 | Supporting OS subroutines required: <<sbrk>>. */ |
---|
| 90 | |
---|
| 91 | #include <_ansi.h> |
---|
| 92 | #include <reent.h> |
---|
| 93 | #include <stdlib.h> |
---|
| 94 | #include <malloc.h> |
---|
| 95 | |
---|
| 96 | #ifndef _REENT_ONLY |
---|
| 97 | |
---|
| 98 | void * |
---|
| 99 | vec_malloc (size_t nbytes) /* get a block */ |
---|
| 100 | { |
---|
| 101 | return _memalign_r (_REENT, 16, nbytes); |
---|
| 102 | } |
---|
| 103 | |
---|
| 104 | #endif |
---|
| 105 | |
---|