1/** @file
2  Architecture Independent Base Memory Library Implementation.
3
4  The following BaseMemoryLib instances contain the same copy of this file:
5    BaseMemoryLib
6    PeiMemoryLib
7    UefiMemoryLib
8
9  Copyright (c) 2006 - 2009, Intel Corporation. All rights reserved.<BR>
10  This program and the accompanying materials
11  are licensed and made available under the terms and conditions of the BSD License
12  which accompanies this distribution.  The full text of the license may be found at
13  http://opensource.org/licenses/bsd-license.php
14
15  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
16  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
17
18**/
19
20#include "MemLibInternals.h"
21
22/**
23  Fills a target buffer with a 16-bit value, and returns the target buffer.
24
25  @param  Buffer  Pointer to the target buffer to fill.
26  @param  Length  Count of 16-bit value to fill.
27  @param  Value   Value with which to fill Length bytes of Buffer.
28
29  @return Buffer
30
31**/
32VOID *
33EFIAPI
34InternalMemSetMem16 (
35  OUT     VOID                      *Buffer,
36  IN      UINTN                     Length,
37  IN      UINT16                    Value
38  )
39{
40  do {
41    ((UINT16*)Buffer)[--Length] = Value;
42  } while (Length != 0);
43  return Buffer;
44}
45
46/**
47  Fills a target buffer with a 32-bit value, and returns the target buffer.
48
49  @param  Buffer  Pointer to the target buffer to fill.
50  @param  Length  Count of 32-bit value to fill.
51  @param  Value   Value with which to fill Length bytes of Buffer.
52
53  @return Buffer
54
55**/
56VOID *
57EFIAPI
58InternalMemSetMem32 (
59  OUT     VOID                      *Buffer,
60  IN      UINTN                     Length,
61  IN      UINT32                    Value
62  )
63{
64  do {
65    ((UINT32*)Buffer)[--Length] = Value;
66  } while (Length != 0);
67  return Buffer;
68}
69
70/**
71  Fills a target buffer with a 64-bit value, and returns the target buffer.
72
73  @param  Buffer  Pointer to the target buffer to fill.
74  @param  Length  Count of 64-bit value to fill.
75  @param  Value   Value with which to fill Length bytes of Buffer.
76
77  @return Buffer
78
79**/
80VOID *
81EFIAPI
82InternalMemSetMem64 (
83  OUT     VOID                      *Buffer,
84  IN      UINTN                     Length,
85  IN      UINT64                    Value
86  )
87{
88  do {
89    ((UINT64*)Buffer)[--Length] = Value;
90  } while (Length != 0);
91  return Buffer;
92}
93
94/**
95  Set Buffer to 0 for Size bytes.
96
97  @param  Buffer Memory to set.
98  @param  Length Number of bytes to set
99
100  @return Buffer
101
102**/
103VOID *
104EFIAPI
105InternalMemZeroMem (
106  OUT     VOID                      *Buffer,
107  IN      UINTN                     Length
108  )
109{
110  return InternalMemSetMem (Buffer, Length, 0);
111}
112
113/**
114  Compares two memory buffers of a given length.
115
116  @param  DestinationBuffer First memory buffer
117  @param  SourceBuffer      Second memory buffer
118  @param  Length            Length of DestinationBuffer and SourceBuffer memory
119                            regions to compare. Must be non-zero.
120
121  @return 0                 All Length bytes of the two buffers are identical.
122  @retval Non-zero          The first mismatched byte in SourceBuffer subtracted from the first
123                            mismatched byte in DestinationBuffer.
124
125**/
126INTN
127EFIAPI
128InternalMemCompareMem (
129  IN      CONST VOID                *DestinationBuffer,
130  IN      CONST VOID                *SourceBuffer,
131  IN      UINTN                     Length
132  )
133{
134  while ((--Length != 0) &&
135         (*(INT8*)DestinationBuffer == *(INT8*)SourceBuffer)) {
136    DestinationBuffer = (INT8*)DestinationBuffer + 1;
137    SourceBuffer = (INT8*)SourceBuffer + 1;
138  }
139  return (INTN)*(UINT8*)DestinationBuffer - (INTN)*(UINT8*)SourceBuffer;
140}
141
142/**
143  Scans a target buffer for an 8-bit value, and returns a pointer to the
144  matching 8-bit value in the target buffer.
145
146  @param  Buffer  Pointer to the target buffer to scan.
147  @param  Length  Count of 8-bit value to scan. Must be non-zero.
148  @param  Value   Value to search for in the target buffer.
149
150  @return Pointer to the first occurrence or NULL if not found.
151
152**/
153CONST VOID *
154EFIAPI
155InternalMemScanMem8 (
156  IN      CONST VOID                *Buffer,
157  IN      UINTN                     Length,
158  IN      UINT8                     Value
159  )
160{
161  CONST UINT8                       *Pointer;
162
163  Pointer = (CONST UINT8*)Buffer;
164  do {
165    if (*Pointer == Value) {
166      return Pointer;
167    }
168    Pointer++;
169  } while (--Length != 0);
170  return NULL;
171}
172
173/**
174  Scans a target buffer for a 16-bit value, and returns a pointer to the
175  matching 16-bit value in the target buffer.
176
177  @param  Buffer  Pointer to the target buffer to scan.
178  @param  Length  Count of 16-bit value to scan. Must be non-zero.
179  @param  Value   Value to search for in the target buffer.
180
181  @return Pointer to the first occurrence or NULL if not found.
182
183**/
184CONST VOID *
185EFIAPI
186InternalMemScanMem16 (
187  IN      CONST VOID                *Buffer,
188  IN      UINTN                     Length,
189  IN      UINT16                    Value
190  )
191{
192  CONST UINT16                      *Pointer;
193
194  Pointer = (CONST UINT16*)Buffer;
195  do {
196    if (*Pointer == Value) {
197      return Pointer;
198    }
199    Pointer++;
200  } while (--Length != 0);
201  return NULL;
202}
203
204/**
205  Scans a target buffer for a 32-bit value, and returns a pointer to the
206  matching 32-bit value in the target buffer.
207
208  @param  Buffer  Pointer to the target buffer to scan.
209  @param  Length  Count of 32-bit value to scan. Must be non-zero.
210  @param  Value   Value to search for in the target buffer.
211
212  @return Pointer to the first occurrence or NULL if not found.
213
214**/
215CONST VOID *
216EFIAPI
217InternalMemScanMem32 (
218  IN      CONST VOID                *Buffer,
219  IN      UINTN                     Length,
220  IN      UINT32                    Value
221  )
222{
223  CONST UINT32                      *Pointer;
224
225  Pointer = (CONST UINT32*)Buffer;
226  do {
227    if (*Pointer == Value) {
228      return Pointer;
229    }
230    Pointer++;
231  } while (--Length != 0);
232  return NULL;
233}
234
235/**
236  Scans a target buffer for a 64-bit value, and returns a pointer to the
237  matching 64-bit value in the target buffer.
238
239  @param  Buffer  Pointer to the target buffer to scan.
240  @param  Length  Count of 64-bit value to scan. Must be non-zero.
241  @param  Value   Value to search for in the target buffer.
242
243  @return Pointer to the first occurrence or NULL if not found.
244
245**/
246CONST VOID *
247EFIAPI
248InternalMemScanMem64 (
249  IN      CONST VOID                *Buffer,
250  IN      UINTN                     Length,
251  IN      UINT64                    Value
252  )
253{
254  CONST UINT64                      *Pointer;
255
256  Pointer = (CONST UINT64*)Buffer;
257  do {
258    if (*Pointer == Value) {
259      return Pointer;
260    }
261    Pointer++;
262  } while (--Length != 0);
263  return NULL;
264}
265