MdePkg/Library/PeiMemoryLib/MemLibGeneric.c

   1 /** @file
   2   Architecture Independent Base Memory Library Implementation.
   3
   4   Copyright (c) 2006 - 2008, 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   The following BaseMemoryLib instances contain the same copy of this file:
  14
  15     BaseMemoryLib
  16     PeiMemoryLib
  17     DxeMemoryLib
  18
  19 **/
  20
  21 #include "MemLibInternals.h"
  22
  23 /**
  24   Fills a target buffer with a 16-bit value, and returns the target buffer.
  25
  26   @param  Buffer  Pointer to the target buffer to fill.
  27   @param  Length  Number of bytes in Buffer to fill.
  28   @param  Value   Value with which to fill Length bytes of Buffer.
  29
  30   @return Buffer
  31
  32 **/
  33 VOID *
  34 EFIAPI
  35 InternalMemSetMem16 (
  36   OUT     VOID                      *Buffer,
  37   IN      UINTN                     Length,
  38   IN      UINT16                    Value
  39   )
  40 {
  41   do {
  42     ((UINT16*)Buffer)[--Length] = Value;
  43   } while (Length != 0);
  44   return Buffer;
  45 }
  46
  47 /**
  48   Fills a target buffer with a 32-bit value, and returns the target buffer.
  49
  50   @param  Buffer  Pointer to the target buffer to fill.
  51   @param  Length  Number of bytes in Buffer to fill.
  52   @param  Value   Value with which to fill Length bytes of Buffer.
  53
  54   @return Buffer
  55
  56 **/
  57 VOID *
  58 EFIAPI
  59 InternalMemSetMem32 (
  60   OUT     VOID                      *Buffer,
  61   IN      UINTN                     Length,
  62   IN      UINT32                    Value
  63   )
  64 {
  65   do {
  66     ((UINT32*)Buffer)[--Length] = Value;
  67   } while (Length != 0);
  68   return Buffer;
  69 }
  70
  71 /**
  72   Fills a target buffer with a 64-bit value, and returns the target buffer.
  73
  74   @param  Buffer  Pointer to the target buffer to fill.
  75   @param  Length  Number of bytes in Buffer to fill.
  76   @param  Value   Value with which to fill Length bytes of Buffer.
  77
  78   @return Buffer
  79
  80 **/
  81 VOID *
  82 EFIAPI
  83 InternalMemSetMem64 (
  84   OUT     VOID                      *Buffer,
  85   IN      UINTN                     Length,
  86   IN      UINT64                    Value
  87   )
  88 {
  89   do {
  90     ((UINT64*)Buffer)[--Length] = Value;
  91   } while (Length != 0);
  92   return Buffer;
  93 }
  94
  95 /**
  96   Set Buffer to 0 for Size bytes.
  97
  98   @param  Buffer Memory to set.
  99   @param  Length Number of bytes to set
 100
 101   @return Buffer
 102
 103 **/
 104 VOID *
 105 EFIAPI
 106 InternalMemZeroMem (
 107   OUT     VOID                      *Buffer,
 108   IN      UINTN                     Length
 109   )
 110 {
 111   return InternalMemSetMem (Buffer, Length, 0);
 112 }
 113
 114 /**
 115   Compares two memory buffers of a given length.
 116
 117   @param  DestinationBuffer First memory buffer
 118   @param  SourceBuffer      Second memory buffer
 119   @param  Length            Length of DestinationBuffer and SourceBuffer memory
 120                             regions to compare. Must be non-zero.
 121
 122   @return 0                 All Length bytes of the two buffers are identical.
 123   @retval Non-zero          The first mismatched byte in SourceBuffer subtracted from the first
 124                             mismatched byte in DestinationBuffer.
 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   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 **/
 184 CONST VOID *
 185 EFIAPI
 186 InternalMemScanMem16 (
 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 **/
 214 CONST VOID *
 215 EFIAPI
 216 InternalMemScanMem32 (
 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 **/
 244 CONST VOID *
 245 EFIAPI
 246 InternalMemScanMem64 (
 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 }