summaryrefslogtreecommitdiff
path: root/EdkCompatibilityPkg/Foundation/Library/EfiCommonLib/Ia32/EfiCopyMem.S
blob: 34487a3719e2221d9cb4d98b112ac1b995ea3b04 (plain)
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
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
#/*++
#
#Copyright (c) 2006, Intel Corporation                                                         
#All rights reserved. This program and the accompanying materials                          
#are licensed and made available under the terms and conditions of the BSD License         
#which accompanies this distribution.  The full text of the license may be found at        
#http://opensource.org/licenses/bsd-license.php                                            
#                                                                                          
#THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     
#WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             
#
#Module Name:
#
#  EfiCopyMem.c
#
#Abstract:
#
#  This is the code that supports IA32-optimized CopyMem service
#
#--*/
#include "EfiBind.h"
#---------------------------------------------------------------------------
    .686: 
    #.MODEL flat,C
    .mmx: 
    .code: 

#---------------------------------------------------------------------------

.globl ASM_PFX(EfiCommonLibCopyMem)

#VOID
#EfiCommonLibCopyMem (
#  IN VOID   *Destination,
#  IN VOID   *Source,
#  IN UINTN  Count
#  )
#/*++
#
#Routine Description:
#
#  Copy Length bytes from Source to Destination.
#
#Arguments:
#
#  Destination - Target of copy
#
#  Source      - Place to copy from
#
#  Length      - Number of bytes to copy
#
#Returns:
#
#  None
#
#--*/
ASM_PFX(EfiCommonLibCopyMem):

  pushl  %ebp
  movl   %esp, %ebp
  pushl  %ecx # reserve space for Scratch Local variable UINT64 MmxSave
  pushl  %ecx
  pushl  %esi
  pushl  %edi

  movl  0x10(%ebp), %ecx  # Count
  movl  0xC(%ebp), %esi  # Source
  movl  8(%ebp), %edi  # Destination

##First off, make sure we have no overlap. That is to say,
##   if (Source == Destination)           => do nothing
##   if (Source + Count <= Destination)   => regular copy
##   if (Destination + Count <= Source)   => regular copy
##   otherwise, do a reverse copy
  movl  %esi, %eax
  addl  %ecx, %eax                    # Source + Count
  cmpl  %edi, %eax
  jle   _StartByteCopy

  movl  %edi, %eax
  addl  %ecx, %eax                    # Dest + Count
  cmpl  %esi, %eax
  jle   _StartByteCopy

  cmpl  %edi, %esi
  je    _CopyMemDone
  jl    _CopyOverlapped               # too bad -- overlaps

  # Pick up misaligned start bytes to get destination pointer 4-byte aligned
_StartByteCopy: 
  cmpl  $0, %ecx
  je    _CopyMemDone                # Count == 0, all done
  movl  %edi, %edx
  andb  $3, %dl                     # check lower 2 bits of address
  testb %dl, %dl
  je    _CopyBlocks                 # already aligned?

  # Copy a byte
  movb  (%esi), %al                 # get byte from Source
  movb  %al, (%edi)                 # write byte to Destination
  decl   %ecx
  incl  %edi
  incl  %esi
  jmp   _StartByteCopy               # back to top of loop

_CopyBlocks: 
  # Compute how many 64-byte blocks we can clear 
  movl  %ecx, %eax                  # get Count in eax
  shrl  $6, %eax                    # convert to 64-byte count
  shll  $6, %eax                    # convert back to bytes
  subl  %eax, %ecx                  # subtract from the original count
  shrl  $6, %eax                    # and this is how many 64-byte blocks

  # If no 64-byte blocks, then skip 
  cmpl  $0, %eax
  je    _CopyRemainingDWords

  # Save mm0 to UINT64 MmxSave
  movq  %mm0, -8(%ebp)

copymmx: 

  movq  %ds:(%esi), %mm0
  movq  %mm0, %ds:(%edi)
  movq  %ds:8(%esi), %mm0
  movq  %mm0, %ds:8(%edi)
  movq  %ds:16(%esi), %mm0
  movq  %mm0, %ds:16(%edi)
  movq  %ds:24(%esi), %mm0
  movq  %mm0, %ds:24(%edi)
  movq  %ds:32(%esi), %mm0
  movq  %mm0, %ds:32(%edi)
  movq  %ds:40(%esi), %mm0
  movq  %mm0, %ds:40(%edi)
  movq  %ds:48(%esi), %mm0
  movq  %mm0, %ds:48(%edi)
  movq  %ds:56(%esi), %mm0
  movq  %mm0, %ds:56(%edi)

  addl  $64, %edi
  addl  $64, %esi
  decl  %eax
  jnz   copymmx

# Restore mm0 from MmxSave
  movq  -8(%ebp), %mm0
  emms                                 # Exit MMX Instruction

  # Copy as many DWORDS as possible
_CopyRemainingDWords: 
  cmpl  $4, %ecx
  jb    _CopyRemainingBytes

  movl  (%esi), %eax                # get data from Source
  movl  %eax, (%edi)                # write byte to Destination
  subl  $4, %ecx                    # decrement Count
  addl  $4, %esi                    # advance Source pointer
  addl  $4, %edi                    # advance Destination pointer
  jmp   _CopyRemainingDWords        # back to top

_CopyRemainingBytes: 
  cmpl  $0, %ecx
  je    _CopyMemDone
  movb  (%esi), %al                 # get byte from Source
  movb  %al, (%edi)                 # write byte to Destination
  decl   %ecx
  incl   %esi
  incl  %edi                     # advance Destination pointer
  jmp   _CopyRemainingBytes         # back to top of loop

  #
  # We do this block if the source and destination buffers overlap. To
  # handle it, copy starting at the end of the source buffer and work
  # your way back. Since this is the atypical case, this code has not
  # been optimized, and thus simply copies bytes.
  #
_CopyOverlapped: 

  # Move the source and destination pointers to the end of the range
  addl  %ecx, %esi                    # Source + Count
  decl   %esi
  addl  %ecx, %edi                    # Dest + Count
  decl   %edi

_CopyOverlappedLoop: 
  cmpl  $0, %ecx
  je    _CopyMemDone
  movb  (%esi), %al                 # get byte from Source
  movb  %al, (%edi)                 # write byte to Destination
  decl   %ecx
  decl   %esi
  decl  %edi
  jmp   _CopyOverlappedLoop         # back to top of loop

_CopyMemDone: 

  popl  %edi
  popl  %esi
  leave
  ret
#EfiCommonLibCopyMem ENDP