← Back to branch summary

~ubuntu-branches/debian/jessie/arcboot/jessie

« back to all changes in this revision

Viewing changes to arclib/stdlib.c

  • Committer: Bazaar Package Importer
  • Author(s): Guido Guenther
  • Date: 2004-03-02 12:01:14 UTC
  • Revision ID: james.westby@ubuntu.com-20040302120114-0pukal9hlpt3k0l7
Tags: 0.3.8.1
correct subarch detection for IP32

Show diffs side-by-side

added added

removed removed

Lines of Context:
arclib/stdlib.c
 
1
/*
 
2
 * Copyright 1999 Silicon Graphics, Inc.
 
3
 */
 
4
#include "stdlib.h"
 
5
#include "string.h"
 
6
#include "arc.h"
 
7
 
 
8
 
 
9
typedef struct _Node {
 
10
        size_t size;
 
11
        struct _Node *next;
 
12
} Node;
 
13
 
 
14
static Node *freeList = NULL;
 
15
 
 
16
 
 
17
void *malloc(size_t size)
 
18
{
 
19
        Node **free, *mem;
 
20
 
 
21
        size +=
 
22
            /* header */ sizeof(Node) + /* round up */ (sizeof(Node) - 1);
 
23
        size -= size % sizeof(Node);
 
24
 
 
25
        free = &freeList;
 
26
        while ((*free != NULL) && ((*free)->size < size))
 
27
                free = &((*free)->next);
 
28
 
 
29
        mem = *free;
 
30
        if (mem != NULL) {
 
31
                if (mem->size > size) {
 
32
                        Node *split = mem + (size / sizeof(Node));
 
33
 
 
34
                        split->size = mem->size - size;
 
35
                        split->next = mem->next;
 
36
                        mem->size = size;
 
37
                        mem->next = split;
 
38
                }
 
39
                *free = mem->next;
 
40
                mem += 1;
 
41
        }
 
42
 
 
43
        return ((void *) mem);
 
44
}
 
45
 
 
46
 
 
47
void free(void *ptr)
 
48
{
 
49
        if (ptr != NULL) {
 
50
                Node *mem = ((Node *) ptr) - 1;
 
51
                Node **free = &freeList;
 
52
 
 
53
                while ((*free != NULL) && (*free < mem)) {
 
54
                        if (mem ==
 
55
                            (*free + ((*free)->size / sizeof(Node)))) {
 
56
                                (*free)->size += mem->size;
 
57
                                mem = *free;
 
58
                                break;
 
59
                        }
 
60
                        free = &((*free)->next);
 
61
                }
 
62
 
 
63
                if (mem != *free) {
 
64
                        mem->next = *free;
 
65
                        *free = mem;
 
66
                }
 
67
 
 
68
                if (mem->next == (mem + (mem->size / sizeof(Node)))) {
 
69
                        mem->size += mem->next->size;
 
70
                        mem->next = mem->next->next;
 
71
                }
 
72
        }
 
73
}
 
74
 
 
75
 
 
76
void *realloc(void *ptr, size_t size)
 
77
{
 
78
        if (ptr == NULL) {
 
79
                ptr = malloc(size);
 
80
        } else {
 
81
                Node *mem = ((Node *) ptr) - 1;
 
82
 
 
83
                size +=
 
84
                    /* header */ sizeof(Node) +
 
85
                /* round up */ (sizeof(Node) - 1);
 
86
                size -= size % sizeof(Node);
 
87
 
 
88
                if (size > mem->size) {
 
89
                        /* Should try to grow */
 
90
                        void *optr = ptr;
 
91
 
 
92
                        ptr = malloc(size);
 
93
                        if (ptr != NULL) {
 
94
                                memcpy(ptr, optr,
 
95
                                       mem->size - sizeof(Node));
 
96
                                free(optr);
 
97
                        }
 
98
                } else if (size < mem->size) {
 
99
                        Node *split = mem + (size / sizeof(Node));
 
100
 
 
101
                        split->size = mem->size - size;
 
102
                        split->next = mem->next;
 
103
                        mem->size = size;
 
104
                        free((void *) (split + 1));
 
105
                }
 
106
        }
 
107
 
 
108
        return ptr;
 
109
}
 
110
 
 
111
 
 
112
void arclib_malloc_add(ULONG start, ULONG size)
 
113
{
 
114
        Node *node = (Node *) start;
 
115
 
 
116
        node->size = size - (size % sizeof(Node));
 
117
        free((void *) (node + 1));
 
118
}