← Back to branch summary

~linaro-toolchain-dev/cortex-strings/trunk

« back to all changes in this revision

Viewing changes to reference/glibc-c/memset.c

  • Committer: Michael Hope
  • Date: 2012-06-12 03:19:48 UTC
  • Revision ID: michael.hope@linaro.org-20120612031948-4ii8jicywtzjprak
Added the C only routines from GLIBC 2.16+20120607~git24a6dbe

Show diffs side-by-side

added added

removed removed

Lines of Context:
reference/glibc-c/memset.c
 
1
/* Copyright (C) 1991, 1997, 2003 Free Software Foundation, Inc.
 
2
   This file is part of the GNU C Library.
 
3
 
 
4
   The GNU C Library is free software; you can redistribute it and/or
 
5
   modify it under the terms of the GNU Lesser General Public
 
6
   License as published by the Free Software Foundation; either
 
7
   version 2.1 of the License, or (at your option) any later version.
 
8
 
 
9
   The GNU C Library is distributed in the hope that it will be useful,
 
10
   but WITHOUT ANY WARRANTY; without even the implied warranty of
 
11
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 
12
   Lesser General Public License for more details.
 
13
 
 
14
   You should have received a copy of the GNU Lesser General Public
 
15
   License along with the GNU C Library; if not, see
 
16
   <http://www.gnu.org/licenses/>.  */
 
17
 
 
18
#include <string.h>
 
19
#include "memcopy.h"
 
20
 
 
21
#undef memset
 
22
 
 
23
void *
 
24
memset (dstpp, c, len)
 
25
     void *dstpp;
 
26
     int c;
 
27
     size_t len;
 
28
{
 
29
  long int dstp = (long int) dstpp;
 
30
 
 
31
  if (len >= 8)
 
32
    {
 
33
      size_t xlen;
 
34
      op_t cccc;
 
35
 
 
36
      cccc = (unsigned char) c;
 
37
      cccc |= cccc << 8;
 
38
      cccc |= cccc << 16;
 
39
      if (OPSIZ > 4)
 
40
        /* Do the shift in two steps to avoid warning if long has 32 bits.  */
 
41
        cccc |= (cccc << 16) << 16;
 
42
 
 
43
      /* There are at least some bytes to set.
 
44
         No need to test for LEN == 0 in this alignment loop.  */
 
45
      while (dstp % OPSIZ != 0)
 
46
        {
 
47
          ((byte *) dstp)[0] = c;
 
48
          dstp += 1;
 
49
          len -= 1;
 
50
        }
 
51
 
 
52
      /* Write 8 `op_t' per iteration until less than 8 `op_t' remain.  */
 
53
      xlen = len / (OPSIZ * 8);
 
54
      while (xlen > 0)
 
55
        {
 
56
          ((op_t *) dstp)[0] = cccc;
 
57
          ((op_t *) dstp)[1] = cccc;
 
58
          ((op_t *) dstp)[2] = cccc;
 
59
          ((op_t *) dstp)[3] = cccc;
 
60
          ((op_t *) dstp)[4] = cccc;
 
61
          ((op_t *) dstp)[5] = cccc;
 
62
          ((op_t *) dstp)[6] = cccc;
 
63
          ((op_t *) dstp)[7] = cccc;
 
64
          dstp += 8 * OPSIZ;
 
65
          xlen -= 1;
 
66
        }
 
67
      len %= OPSIZ * 8;
 
68
 
 
69
      /* Write 1 `op_t' per iteration until less than OPSIZ bytes remain.  */
 
70
      xlen = len / OPSIZ;
 
71
      while (xlen > 0)
 
72
        {
 
73
          ((op_t *) dstp)[0] = cccc;
 
74
          dstp += OPSIZ;
 
75
          xlen -= 1;
 
76
        }
 
77
      len %= OPSIZ;
 
78
    }
 
79
 
 
80
  /* Write the last few bytes.  */
 
81
  while (len > 0)
 
82
    {
 
83
      ((byte *) dstp)[0] = c;
 
84
      dstp += 1;
 
85
      len -= 1;
 
86
    }
 
87
 
 
88
  return dstpp;
 
89
}