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