MdePkg/Library/BaseMemoryLib/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   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 **/
 154 CONST VOID *
 155 EFIAPI
 156 InternalMemScanMem8 (
 157   IN      CONST VOID                *Buffer,
 158   IN      UINTN                     Length,
 159   IN      UINT8                     Value
 160   )
 161 {
 162   CONST UINT8                       *Pointer;
 163
 164   ASSERT (Length > 0);
 165   Pointer = (CONST UINT8*)Buffer;
 166   do {
 167     if (*(Pointer++) == Value) {
 168       return Pointer;
 169     }
 170   } while (--Length != 0);
 171   return NULL;
 172 }
 173
 174 /**
 175   Scans a target buffer for a 16-bit value, and returns a pointer to the
 176   matching 16-bit value in the target buffer.
 177
 178   @param  Buffer  Pointer to the target buffer to scan.
 179   @param  Length  Number of bytes in Buffer to scan. Must be non-zero.
 180   @param  Value   Value to search for in the target buffer.
 181
 182   @return Pointer to the first occurrence or NULL if not found.
 183
 184 **/
 185 CONST VOID *
 186 EFIAPI
 187 InternalMemScanMem16 (
 188   IN      CONST VOID                *Buffer,
 189   IN      UINTN                     Length,
 190   IN      UINT16                    Value
 191   )
 192 {
 193   CONST UINT16                      *Pointer;
 194
 195   ASSERT (Length > 0);
 196   Pointer = (CONST UINT16*)Buffer;
 197   do {
 198     if (*(Pointer++) == Value) {
 199       return Pointer;
 200     }
 201   } while (--Length != 0);
 202   return NULL;
 203 }
 204
 205 /**
 206   Scans a target buffer for a 32-bit value, and returns a pointer to the
 207   matching 32-bit value in the target buffer.
 208
 209   @param  Buffer  Pointer to the target buffer to scan.
 210   @param  Length  Number of bytes in Buffer to scan. Must be non-zero.
 211   @param  Value   Value to search for in the target buffer.
 212
 213   @return Pointer to the first occurrence or NULL if not found.
 214
 215 **/
 216 CONST VOID *
 217 EFIAPI
 218 InternalMemScanMem32 (
 219   IN      CONST VOID                *Buffer,
 220   IN      UINTN                     Length,
 221   IN      UINT32                    Value
 222   )
 223 {
 224   CONST UINT32                      *Pointer;
 225
 226   ASSERT (Length > 0);
 227   Pointer = (CONST UINT32*)Buffer;
 228   do {
 229     if (*(Pointer++) == Value) {
 230       return Pointer;
 231     }
 232   } while (--Length != 0);
 233   return NULL;
 234 }
 235
 236 /**
 237   Scans a target buffer for a 64-bit value, and returns a pointer to the
 238   matching 64-bit value in the target buffer.
 239
 240   @param  Buffer  Pointer to the target buffer to scan.
 241   @param  Length  Number of bytes in Buffer to scan. Must be non-zero.
 242   @param  Value   Value to search for in the target buffer.
 243
 244   @return Pointer to the first occurrence or NULL if not found.
 245
 246 **/
 247 CONST VOID *
 248 EFIAPI
 249 InternalMemScanMem64 (
 250   IN      CONST VOID                *Buffer,
 251   IN      UINTN                     Length,
 252   IN      UINT64                    Value
 253   )
 254 {
 255   CONST UINT64                      *Pointer;
 256
 257   ASSERT (Length > 0);
 258   Pointer = (CONST UINT64*)Buffer;
 259   do {
 260     if (*(Pointer++) == Value) {
 261       return Pointer;
 262     }
 263   } while (--Length != 0);
 264   return NULL;
 265 }