1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
| /* memcpy.S: optimised assembly memcpy
| *
| * Copyright (C) 2003 Red Hat, Inc. All Rights Reserved.
| * Written by David Howells (dhowells@redhat.com)
| *
| * This program is free software; you can redistribute it and/or
| * modify it under the terms of the GNU General Public License
| * as published by the Free Software Foundation; either version
| * 2 of the License, or (at your option) any later version.
| */
|
|
| .text
| .p2align 4
|
| ###############################################################################
| #
| # void *memcpy(void *to, const char *from, size_t count)
| #
| # - NOTE: must not use any stack. exception detection performs function return
| # to caller's fixup routine, aborting the remainder of the copy
| #
| ###############################################################################
| .globl memcpy,__memcpy_end
| .type memcpy,@function
| memcpy:
| or.p gr8,gr9,gr4
| orcc gr10,gr0,gr0,icc3
| or.p gr10,gr4,gr4
| beqlr icc3,#0
|
| # optimise based on best common alignment for to, from & count
| andicc.p gr4,#0x0f,gr0,icc0
| setlos #8,gr11
| andicc.p gr4,#0x07,gr0,icc1
| beq icc0,#0,memcpy_16
| andicc.p gr4,#0x03,gr0,icc0
| beq icc1,#0,memcpy_8
| andicc.p gr4,#0x01,gr0,icc1
| beq icc0,#0,memcpy_4
| setlos.p #1,gr11
| beq icc1,#0,memcpy_2
|
| # do byte by byte copy
| sub.p gr8,gr11,gr3
| sub gr9,gr11,gr9
| 0: ldubu.p @(gr9,gr11),gr4
| subicc gr10,#1,gr10,icc0
| stbu.p gr4,@(gr3,gr11)
| bne icc0,#2,0b
| bralr
|
| # do halfword by halfword copy
| memcpy_2:
| setlos #2,gr11
| sub.p gr8,gr11,gr3
| sub gr9,gr11,gr9
| 0: lduhu.p @(gr9,gr11),gr4
| subicc gr10,#2,gr10,icc0
| sthu.p gr4,@(gr3,gr11)
| bne icc0,#2,0b
| bralr
|
| # do word by word copy
| memcpy_4:
| setlos #4,gr11
| sub.p gr8,gr11,gr3
| sub gr9,gr11,gr9
| 0: ldu.p @(gr9,gr11),gr4
| subicc gr10,#4,gr10,icc0
| stu.p gr4,@(gr3,gr11)
| bne icc0,#2,0b
| bralr
|
| # do double-word by double-word copy
| memcpy_8:
| sub.p gr8,gr11,gr3
| sub gr9,gr11,gr9
| 0: lddu.p @(gr9,gr11),gr4
| subicc gr10,#8,gr10,icc0
| stdu.p gr4,@(gr3,gr11)
| bne icc0,#2,0b
| bralr
|
| # do quad-word by quad-word copy
| memcpy_16:
| sub.p gr8,gr11,gr3
| sub gr9,gr11,gr9
| 0: lddu @(gr9,gr11),gr4
| lddu.p @(gr9,gr11),gr6
| subicc gr10,#16,gr10,icc0
| stdu gr4,@(gr3,gr11)
| stdu.p gr6,@(gr3,gr11)
| bne icc0,#2,0b
| bralr
| __memcpy_end:
|
| .size memcpy, __memcpy_end-memcpy
|
| ###############################################################################
| #
| # copy to/from userspace
| # - return the number of bytes that could not be copied (0 on complete success)
| #
| # long __memcpy_user(void *dst, const void *src, size_t count)
| #
| ###############################################################################
| .globl __memcpy_user, __memcpy_user_error_lr, __memcpy_user_error_handler
| .type __memcpy_user,@function
| __memcpy_user:
| movsg lr,gr7
| subi.p sp,#8,sp
| add gr8,gr10,gr6 ; calculate expected end address
| stdi gr6,@(sp,#0)
|
| # abuse memcpy to do the dirty work
| call memcpy
| __memcpy_user_error_lr:
| ldi.p @(sp,#4),gr7
| setlos #0,gr8
| jmpl.p @(gr7,gr0)
| addi sp,#8,sp
|
| # deal any exception generated by memcpy
| # GR8 - memcpy's current dest address
| # GR11 - memset's step value (index register for store insns)
| __memcpy_user_error_handler:
| lddi.p @(sp,#0),gr4 ; load GR4 with dst+count, GR5 with ret addr
| add gr11,gr3,gr7
| sub.p gr4,gr7,gr8
|
| addi sp,#8,sp
| jmpl @(gr5,gr0)
|
| .size __memcpy_user, .-__memcpy_user
|
|
