MdePkg/Library/PeiMemoryLib/MemLibGeneric.c

   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     UefiMemoryLib
  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 **/
  35 VOID *
  36 EFIAPI
  37 InternalMemSetMem16 (
  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 **/
  59 VOID *
  60 EFIAPI
  61 InternalMemSetMem32 (
  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 **/
  83 VOID *
  84 EFIAPI
  85 InternalMemSetMem64 (
  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 **/
 106 VOID *
 107 EFIAPI
 108 InternalMemZeroMem (
 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 **/
 127 INTN
 128 EFIAPI
 129 InternalMemCompareMem (
 130   IN      CONST VOID                *DestinationBuffer,
 131   IN      CONST VOID                *SourceBuffer,
 132   IN      UINTN                     Length
 133   )
 134 {
 135   ASSERT (Length > 0);
 136   while ((--Length != 0) &&
 137          (*(INT8*)DestinationBuffer == *(INT8*)SourceBuffer)) {
 138     DestinationBuffer = (INT8*)DestinationBuffer + 1;
 139     SourceBuffer = (INT8*)SourceBuffer + 1;
 140   }
 141   return (INTN)*(UINT8*)DestinationBuffer - (INTN)*(UINT8*)SourceBuffer;
 142 }
 143
 144 /**
 145   Scans a target buffer for an 8-bit value, and returns a pointer to the
 146   matching 8-bit value in the target buffer.
 147
 148   @param  Buffer  Pointer to the target buffer to scan.
 149   @param  Length  Number of bytes in Buffer to scan. Must be non-zero.
 150   @param  Value   Value to search for in the target buffer.
 151
 152   @return Pointer to the first occurrence or NULL if not found.
 153
 154 **/
 155 CONST VOID *
 156 EFIAPI
 157 InternalMemScanMem8 (
 158   IN      CONST VOID                *Buffer,
 159   IN      UINTN                     Length,
 160   IN      UINT8                     Value
 161   )
 162 {
 163   CONST UINT8                       *Pointer;
 164
 165   ASSERT (Length > 0);
 166   Pointer = (CONST UINT8*)Buffer;
 167   do {
 168     if (*(Pointer++) == Value) {
 169       return Pointer;
 170     }
 171   } while (--Length != 0);
 172   return NULL;
 173 }
 174
 175 /**
 176   Scans a target buffer for a 16-bit value, and returns a pointer to the
 177   matching 16-bit value in the target buffer.
 178
 179   @param  Buffer  Pointer to the target buffer to scan.
 180   @param  Length  Number of bytes in Buffer to scan. Must be non-zero.
 181   @param  Value   Value to search for in the target buffer.
 182
 183   @return Pointer to the first occurrence or NULL if not found.
 184
 185 **/
 186 CONST VOID *
 187 EFIAPI
 188 InternalMemScanMem16 (
 189   IN      CONST VOID                *Buffer,
 190   IN      UINTN                     Length,
 191   IN      UINT16                    Value
 192   )
 193 {
 194   CONST UINT16                      *Pointer;
 195
 196   ASSERT (Length > 0);
 197   Pointer = (CONST UINT16*)Buffer;
 198   do {
 199     if (*(Pointer++) == Value) {
 200       return Pointer;
 201     }
 202   } while (--Length != 0);
 203   return NULL;
 204 }
 205
 206 /**
 207   Scans a target buffer for a 32-bit value, and returns a pointer to the
 208   matching 32-bit value in the target buffer.
 209
 210   @param  Buffer  Pointer to the target buffer to scan.
 211   @param  Length  Number of bytes in Buffer to scan. Must be non-zero.
 212   @param  Value   Value to search for in the target buffer.
 213
 214   @return Pointer to the first occurrence or NULL if not found.
 215
 216 **/
 217 CONST VOID *
 218 EFIAPI
 219 InternalMemScanMem32 (
 220   IN      CONST VOID                *Buffer,
 221   IN      UINTN                     Length,
 222   IN      UINT32                    Value
 223   )
 224 {
 225   CONST UINT32                      *Pointer;
 226
 227   ASSERT (Length > 0);
 228   Pointer = (CONST UINT32*)Buffer;
 229   do {
 230     if (*(Pointer++) == Value) {
 231       return Pointer;
 232     }
 233   } while (--Length != 0);
 234   return NULL;
 235 }
 236
 237 /**
 238   Scans a target buffer for a 64-bit value, and returns a pointer to the
 239   matching 64-bit value in the target buffer.
 240
 241   @param  Buffer  Pointer to the target buffer to scan.
 242   @param  Length  Number of bytes in Buffer to scan. Must be non-zero.
 243   @param  Value   Value to search for in the target buffer.
 244
 245   @return Pointer to the first occurrence or NULL if not found.
 246
 247 **/
 248 CONST VOID *
 249 EFIAPI
 250 InternalMemScanMem64 (
 251   IN      CONST VOID                *Buffer,
 252   IN      UINTN                     Length,
 253   IN      UINT64                    Value
 254   )
 255 {
 256   CONST UINT64                      *Pointer;
 257
 258   ASSERT (Length > 0);
 259   Pointer = (CONST UINT64*)Buffer;
 260   do {
 261     if (*(Pointer++) == Value) {
 262       return Pointer;
 263     }
 264   } while (--Length != 0);
 265   return NULL;
 266 }