Return to memset.c CVS log

Up to [local] / sys / lib / libkern

Annotation of sys/lib/libkern/memset.c, Revision 1.1.1.1

1.1       nbrk        1: /*     $OpenBSD: memset.c,v 1.5 2004/08/07 00:38:32 deraadt Exp $      */
                      2: /*     $NetBSD: memset.c,v 1.6 1998/03/27 05:35:47 cgd Exp $   */
                      3:
                      4: /*-
                      5:  * Copyright (c) 1990, 1993
                      6:  *     The Regents of the University of California.  All rights reserved.
                      7:  *
                      8:  * This code is derived from software contributed to Berkeley by
                      9:  * Mike Hibler and Chris Torek.
                     10:  *
                     11:  * Redistribution and use in source and binary forms, with or without
                     12:  * modification, are permitted provided that the following conditions
                     13:  * are met:
                     14:  * 1. Redistributions of source code must retain the above copyright
                     15:  *    notice, this list of conditions and the following disclaimer.
                     16:  * 2. Redistributions in binary form must reproduce the above copyright
                     17:  *    notice, this list of conditions and the following disclaimer in the
                     18:  *    documentation and/or other materials provided with the distribution.
                     19:  * 3. Neither the name of the University nor the names of its contributors
                     20:  *    may be used to endorse or promote products derived from this software
                     21:  *    without specific prior written permission.
                     22:  *
                     23:  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
                     24:  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
                     25:  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
                     26:  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
                     27:  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
                     28:  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
                     29:  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
                     30:  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
                     31:  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
                     32:  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
                     33:  * SUCH DAMAGE.
                     34:  */
                     35:
                     36: #include <sys/cdefs.h>
                     37: #if defined(LIBC_SCCS) && !defined(lint)
                     38: #if 0
                     39: static char sccsid[] = "@(#)memset.c   8.1 (Berkeley) 6/4/93";
                     40: #else
                     41: __RCSID("$NetBSD: memset.c,v 1.6 1998/03/27 05:35:47 cgd Exp $");
                     42: #endif
                     43: #endif /* LIBC_SCCS and not lint */
                     44:
                     45: #include <sys/types.h>
                     46:
                     47: #if !defined(_KERNEL) && !defined(_STANDALONE)
                     48: #include <string.h>
                     49: #include <limits.h>
                     50: #else
                     51: #include <sys/limits.h>
                     52: #include <sys/systm.h>
                     53: #include <lib/libkern/libkern.h>
                     54: #endif
                     55:
                     56: #define        wsize   sizeof(u_int)
                     57: #define        wmask   (wsize - 1)
                     58:
                     59: #ifdef BZERO
                     60: #define        RETURN  return
                     61: #define        VAL     0
                     62: #define        WIDEVAL 0
                     63:
                     64: void
                     65: bzero(void *dst0, size_t length)
                     66: #else
                     67: #define        RETURN  return (dst0)
                     68: #define        VAL     c0
                     69: #define        WIDEVAL c
                     70:
                     71: void *
                     72: memset(void *dst0, int c0, size_t length)
                     73: #endif
                     74: {
                     75:        size_t t;
                     76: #ifndef BZERO
                     77:        u_int c;
                     78: #endif
                     79:        u_char *dst;
                     80:
                     81:        dst = dst0;
                     82:        /*
                     83:         * If not enough words, just fill bytes.  A length >= 2 words
                     84:         * guarantees that at least one of them is `complete' after
                     85:         * any necessary alignment.  For instance:
                     86:         *
                     87:         *      |-----------|-----------|-----------|
                     88:         *      |00|01|02|03|04|05|06|07|08|09|0A|00|
                     89:         *                ^---------------------^
                     90:         *               dst             dst+length-1
                     91:         *
                     92:         * but we use a minimum of 3 here since the overhead of the code
                     93:         * to do word writes is substantial.
                     94:         */
                     95:        if (length < 3 * wsize) {
                     96:                while (length != 0) {
                     97:                        *dst++ = VAL;
                     98:                        --length;
                     99:                }
                    100:                RETURN;
                    101:        }
                    102:
                    103: #ifndef BZERO
                    104:        if ((c = (u_char)c0) != 0) {    /* Fill the word. */
                    105:                c = (c << 8) | c;       /* u_int is 16 bits. */
                    106: #if UINT_MAX > 0xffff
                    107:                c = (c << 16) | c;      /* u_int is 32 bits. */
                    108: #endif
                    109: #if UINT_MAX > 0xffffffff
                    110:                c = (c << 32) | c;      /* u_int is 64 bits. */
                    111: #endif
                    112:        }
                    113: #endif
                    114:        /* Align destination by filling in bytes. */
                    115:        if ((t = (u_long)dst & wmask) != 0) {
                    116:                t = wsize - t;
                    117:                length -= t;
                    118:                do {
                    119:                        *dst++ = VAL;
                    120:                } while (--t != 0);
                    121:        }
                    122:
                    123:        /* Fill words.  Length was >= 2*words so we know t >= 1 here. */
                    124:        t = length / wsize;
                    125:        do {
                    126:                *(u_int *)dst = WIDEVAL;
                    127:                dst += wsize;
                    128:        } while (--t != 0);
                    129:
                    130:        /* Mop up trailing bytes, if any. */
                    131:        t = length & wmask;
                    132:        if (t != 0)
                    133:                do {
                    134:                        *dst++ = VAL;
                    135:                } while (--t != 0);
                    136:        RETURN;
                    137: }