source: trunk/libs/newlib/src/newlib/libc/machine/visium/memset.c @ 444

Last change on this file since 444 was 444, checked in by satin@…, 6 years ago

add newlib,libalmos-mkh, restructure shared_syscalls.h and mini-libc
File size: 13.9 KB
Line 
1/* memset for the Visium processor.
2
3   Copyright (c) 2015 Rolls-Royce Controls and Data Services Limited.
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 are met:
8
9     * Redistributions of source code must retain the above copyright notice,
10       this list of conditions and the following disclaimer.
11     * Redistributions in binary form must reproduce the above copyright
12       notice, this list of conditions and the following disclaimer in the
13       documentation and/or other materials provided with the distribution.
14     * Neither the name of Rolls-Royce Controls and Data Services Limited nor
15       the names of its contributors may 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 COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
19   AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
20   IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
21   ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
22   LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
23   CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
24   SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
25   INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
26   CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
27   ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
28   THE POSSIBILITY OF SUCH DAMAGE.  */
29
30/* This file must be kept in sync with libgcc/config/visium/memset.c  */
31
32#include <stddef.h>
33#include "memset.h"
34
35#define SET_32_OBJECTS(out)     \
36do {                            \
37  out [0] = m0;                 \
38  out [1] = m0;                 \
39  out [2] = m0;                 \
40  out [3] = m0;                 \
41  out [4] = m0;                 \
42  out [5] = m0;                 \
43  out [6] = m0;                 \
44  out [7] = m0;                 \
45  out [8] = m0;                 \
46  out [9] = m0;                 \
47  out [10] = m0;                \
48  out [11] = m0;                \
49  out [12] = m0;                \
50  out [13] = m0;                \
51  out [14] = m0;                \
52  out [15] = m0;                \
53  out [16] = m0;                \
54  out [17] = m0;                \
55  out [18] = m0;                \
56  out [19] = m0;                \
57  out [20] = m0;                \
58  out [21] = m0;                \
59  out [22] = m0;                \
60  out [23] = m0;                \
61  out [24] = m0;                \
62  out [25] = m0;                \
63  out [26] = m0;                \
64  out [27] = m0;                \
65  out [28] = m0;                \
66  out [29] = m0;                \
67  out [30] = m0;                \
68  out [31] = m0;                \
69  out += 32;                    \
70} while(0)
71
72#define SET_16_OBJECTS(out)     \
73do {                            \
74  out [0] = m0;                 \
75  out [1] = m0;                 \
76  out [2] = m0;                 \
77  out [3] = m0;                 \
78  out [4] = m0;                 \
79  out [5] = m0;                 \
80  out [6] = m0;                 \
81  out [7] = m0;                 \
82  out [8] = m0;                 \
83  out [9] = m0;                 \
84  out [10] = m0;                \
85  out [11] = m0;                \
86  out [12] = m0;                \
87  out [13] = m0;                \
88  out [14] = m0;                \
89  out [15] = m0;                \
90  out += 16;                    \
91} while(0)
92
93#define SET_12_OBJECTS(out)     \
94do {                            \
95  out [0] = m0;                 \
96  out [1] = m0;                 \
97  out [2] = m0;                 \
98  out [3] = m0;                 \
99  out [4] = m0;                 \
100  out [5] = m0;                 \
101  out [6] = m0;                 \
102  out [7] = m0;                 \
103  out [8] = m0;                 \
104  out [9] = m0;                 \
105  out [10] = m0;                \
106  out [11] = m0;                \
107  out += 12;                    \
108} while(0)
109
110#define SET_11_OBJECTS(out)     \
111do {                            \
112  out [0] = m0;                 \
113  out [1] = m0;                 \
114  out [2] = m0;                 \
115  out [3] = m0;                 \
116  out [4] = m0;                 \
117  out [5] = m0;                 \
118  out [6] = m0;                 \
119  out [7] = m0;                 \
120  out [8] = m0;                 \
121  out [9] = m0;                 \
122  out [10] = m0;                \
123  out += 11;                    \
124} while(0)
125
126#define SET_10_OBJECTS(out)     \
127do {                            \
128  out [0] = m0;                 \
129  out [1] = m0;                 \
130  out [2] = m0;                 \
131  out [3] = m0;                 \
132  out [4] = m0;                 \
133  out [5] = m0;                 \
134  out [6] = m0;                 \
135  out [7] = m0;                 \
136  out [8] = m0;                 \
137  out [9] = m0;                 \
138  out += 10;                    \
139} while(0)
140
141#define SET_9_OBJECTS(out)      \
142do {                            \
143  out [0] = m0;                 \
144  out [1] = m0;                 \
145  out [2] = m0;                 \
146  out [3] = m0;                 \
147  out [4] = m0;                 \
148  out [5] = m0;                 \
149  out [6] = m0;                 \
150  out [7] = m0;                 \
151  out [8] = m0;                 \
152  out += 9;                     \
153} while(0)
154
155#define SET_8_OBJECTS(out)      \
156do {                            \
157  out [0] = m0;                 \
158  out [1] = m0;                 \
159  out [2] = m0;                 \
160  out [3] = m0;                 \
161  out [4] = m0;                 \
162  out [5] = m0;                 \
163  out [6] = m0;                 \
164  out [7] = m0;                 \
165  out += 8;                     \
166} while(0)
167
168#define SET_7_OBJECTS(out)      \
169do {                            \
170  out [0] = m0;                 \
171  out [1] = m0;                 \
172  out [2] = m0;                 \
173  out [3] = m0;                 \
174  out [4] = m0;                 \
175  out [5] = m0;                 \
176  out [6] = m0;                 \
177  out += 7;                     \
178} while(0)
179
180#define SET_6_OBJECTS(out)      \
181do {                            \
182  out [0] = m0;                 \
183  out [1] = m0;                 \
184  out [2] = m0;                 \
185  out [3] = m0;                 \
186  out [4] = m0;                 \
187  out [5] = m0;                 \
188  out += 6;                     \
189} while(0)
190
191#define SET_5_OBJECTS(out)      \
192do {                            \
193  out [0] = m0;                 \
194  out [1] = m0;                 \
195  out [2] = m0;                 \
196  out [3] = m0;                 \
197  out [4] = m0;                 \
198  out += 5;                     \
199} while(0)
200
201#define SET_4_OBJECTS(out)      \
202do {                            \
203  out [0] = m0;                 \
204  out [1] = m0;                 \
205  out [2] = m0;                 \
206  out [3] = m0;                 \
207  out += 4;                     \
208} while(0)
209
210#define SET_3_OBJECTS(out)      \
211do {                            \
212  out [0] = m0;                 \
213  out [1] = m0;                 \
214  out [2] = m0;                 \
215  out += 3;                     \
216} while(0)
217
218#define SET_2_OBJECTS(out)      \
219do {                            \
220  out [0] = m0;                 \
221  out [1] = m0;                 \
222  out += 2;                     \
223} while(0)
224
225#define SET_1_OBJECT(out)       \
226do {                            \
227  out [0] = m0;                 \
228  out += 1;                     \
229} while(0)
230
231
232static inline void
233__int_memset (void *__restrict s1, int val, size_t n)
234{
235  int value = n;
236  int loop_var;
237  int *out = s1;
238  int count;
239  int m0 = val;
240
241  /* This code currently give a stall for any value with a 1->2 in the low 5
242     bits, i.e.  1,2, 33,34 ? not acceptable!  */
243  switch (value & 0x1f)
244    {
245    case 0:
246      break;
247    case 1:
248      SET_1_OBJECT (out);
249      break;
250    case 2:
251      SET_2_OBJECTS (out);
252      break;
253    case 3:
254      SET_3_OBJECTS (out);
255      break;
256    case 4:
257      SET_4_OBJECTS (out);
258      break;
259    case 5:
260      SET_5_OBJECTS (out);
261      break;
262    case 6:
263      SET_6_OBJECTS (out);
264      break;
265    case 7:
266      SET_7_OBJECTS (out);
267      break;
268    case 8:
269      SET_8_OBJECTS (out);
270      break;
271    case 9:
272      SET_9_OBJECTS (out);
273      break;
274    case 10:
275      SET_10_OBJECTS (out);
276      break;
277    case 11:
278      SET_11_OBJECTS (out);
279      break;
280    case 12:
281      SET_12_OBJECTS (out);
282      break;
283    case 13:
284      SET_9_OBJECTS (out);
285      SET_4_OBJECTS (out);
286      break;
287    case 14:
288      SET_12_OBJECTS (out);
289      SET_2_OBJECTS (out);
290      break;
291    case 15:
292      SET_11_OBJECTS (out);
293      SET_4_OBJECTS (out);
294      break;
295    case 16:
296      SET_16_OBJECTS (out);
297      break;
298    case 17:
299      SET_11_OBJECTS (out);
300      SET_6_OBJECTS (out);
301      break;
302    case 18:
303      SET_9_OBJECTS (out);
304      SET_9_OBJECTS (out);
305      break;
306    case 19:
307      SET_16_OBJECTS (out);
308      SET_3_OBJECTS (out);
309      break;
310    case 20:
311      SET_16_OBJECTS (out);
312      SET_4_OBJECTS (out);
313      break;
314    case 21:
315      SET_16_OBJECTS (out);
316      SET_5_OBJECTS (out);
317      break;
318    case 22:
319      SET_16_OBJECTS (out);
320      SET_6_OBJECTS (out);
321      break;
322    case 23:
323      SET_16_OBJECTS (out);
324      SET_7_OBJECTS (out);
325      break;
326    case 24:
327      SET_16_OBJECTS (out);
328      SET_8_OBJECTS (out);
329      break;
330    case 25:
331      SET_16_OBJECTS (out);
332      SET_9_OBJECTS (out);
333      break;
334    case 26:
335      SET_16_OBJECTS (out);
336      SET_10_OBJECTS (out);
337      break;
338    case 27:
339      SET_16_OBJECTS (out);
340      SET_11_OBJECTS (out);
341      break;
342    case 28:
343      SET_16_OBJECTS (out);
344      SET_8_OBJECTS (out);
345      SET_4_OBJECTS (out);
346      break;
347    case 29:
348      SET_16_OBJECTS (out);
349      SET_9_OBJECTS (out);
350      SET_4_OBJECTS (out);
351      break;
352    case 30:
353      SET_16_OBJECTS (out);
354      SET_12_OBJECTS (out);
355      SET_2_OBJECTS (out);
356      break;
357    case 31:
358      SET_16_OBJECTS (out);
359      SET_11_OBJECTS (out);
360      SET_4_OBJECTS (out);
361      break;
362    }
363
364  /* This loop governs the asmptoptic behaviour of this algorithm, for long
365     word copies.  */
366  count = value >> 5;
367  for (loop_var = 0; loop_var < count; loop_var++)
368    SET_32_OBJECTS (out);
369}
370
371static inline void
372__short_int_memset (void *__restrict s1, int val, size_t n)
373{
374  int value = n;
375  int loop_var;
376  int short *out = s1;
377  int count;
378  int m0 = val;
379
380  /* This code currently give a stall for any value with a 1->2 in the low 5
381     bits, i.e.  1,2, 33,34 ? not acceptable!  */
382  switch (value & 0x1f)
383    {
384    case 0:
385      break;
386    case 1:
387      SET_1_OBJECT (out);
388      break;
389    case 2:
390      SET_2_OBJECTS (out);
391      break;
392    case 3:
393      SET_3_OBJECTS (out);
394      break;
395    case 4:
396      SET_4_OBJECTS (out);
397      break;
398    case 5:
399      SET_5_OBJECTS (out);
400      break;
401    case 6:
402      SET_6_OBJECTS (out);
403      break;
404    case 7:
405      SET_7_OBJECTS (out);
406      break;
407    case 8:
408      SET_8_OBJECTS (out);
409      break;
410    case 9:
411      SET_9_OBJECTS (out);
412      break;
413    case 10:
414      SET_10_OBJECTS (out);
415      break;
416    case 11:
417      SET_11_OBJECTS (out);
418      break;
419    case 12:
420      SET_12_OBJECTS (out);
421      break;
422    case 13:
423      SET_9_OBJECTS (out);
424      SET_4_OBJECTS (out);
425      break;
426    case 14:
427      SET_12_OBJECTS (out);
428      SET_2_OBJECTS (out);
429      break;
430    case 15:
431      SET_11_OBJECTS (out);
432      SET_4_OBJECTS (out);
433      break;
434    case 16:
435      SET_16_OBJECTS (out);
436      break;
437    case 17:
438      SET_11_OBJECTS (out);
439      SET_6_OBJECTS (out);
440      break;
441    case 18:
442      SET_9_OBJECTS (out);
443      SET_9_OBJECTS (out);
444      break;
445    case 19:
446      SET_16_OBJECTS (out);
447      SET_3_OBJECTS (out);
448      break;
449    case 20:
450      SET_16_OBJECTS (out);
451      SET_4_OBJECTS (out);
452      break;
453    case 21:
454      SET_16_OBJECTS (out);
455      SET_5_OBJECTS (out);
456      break;
457    case 22:
458      SET_16_OBJECTS (out);
459      SET_6_OBJECTS (out);
460      break;
461    case 23:
462      SET_16_OBJECTS (out);
463      SET_7_OBJECTS (out);
464      break;
465    case 24:
466      SET_16_OBJECTS (out);
467      SET_8_OBJECTS (out);
468      break;
469    case 25:
470      SET_16_OBJECTS (out);
471      SET_9_OBJECTS (out);
472      break;
473    case 26:
474      SET_16_OBJECTS (out);
475      SET_10_OBJECTS (out);
476      break;
477    case 27:
478      SET_16_OBJECTS (out);
479      SET_11_OBJECTS (out);
480      break;
481    case 28:
482      SET_16_OBJECTS (out);
483      SET_8_OBJECTS (out);
484      SET_4_OBJECTS (out);
485      break;
486    case 29:
487      SET_16_OBJECTS (out);
488      SET_9_OBJECTS (out);
489      SET_4_OBJECTS (out);
490      break;
491    case 30:
492      SET_16_OBJECTS (out);
493      SET_12_OBJECTS (out);
494      SET_2_OBJECTS (out);
495      break;
496    case 31:
497      SET_16_OBJECTS (out);
498      SET_11_OBJECTS (out);
499      SET_4_OBJECTS (out);
500      break;
501    }
502
503  /* This loop governs the asmptoptic behaviour of this algorithm, for long
504     word copies.  */
505  count = value >> 5;
506  for (loop_var = 0; loop_var < count; loop_var++)
507    SET_32_OBJECTS (out);
508}
509
510static inline void
511__byte_memset (void *__restrict s1, int val, size_t n)
512{
513  int value = n;
514  int loop_var;
515  char *out = s1;
516  int count;
517  int m0 = val;
518
519  /* This code currently give a stall for any value with a 1->2 in the low 5
520     bits, i.e.  1,2, 33,34 ? not acceptable!  */
521  switch (value & 0x1f)
522    {
523    case 0:
524      break;
525    case 1:
526      SET_1_OBJECT (out);
527      break;
528    case 2:
529      SET_2_OBJECTS (out);
530      break;
531    case 3:
532      SET_3_OBJECTS (out);
533      break;
534    case 4:
535      SET_4_OBJECTS (out);
536      break;
537    case 5:
538      SET_5_OBJECTS (out);
539      break;
540    case 6:
541      SET_6_OBJECTS (out);
542      break;
543    case 7:
544      SET_7_OBJECTS (out);
545      break;
546    case 8:
547      SET_8_OBJECTS (out);
548      break;
549    case 9:
550      SET_9_OBJECTS (out);
551      break;
552    case 10:
553      SET_10_OBJECTS (out);
554      break;
555    case 11:
556      SET_11_OBJECTS (out);
557      break;
558    case 12:
559      SET_12_OBJECTS (out);
560      break;
561    case 13:
562      SET_9_OBJECTS (out);
563      SET_4_OBJECTS (out);
564      break;
565    case 14:
566      SET_12_OBJECTS (out);
567      SET_2_OBJECTS (out);
568      break;
569    case 15:
570      SET_11_OBJECTS (out);
571      SET_4_OBJECTS (out);
572      break;
573    case 16:
574      SET_16_OBJECTS (out);
575      break;
576    case 17:
577      SET_11_OBJECTS (out);
578      SET_6_OBJECTS (out);
579      break;
580    case 18:
581      SET_9_OBJECTS (out);
582      SET_9_OBJECTS (out);
583      break;
584    case 19:
585      SET_16_OBJECTS (out);
586      SET_3_OBJECTS (out);
587      break;
588    case 20:
589      SET_16_OBJECTS (out);
590      SET_4_OBJECTS (out);
591      break;
592    case 21:
593      SET_16_OBJECTS (out);
594      SET_5_OBJECTS (out);
595      break;
596    case 22:
597      SET_16_OBJECTS (out);
598      SET_6_OBJECTS (out);
599      break;
600    case 23:
601      SET_16_OBJECTS (out);
602      SET_7_OBJECTS (out);
603      break;
604    case 24:
605      SET_16_OBJECTS (out);
606      SET_8_OBJECTS (out);
607      break;
608    case 25:
609      SET_16_OBJECTS (out);
610      SET_9_OBJECTS (out);
611      break;
612    case 26:
613      SET_16_OBJECTS (out);
614      SET_10_OBJECTS (out);
615      break;
616    case 27:
617      SET_16_OBJECTS (out);
618      SET_11_OBJECTS (out);
619      break;
620    case 28:
621      SET_16_OBJECTS (out);
622      SET_8_OBJECTS (out);
623      SET_4_OBJECTS (out);
624      break;
625    case 29:
626      SET_16_OBJECTS (out);
627      SET_9_OBJECTS (out);
628      SET_4_OBJECTS (out);
629      break;
630    case 30:
631      SET_16_OBJECTS (out);
632      SET_12_OBJECTS (out);
633      SET_2_OBJECTS (out);
634      break;
635    case 31:
636      SET_16_OBJECTS (out);
637      SET_11_OBJECTS (out);
638      SET_4_OBJECTS (out);
639      break;
640    }
641
642  /* This loop governs the asmptoptic behaviour of this algorithm, for long
643     word copies.  */
644  count = value >> 5;
645  for (loop_var = 0; loop_var < count; loop_var++)
646    SET_32_OBJECTS (out);
647}
648
649
650/* Exposed interface.  */
651
652void *
653memset (void *s, int c, size_t n)
654{
655  void *result = s;
656
657  /* None of the following handles setting zero bytes.  */
658  if (n != 0)
659    {
660      unsigned test = (unsigned) s | (unsigned) n;
661
662      if (test & 1)
663        __byte_memset (s, c, n);
664      else if (test & 2)
665        {
666          short int sc = (short int) ((c << 8) + (char) c);
667          __short_int_memset (s, sc, n >> 1);
668        }
669      else
670        {
671          int ic = (c << 24) + ((char) c << 16) + ((char) c << 8) + (char) c;
672          __int_memset (s, ic, n >> 2);
673        }
674    }
675
676  return result;
677}
Note: See TracBrowser for help on using the repository browser.