diff options
author | patacongo <patacongo@42af7a65-404d-4744-a932-0658087f49c3> | 2007-02-27 21:17:21 +0000 |
---|---|---|
committer | patacongo <patacongo@42af7a65-404d-4744-a932-0658087f49c3> | 2007-02-27 21:17:21 +0000 |
commit | 148cde5e982950ad5836fa96baa466de842e1c14 (patch) | |
tree | bf737b367b91c5da81345eb21016b07400d7a72f /nuttx/mm | |
parent | f6b81a790c28d7d36d9de33810df5270c1ebbfd7 (diff) | |
download | px4-nuttx-148cde5e982950ad5836fa96baa466de842e1c14.tar.gz px4-nuttx-148cde5e982950ad5836fa96baa466de842e1c14.tar.bz2 px4-nuttx-148cde5e982950ad5836fa96baa466de842e1c14.zip |
Finally, a clean SDCC compile
git-svn-id: svn://svn.code.sf.net/p/nuttx/code/trunk@20 42af7a65-404d-4744-a932-0658087f49c3
Diffstat (limited to 'nuttx/mm')
-rw-r--r-- | nuttx/mm/Makefile | 2 | ||||
-rw-r--r-- | nuttx/mm/mm_addfreechunk.c | 6 | ||||
-rw-r--r-- | nuttx/mm/mm_calloc.c | 4 | ||||
-rw-r--r-- | nuttx/mm/mm_environment.h | 1 | ||||
-rw-r--r-- | nuttx/mm/mm_free.c | 21 | ||||
-rw-r--r-- | nuttx/mm/mm_initialize.c | 24 | ||||
-rw-r--r-- | nuttx/mm/mm_internal.h | 47 | ||||
-rw-r--r-- | nuttx/mm/mm_mallinfo.c | 34 | ||||
-rw-r--r-- | nuttx/mm/mm_malloc.c | 12 | ||||
-rw-r--r-- | nuttx/mm/mm_memalign.c | 20 | ||||
-rw-r--r-- | nuttx/mm/mm_realloc.c | 38 | ||||
-rw-r--r-- | nuttx/mm/mm_shrinkchunk.c | 18 | ||||
-rw-r--r-- | nuttx/mm/mm_zalloc.c | 4 |
13 files changed, 130 insertions, 101 deletions
diff --git a/nuttx/mm/Makefile b/nuttx/mm/Makefile index ce32beea5..c00a7a2ae 100644 --- a/nuttx/mm/Makefile +++ b/nuttx/mm/Makefile @@ -70,7 +70,7 @@ $(BIN): $(OBJS) depend: .depend clean: - rm -f $(BIN) *.o *~ + rm -f $(BIN) *.o *.asm *.lst *.sym *.adb *~ distclean: clean rm -f Make.dep .depend diff --git a/nuttx/mm/mm_addfreechunk.c b/nuttx/mm/mm_addfreechunk.c index f59b9f59e..c3b74a07d 100644 --- a/nuttx/mm/mm_addfreechunk.c +++ b/nuttx/mm/mm_addfreechunk.c @@ -61,10 +61,10 @@ * ************************************************************/ -void mm_addfreechunk(struct mm_freenode_s *node) +void mm_addfreechunk(FAR struct mm_freenode_s *node) { - struct mm_freenode_s *next; - struct mm_freenode_s *prev; + FAR struct mm_freenode_s *next; + FAR struct mm_freenode_s *prev; /* Convert the size to a nodelist index */ diff --git a/nuttx/mm/mm_calloc.c b/nuttx/mm/mm_calloc.c index de69b881c..6c9db3440 100644 --- a/nuttx/mm/mm_calloc.c +++ b/nuttx/mm/mm_calloc.c @@ -55,9 +55,9 @@ * calloc calculates the size and calls zalloc ************************************************************/ -void *calloc(size_t n, size_t elem_size) +FAR void *calloc(size_t n, size_t elem_size) { - void *ret = NULL; + FAR void *ret = NULL; if (n > 0 && elem_size > 0) { diff --git a/nuttx/mm/mm_environment.h b/nuttx/mm/mm_environment.h index 8d4816bd0..14476957d 100644 --- a/nuttx/mm/mm_environment.h +++ b/nuttx/mm/mm_environment.h @@ -47,6 +47,7 @@ #ifndef MM_TEST # include <nuttx/config.h> +# include <nuttx/compiler.h> # include <sys/types.h> # include <stdlib.h> # include <string.h> diff --git a/nuttx/mm/mm_free.c b/nuttx/mm/mm_free.c index 7fb2a061e..276a734d0 100644 --- a/nuttx/mm/mm_free.c +++ b/nuttx/mm/mm_free.c @@ -62,11 +62,11 @@ * ************************************************************/ -void free(void *mem) +void free(FAR void *mem) { - struct mm_freenode_s *node; - struct mm_freenode_s *prev; - struct mm_freenode_s *next; + FAR struct mm_freenode_s *node; + FAR struct mm_freenode_s *prev; + FAR struct mm_freenode_s *next; /* Protect against attempts to free a NULL reference */ @@ -83,22 +83,22 @@ void free(void *mem) /* Map the memory chunk into a free node */ - node = (struct mm_freenode_s *)((char*)mem - SIZEOF_MM_ALLOCNODE); + node = (FAR struct mm_freenode_s *)((char*)mem - SIZEOF_MM_ALLOCNODE); node->preceding &= ~MM_ALLOC_BIT; /* Check if the following node is free and, if so, merge it */ - next = (struct mm_freenode_s *)((char*)node + node->size); + next = (FAR struct mm_freenode_s *)((char*)node + node->size); if ((next->preceding & MM_ALLOC_BIT) == 0) { - struct mm_allocnode_s *andbeyond; + FAR struct mm_allocnode_s *andbeyond; /* Get the node following the next node (which will * become the new next node). We know that we can never * index past the tail chunk because it is always allocated. */ - andbeyond = (struct mm_allocnode_s*)((char*)next + next->size); + andbeyond = (FAR struct mm_allocnode_s*)((char*)next + next->size); /* Remove the next node. There must be a predecessor, * but there may not be a successor node. @@ -115,14 +115,14 @@ void free(void *mem) node->size += next->size; andbeyond->preceding = node->size | (andbeyond->preceding & MM_ALLOC_BIT); - next = (struct mm_freenode_s *)andbeyond; + next = (FAR struct mm_freenode_s *)andbeyond; } /* Check if the preceding node is also free and, if so, merge * it with this node */ - prev = (struct mm_freenode_s *)((char*)node - node->preceding); + prev = (FAR struct mm_freenode_s *)((char*)node - node->preceding); if ((prev->preceding & MM_ALLOC_BIT) == 0) { /* Remove the node. There must be a predecessor, but there may @@ -146,6 +146,5 @@ void free(void *mem) /* Add the merged node to the nodelist */ mm_addfreechunk(node); - mm_givesemaphore(); } diff --git a/nuttx/mm/mm_initialize.c b/nuttx/mm/mm_initialize.c index 4bf24a70b..6d16a5677 100644 --- a/nuttx/mm/mm_initialize.c +++ b/nuttx/mm/mm_initialize.c @@ -50,19 +50,19 @@ /* This is the size of the heap provided to mm */ -size_t g_heapsize; +size_t g_heapsize; /* This is the first and last nodes of the heap */ -struct mm_allocnode_s *g_heapstart; -struct mm_allocnode_s *g_heapend; +FAR struct mm_allocnode_s *g_heapstart; +FAR struct mm_allocnode_s *g_heapend; /* All free nodes are maintained in a doubly linked list. This * array provides some hooks into the list at various points to * speed searches for free nodes. */ -struct mm_freenode_s g_nodelist[MM_NNODES]; +FAR struct mm_freenode_s g_nodelist[MM_NNODES]; /************************************************************ * Public Functions @@ -85,9 +85,11 @@ struct mm_freenode_s g_nodelist[MM_NNODES]; * ************************************************************/ -void mm_initialize(void *heapstart, size_t heapsize) +void mm_initialize(FAR void *heapstart, size_t heapsize) { - struct mm_freenode_s *node; + FAR struct mm_freenode_s *node; + size_t heapbase; + size_t heapend; int i; CHECK_ALLOCNODE_SIZE; @@ -97,8 +99,8 @@ void mm_initialize(void *heapstart, size_t heapsize) * both aligned with the MM_MIN_CHUNK size. */ - size_t heapbase = MM_ALIGN_UP((size_t)heapstart); - size_t heapend = MM_ALIGN_DOWN((size_t)heapstart + (size_t)heapsize); + heapbase = MM_ALIGN_UP((size_t)heapstart); + heapend = MM_ALIGN_DOWN((size_t)heapstart + (size_t)heapsize); /* Save the size of the heap */ @@ -121,15 +123,15 @@ void mm_initialize(void *heapstart, size_t heapsize) * all available memory. */ - g_heapstart = (struct mm_allocnode_s *)heapbase; + g_heapstart = (FAR struct mm_allocnode_s *)heapbase; g_heapstart->size = SIZEOF_MM_ALLOCNODE; g_heapstart->preceding = MM_ALLOC_BIT; - node = (struct mm_freenode_s *)(heapbase + SIZEOF_MM_ALLOCNODE); + node = (FAR struct mm_freenode_s *)(heapbase + SIZEOF_MM_ALLOCNODE); node->size = g_heapsize - 2*SIZEOF_MM_ALLOCNODE; node->preceding = SIZEOF_MM_ALLOCNODE; - g_heapend = (struct mm_allocnode_s *)(heapend - SIZEOF_MM_ALLOCNODE); + g_heapend = (FAR struct mm_allocnode_s *)(heapend - SIZEOF_MM_ALLOCNODE); g_heapend->size = SIZEOF_MM_ALLOCNODE; g_heapend->preceding = node->size | MM_ALLOC_BIT; diff --git a/nuttx/mm/mm_internal.h b/nuttx/mm/mm_internal.h index 27c9f1f3b..e1b9f9beb 100644 --- a/nuttx/mm/mm_internal.h +++ b/nuttx/mm/mm_internal.h @@ -120,14 +120,14 @@ struct mm_allocnode_s struct mm_freenode_s { - size_t size; /* Size of this chunk */ - size_t preceding; /* Size of the preceding chunk */ - struct mm_freenode_s *flink; /* Supports a doubly linked list */ - struct mm_freenode_s *blink; + size_t size; /* Size of this chunk */ + size_t preceding; /* Size of the preceding chunk */ + FAR struct mm_freenode_s *flink; /* Supports a doubly linked list */ + FAR struct mm_freenode_s *blink; }; #ifdef CONFIG_SMALL_MEMORY -# define SIZEOF_MM_FREENODE 10 +# define SIZEOF_MM_FREENODE 8 #else # define SIZEOF_MM_FREENODE 16 #endif @@ -160,15 +160,15 @@ extern size_t g_heapsize; /* This is the first and last nodes of the heap */ -extern struct mm_allocnode_s *g_heapstart; -extern struct mm_allocnode_s *g_heapend; +extern FAR struct mm_allocnode_s *g_heapstart; +extern FAR struct mm_allocnode_s *g_heapend; /* All free nodes are maintained in a doubly linked list. This * array provides some hooks into the list at various points to * speed searches for free nodes. */ -extern struct mm_freenode_s g_nodelist[MM_NNODES]; +extern FAR struct mm_freenode_s g_nodelist[MM_NNODES]; /************************************************************ * Pulblic Function Prototypes @@ -177,23 +177,28 @@ extern struct mm_freenode_s g_nodelist[MM_NNODES]; /* Normally defined in malloc.h */ #ifdef MM_TEST - extern void *mm_malloc(size_t); - extern void mm_free(void*); - extern void *mm_realloc(void*, size_t); - extern void *mm_memalign(size_t, size_t); - extern void *mm_zalloc(size_t); - extern void *mm_calloc(size_t, size_t); + extern FAR void *mm_malloc(size_t); + extern void mm_free(void*); + extern FAR void *mm_realloc(void*, size_t); + extern FAR void *mm_memalign(size_t, size_t); + extern FAR void *mm_zalloc(size_t); + extern FAR void *mm_calloc(size_t, size_t); +#ifdef CONFIG_CAN_PASS_STRUCTS extern struct mallinfo mallinfo(void); +#else + extern int mallinfo(struct mallinfo *info); +#endif #endif -extern void mm_shrinkchunk(struct mm_allocnode_s *node, size_t size); -extern void mm_addfreechunk(struct mm_freenode_s *node); -extern int mm_size2ndx(size_t size); -extern void mm_seminitialize(void); -extern void mm_takesemaphore(void); -extern void mm_givesemaphore(void); +extern void mm_shrinkchunk(FAR struct mm_allocnode_s *node, + size_t size); +extern void mm_addfreechunk(FAR struct mm_freenode_s *node); +extern int mm_size2ndx(size_t size); +extern void mm_seminitialize(void); +extern void mm_takesemaphore(void); +extern void mm_givesemaphore(void); #ifdef MM_TEST - extern int mm_getsemaphore(void); + extern int mm_getsemaphore(void); #endif #endif /* __MM_INTERNAL_H */ diff --git a/nuttx/mm/mm_mallinfo.c b/nuttx/mm/mm_mallinfo.c index 4aba9770c..68c2a7bb7 100644 --- a/nuttx/mm/mm_mallinfo.c +++ b/nuttx/mm/mm_mallinfo.c @@ -65,15 +65,26 @@ * ************************************************************/ +#ifdef CONFIG_CAN_PASS_STRUCTS struct mallinfo mallinfo(void) +#else +int mallinfo(struct mallinfo *info) +#endif { - static struct mallinfo stats; struct mm_allocnode_s *node; size_t mxordblk = 0; int ordblks = 0; /* Number of non-inuse chunks */ size_t uordblks = 0; /* Total allocated space */ size_t fordblks = 0; /* Total non-inuse space */ +#ifdef CONFIG_CAN_PASS_STRUCTS + static struct mallinfo info; +#else + if (!info) + { + return ERROR; + } +#endif /* Visit each node in physical memory */ for (node = g_heapstart; @@ -99,10 +110,19 @@ struct mallinfo mallinfo(void) uordblks += SIZEOF_MM_ALLOCNODE; /* account for the tail node */ DEBUGASSERT(uordblks + fordblks == g_heapsize); - stats.arena = g_heapsize; - stats.ordblks = ordblks; - stats.mxordblk = mxordblk; - stats.uordblks = uordblks; - stats.fordblks = fordblks; - return stats; +#ifdef CONFIG_CAN_PASS_STRUCTS + info.arena = g_heapsize; + info.ordblks = ordblks; + info.mxordblk = mxordblk; + info.uordblks = uordblks; + info.fordblks = fordblks; + return info; +#else + info->arena = g_heapsize; + info->ordblks = ordblks; + info->mxordblk = mxordblk; + info->uordblks = uordblks; + info->fordblks = fordblks; + return OK; +#endif } diff --git a/nuttx/mm/mm_malloc.c b/nuttx/mm/mm_malloc.c index 80a89222b..05c0f73c8 100644 --- a/nuttx/mm/mm_malloc.c +++ b/nuttx/mm/mm_malloc.c @@ -85,9 +85,9 @@ * ************************************************************/ -void *malloc(size_t size) +FAR void *malloc(size_t size) { - struct mm_freenode_s *node; + FAR struct mm_freenode_s *node; void *ret = NULL; int ndx; @@ -142,8 +142,8 @@ void *malloc(size_t size) if (node) { - struct mm_freenode_s *remainder; - struct mm_freenode_s *next; + FAR struct mm_freenode_s *remainder; + FAR struct mm_freenode_s *next; size_t remaining; /* Remove the node. There must be a predecessor, but there may @@ -169,11 +169,11 @@ void *malloc(size_t size) { /* Get a pointer to the next node in physical memory */ - next = (struct mm_freenode_s*)(((char*)node) + node->size); + next = (FAR struct mm_freenode_s*)(((char*)node) + node->size); /* Create the remainder node */ - remainder = (struct mm_freenode_s*)(((char*)node) + size); + remainder = (FAR struct mm_freenode_s*)(((char*)node) + size); remainder->size = remaining; remainder->preceding = size; diff --git a/nuttx/mm/mm_memalign.c b/nuttx/mm/mm_memalign.c index 1f5c07727..7ac192d9c 100644 --- a/nuttx/mm/mm_memalign.c +++ b/nuttx/mm/mm_memalign.c @@ -63,9 +63,9 @@ * ************************************************************/ -void *memalign(size_t alignment, size_t size) +FAR void *memalign(size_t alignment, size_t size) { - struct mm_allocnode_s *node; + FAR struct mm_allocnode_s *node; size_t rawchunk; size_t alignedchunk; size_t mask = (size_t)(alignment - 1); @@ -115,7 +115,7 @@ void *memalign(size_t alignment, size_t size) * node after the allocation. */ - node = (struct mm_allocnode_s*)(rawchunk - SIZEOF_MM_ALLOCNODE); + node = (FAR struct mm_allocnode_s*)(rawchunk - SIZEOF_MM_ALLOCNODE); /* Find the aligned subregion */ @@ -125,13 +125,13 @@ void *memalign(size_t alignment, size_t size) if (alignedchunk != rawchunk) { - struct mm_allocnode_s *newnode; - struct mm_allocnode_s *next; + FAR struct mm_allocnode_s *newnode; + FAR struct mm_allocnode_s *next; size_t precedingsize; /* Get the node the next node after the allocation. */ - next = (struct mm_allocnode_s*)((char*)node + node->size); + next = (FAR struct mm_allocnode_s*)((char*)node + node->size); /* Make sure that there is space to convert the preceding mm_allocnode_s * into an mm_freenode_s. I think that this should always be true @@ -139,7 +139,7 @@ void *memalign(size_t alignment, size_t size) DEBUGASSERT(alignedchunk >= rawchunk + 8); - newnode = (struct mm_allocnode_s*)(alignedchunk - SIZEOF_MM_ALLOCNODE); + newnode = (FAR struct mm_allocnode_s*)(alignedchunk - SIZEOF_MM_ALLOCNODE); /* Preceding size is full size of the new 'node,' including * SIZEOF_MM_ALLOCNODE @@ -158,7 +158,7 @@ void *memalign(size_t alignment, size_t size) if (precedingsize < SIZEOF_MM_FREENODE) { alignedchunk += alignment; - newnode = (struct mm_allocnode_s*)(alignedchunk - SIZEOF_MM_ALLOCNODE); + newnode = (FAR struct mm_allocnode_s*)(alignedchunk - SIZEOF_MM_ALLOCNODE); precedingsize = (size_t)newnode - (size_t)node; } @@ -184,7 +184,7 @@ void *memalign(size_t alignment, size_t size) /* Add the original, newly freed node to the free nodelist */ - mm_addfreechunk((struct mm_freenode_s *)node); + mm_addfreechunk((FAR struct mm_freenode_s *)node); /* Replace the original node with the newlay realloaced, * aligned node @@ -206,5 +206,5 @@ void *memalign(size_t alignment, size_t size) } mm_givesemaphore(); - return (void*)alignedchunk; + return (FAR void*)alignedchunk; } diff --git a/nuttx/mm/mm_realloc.c b/nuttx/mm/mm_realloc.c index b288e880a..52dd56bb7 100644 --- a/nuttx/mm/mm_realloc.c +++ b/nuttx/mm/mm_realloc.c @@ -73,11 +73,11 @@ * ************************************************************/ -void *realloc(void *oldmem, size_t size) +FAR void *realloc(FAR void *oldmem, size_t size) { - struct mm_allocnode_s *oldnode; - struct mm_freenode_s *prev; - struct mm_freenode_s *next; + FAR struct mm_allocnode_s *oldnode; + FAR struct mm_freenode_s *prev; + FAR struct mm_freenode_s *next; size_t oldsize; size_t prevsize = 0; size_t nextsize = 0; @@ -106,7 +106,7 @@ void *realloc(void *oldmem, size_t size) /* Map the memory chunk into an allocated node structure */ - oldnode = (struct mm_allocnode_s *)((char*)oldmem - SIZEOF_MM_ALLOCNODE); + oldnode = (FAR struct mm_allocnode_s *)((FAR char*)oldmem - SIZEOF_MM_ALLOCNODE); /* We need to hold the MM semaphore while we muck with the * nodelist. @@ -129,13 +129,13 @@ void *realloc(void *oldmem, size_t size) * the best decision */ - next = (struct mm_freenode_s *)((char*)oldnode + oldnode->size); + next = (FAR struct mm_freenode_s *)((FAR char*)oldnode + oldnode->size); if ((next->preceding & MM_ALLOC_BIT) == 0) { nextsize = next->size; } - prev = (struct mm_freenode_s *)((char*)oldnode - (oldnode->preceding & ~MM_ALLOC_BIT)); + prev = (FAR struct mm_freenode_s *)((FAR char*)oldnode - (oldnode->preceding & ~MM_ALLOC_BIT)); if ((prev->preceding & MM_ALLOC_BIT) == 0) { prevsize = prev->size; @@ -145,9 +145,9 @@ void *realloc(void *oldmem, size_t size) if (nextsize + prevsize + oldsize >= size) { - size_t needed = size - oldsize; - size_t takeprev; - size_t takenext; + size_t needed = size - oldsize; + size_t takeprev = 0; + size_t takenext = 0; /* Check if we can extend into the previous chunk and if the * previous chunk is smaller than the next chunk. @@ -207,7 +207,7 @@ void *realloc(void *oldmem, size_t size) if (takeprev) { - struct mm_allocnode_s *newnode; + FAR struct mm_allocnode_s *newnode; /* Remove the previous node. There must be a predecessor, * but there may not be a successor node. @@ -222,7 +222,7 @@ void *realloc(void *oldmem, size_t size) /* Extend the node into the previous free chunk */ - newnode = (struct mm_allocnode_s *)((char*)oldnode - takeprev); + newnode = (FAR struct mm_allocnode_s *)((FAR char*)oldnode - takeprev); /* Did we consume the entire preceding chunk? */ @@ -261,12 +261,12 @@ void *realloc(void *oldmem, size_t size) if (takenext) { - struct mm_freenode_s *newnode; - struct mm_allocnode_s *andbeyond; + FAR struct mm_freenode_s *newnode; + FAR struct mm_allocnode_s *andbeyond; /* Get the chunk following the next node (which could be the tail chunk) */ - andbeyond = (struct mm_allocnode_s*)((char*)next + nextsize); + andbeyond = (FAR struct mm_allocnode_s*)((char*)next + nextsize); /* Remove the next node. There must be a predecessor, * but there may not be a successor node. @@ -282,7 +282,7 @@ void *realloc(void *oldmem, size_t size) /* Extend the node into the previous next chunk */ oldnode->size = oldsize + takenext; - newnode = (struct mm_freenode_s *)((char*)oldnode + oldnode->size); + newnode = (FAR struct mm_freenode_s *)((char*)oldnode + oldnode->size); /* Did we consume the entire preceding chunk? */ @@ -310,19 +310,21 @@ void *realloc(void *oldmem, size_t size) mm_givesemaphore(); - return (void*)((char*)oldnode + SIZEOF_MM_ALLOCNODE); + return (FAR void*)((FAR char*)oldnode + SIZEOF_MM_ALLOCNODE); } /* The current chunk cannot be extended. Just allocate a new chunk and copy */ else { + FAR void *newmem; + /* Allocate a new block. On failure, realloc must return NULL but * leave the original memory in place. */ mm_givesemaphore(); - char *newmem = (char*)malloc(size); + newmem = (FAR void*)malloc(size); if (newmem) { memcpy(newmem, oldmem, oldsize); diff --git a/nuttx/mm/mm_shrinkchunk.c b/nuttx/mm/mm_shrinkchunk.c index 8869f045c..4612c426d 100644 --- a/nuttx/mm/mm_shrinkchunk.c +++ b/nuttx/mm/mm_shrinkchunk.c @@ -64,24 +64,24 @@ * ************************************************************/ -void mm_shrinkchunk(struct mm_allocnode_s *node, size_t size) +void mm_shrinkchunk(FAR struct mm_allocnode_s *node, size_t size) { - struct mm_freenode_s *next; + FAR struct mm_freenode_s *next; /* Get a reference to the next node */ - next = (struct mm_freenode_s*)((char*)node + node->size); + next = (FAR struct mm_freenode_s*)((char*)node + node->size); /* Check if it is free */ if ((next->preceding & MM_ALLOC_BIT) == 0) { - struct mm_allocnode_s *andbeyond; - struct mm_freenode_s *newnode; + FAR struct mm_allocnode_s *andbeyond; + FAR struct mm_freenode_s *newnode; /* Get the chunk next the next node (which could be the tail chunk) */ - andbeyond = (struct mm_allocnode_s*)((char*)next + next->size); + andbeyond = (FAR struct mm_allocnode_s*)((char*)next + next->size); /* Remove the next node. There must be a predecessor, but there may * not be a successor node. @@ -98,7 +98,7 @@ void mm_shrinkchunk(struct mm_allocnode_s *node, size_t size) * and the tailing memory from the aligned chunk. */ - newnode = (struct mm_freenode_s*)((char*)node + size); + newnode = (FAR struct mm_freenode_s*)((char*)node + size); /* Set up the size of the new node */ @@ -118,13 +118,13 @@ void mm_shrinkchunk(struct mm_allocnode_s *node, size_t size) else if (node->size >= size + SIZEOF_MM_FREENODE) { - struct mm_freenode_s *newnode; + FAR struct mm_freenode_s *newnode; /* Create a new chunk that will hold both the next chunk * and the tailing memory from the aligned chunk. */ - newnode = (struct mm_freenode_s*)((char*)node + size); + newnode = (FAR struct mm_freenode_s*)((char*)node + size); /* Set up the size of the new node */ diff --git a/nuttx/mm/mm_zalloc.c b/nuttx/mm/mm_zalloc.c index a26992b00..270839cac 100644 --- a/nuttx/mm/mm_zalloc.c +++ b/nuttx/mm/mm_zalloc.c @@ -56,9 +56,9 @@ * ************************************************************/ -void *zalloc(size_t size) +FAR void *zalloc(size_t size) { - void *alloc = malloc(size); + FAR void *alloc = malloc(size); if (alloc) { memset(alloc, 0, size); |