← Back to branch summary

~galfy/helenos/bird-port-mainline

« back to all changes in this revision

Viewing changes to kernel/generic/src/lib/memstr.c

  • Committer: Martin Decky
  • Date: 2009-08-04 11:19:19 UTC
  • Revision ID: martin@uranus.dsrg.hide.ms.mff.cuni.cz-20090804111919-evyclddlr3v5lhmp
Initial import

Show diffs side-by-side

added added

removed removed

Lines of Context:
kernel/generic/src/lib/memstr.c
 
1
/*
 
2
 * Copyright (c) 2001-2004 Jakub Jermar
 
3
 * Copyright (c) 2008 Jiri Svoboda
 
4
 * All rights reserved.
 
5
 *
 
6
 * Redistribution and use in source and binary forms, with or without
 
7
 * modification, are permitted provided that the following conditions
 
8
 * are met:
 
9
 *
 
10
 * - Redistributions of source code must retain the above copyright
 
11
 *   notice, this list of conditions and the following disclaimer.
 
12
 * - Redistributions in binary form must reproduce the above copyright
 
13
 *   notice, this list of conditions and the following disclaimer in the
 
14
 *   documentation and/or other materials provided with the distribution.
 
15
 * - The name of the author may not be used to endorse or promote products
 
16
 *   derived from this software without specific prior written permission.
 
17
 *
 
18
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 
19
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 
20
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 
21
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 
22
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 
23
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 
24
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 
25
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 
26
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 
27
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
28
 */
 
29
 
 
30
/** @addtogroup generic 
 
31
 * @{
 
32
 */
 
33
 
 
34
/**
 
35
 * @file
 
36
 * @brief       Memory string operations.
 
37
 *
 
38
 * This file provides architecture independent functions to manipulate blocks of
 
39
 * memory. These functions are optimized as much as generic functions of this
 
40
 * type can be. However, architectures are free to provide even more optimized
 
41
 * versions of these functions.
 
42
 */
 
43
 
 
44
#include <memstr.h>
 
45
#include <arch/types.h>
 
46
#include <align.h>
 
47
 
 
48
/** Copy block of memory.
 
49
 *
 
50
 * Copy cnt bytes from src address to dst address.  The copying is done
 
51
 * word-by-word and then byte-by-byte.  The source and destination memory areas
 
52
 * cannot overlap.
 
53
 *
 
54
 * @param src           Source address to copy from.
 
55
 * @param dst           Destination address to copy to.
 
56
 * @param cnt           Number of bytes to copy.
 
57
 *
 
58
 * @return              Destination address.
 
59
 */
 
60
void *_memcpy(void *dst, const void *src, size_t cnt)
 
61
{
 
62
        unsigned int i, j;
 
63
        
 
64
        if (ALIGN_UP((uintptr_t) src, sizeof(unative_t)) != (uintptr_t) src ||
 
65
            ALIGN_UP((uintptr_t) dst, sizeof(unative_t)) != (uintptr_t) dst) {
 
66
                for (i = 0; i < cnt; i++)
 
67
                        ((uint8_t *) dst)[i] = ((uint8_t *) src)[i];
 
68
        } else { 
 
69
                for (i = 0; i < cnt / sizeof(unative_t); i++)
 
70
                        ((unative_t *) dst)[i] = ((unative_t *) src)[i];
 
71
                
 
72
                for (j = 0; j < cnt % sizeof(unative_t); j++)
 
73
                        ((uint8_t *)(((unative_t *) dst) + i))[j] =
 
74
                            ((uint8_t *)(((unative_t *) src) + i))[j];
 
75
        }
 
76
                
 
77
        return (char *) dst;
 
78
}
 
79
 
 
80
/** Move memory block with possible overlapping.
 
81
 *
 
82
 * Copy cnt bytes from src address to dst address. The source and destination
 
83
 * memory areas may overlap.
 
84
 *
 
85
 * @param src           Source address to copy from.
 
86
 * @param dst           Destination address to copy to.
 
87
 * @param cnt           Number of bytes to copy.
 
88
 *
 
89
 * @return              Destination address.
 
90
 */
 
91
void *memmove(void *dst, const void *src, size_t n)
 
92
{
 
93
        const uint8_t *sp;
 
94
        uint8_t *dp;
 
95
 
 
96
        /* Nothing to do? */
 
97
        if (src == dst)
 
98
                return dst;
 
99
 
 
100
        /* Non-overlapping? */
 
101
        if (dst >= src + n || src >= dst + n) { 
 
102
                return memcpy(dst, src, n);
 
103
        }
 
104
 
 
105
        /* Which direction? */
 
106
        if (src > dst) {
 
107
                /* Forwards. */
 
108
                sp = src;
 
109
                dp = dst;
 
110
 
 
111
                while (n-- != 0)
 
112
                        *dp++ = *sp++;
 
113
        } else {
 
114
                /* Backwards. */
 
115
                sp = src + (n - 1);
 
116
                dp = dst + (n - 1);
 
117
 
 
118
                while (n-- != 0)
 
119
                        *dp-- = *sp--;
 
120
        }
 
121
 
 
122
        return dst;
 
123
}
 
124
 
 
125
/** Fill block of memory
 
126
 *
 
127
 * Fill cnt bytes at dst address with the value x.  The filling is done
 
128
 * byte-by-byte.
 
129
 *
 
130
 * @param dst           Destination address to fill.
 
131
 * @param cnt           Number of bytes to fill.
 
132
 * @param x             Value to fill.
 
133
 *
 
134
 */
 
135
void _memsetb(void *dst, size_t cnt, uint8_t x)
 
136
{
 
137
        unsigned int i;
 
138
        uint8_t *p = (uint8_t *) dst;
 
139
        
 
140
        for (i = 0; i < cnt; i++)
 
141
                p[i] = x;
 
142
}
 
143
 
 
144
/** Fill block of memory.
 
145
 *
 
146
 * Fill cnt words at dst address with the value x.  The filling is done
 
147
 * word-by-word.
 
148
 *
 
149
 * @param dst           Destination address to fill.
 
150
 * @param cnt           Number of words to fill.
 
151
 * @param x             Value to fill.
 
152
 *
 
153
 */
 
154
void _memsetw(void *dst, size_t cnt, uint16_t x)
 
155
{
 
156
        unsigned int i;
 
157
        uint16_t *p = (uint16_t *) dst;
 
158
        
 
159
        for (i = 0; i < cnt; i++)
 
160
                p[i] = x;       
 
161
}
 
162
 
 
163
/** @}
 
164
 */