MdePkg/Library/BaseLib/Unaligned.c

   1 /** @file
   2   Unaligned access functions of BaseLib.
   3
   4   Copyright (c) 2006 - 2010, Intel Corporation. All rights reserved.<BR>
   5   SPDX-License-Identifier: BSD-2-Clause-Patent
   6
   7 **/
   8
   9
  10 #include "BaseLibInternals.h"
  11
  12
  13 /**
  14   Reads a 16-bit value from memory that may be unaligned.
  15
  16   This function returns the 16-bit value pointed to by Buffer. The function
  17   guarantees that the read operation does not produce an alignment fault.
  18
  19   If the Buffer is NULL, then ASSERT().
  20
  21   @param  Buffer  A pointer to a 16-bit value that may be unaligned.
  22
  23   @return The 16-bit value read from Buffer.
  24
  25 **/
  26 UINT16
  27 EFIAPI
  28 ReadUnaligned16 (
  29   IN CONST UINT16              *Buffer
  30   )
  31 {
  32   ASSERT (Buffer != NULL);
  33
  34   return *Buffer;
  35 }
  36
  37 /**
  38   Writes a 16-bit value to memory that may be unaligned.
  39
  40   This function writes the 16-bit value specified by Value to Buffer. Value is
  41   returned. The function guarantees that the write operation does not produce
  42   an alignment fault.
  43
  44   If the Buffer is NULL, then ASSERT().
  45
  46   @param  Buffer  A pointer to a 16-bit value that may be unaligned.
  47   @param  Value   16-bit value to write to Buffer.
  48
  49   @return The 16-bit value to write to Buffer.
  50
  51 **/
  52 UINT16
  53 EFIAPI
  54 WriteUnaligned16 (
  55   OUT UINT16                    *Buffer,
  56   IN  UINT16                    Value
  57   )
  58 {
  59   ASSERT (Buffer != NULL);
  60
  61   return *Buffer = Value;
  62 }
  63
  64 /**
  65   Reads a 24-bit value from memory that may be unaligned.
  66
  67   This function returns the 24-bit value pointed to by Buffer. The function
  68   guarantees that the read operation does not produce an alignment fault.
  69
  70   If the Buffer is NULL, then ASSERT().
  71
  72   @param  Buffer  A pointer to a 24-bit value that may be unaligned.
  73
  74   @return The 24-bit value read from Buffer.
  75
  76 **/
  77 UINT32
  78 EFIAPI
  79 ReadUnaligned24 (
  80   IN CONST UINT32              *Buffer
  81   )
  82 {
  83   ASSERT (Buffer != NULL);
  84
  85   return *Buffer & 0xffffff;
  86 }
  87
  88 /**
  89   Writes a 24-bit value to memory that may be unaligned.
  90
  91   This function writes the 24-bit value specified by Value to Buffer. Value is
  92   returned. The function guarantees that the write operation does not produce
  93   an alignment fault.
  94
  95   If the Buffer is NULL, then ASSERT().
  96
  97   @param  Buffer  A pointer to a 24-bit value that may be unaligned.
  98   @param  Value   24-bit value to write to Buffer.
  99
 100   @return The 24-bit value to write to Buffer.
 101
 102 **/
 103 UINT32
 104 EFIAPI
 105 WriteUnaligned24 (
 106   OUT UINT32                    *Buffer,
 107   IN  UINT32                    Value
 108   )
 109 {
 110   ASSERT (Buffer != NULL);
 111
 112   *Buffer = BitFieldWrite32 (*Buffer, 0, 23, Value);
 113   return Value;
 114 }
 115
 116 /**
 117   Reads a 32-bit value from memory that may be unaligned.
 118
 119   This function returns the 32-bit value pointed to by Buffer. The function
 120   guarantees that the read operation does not produce an alignment fault.
 121
 122   If the Buffer is NULL, then ASSERT().
 123
 124   @param  Buffer  A pointer to a 32-bit value that may be unaligned.
 125
 126   @return The 32-bit value read from Buffer.
 127
 128 **/
 129 UINT32
 130 EFIAPI
 131 ReadUnaligned32 (
 132   IN CONST UINT32              *Buffer
 133   )
 134 {
 135   ASSERT (Buffer != NULL);
 136
 137   return *Buffer;
 138 }
 139
 140 /**
 141   Writes a 32-bit value to memory that may be unaligned.
 142
 143   This function writes the 32-bit value specified by Value to Buffer. Value is
 144   returned. The function guarantees that the write operation does not produce
 145   an alignment fault.
 146
 147   If the Buffer is NULL, then ASSERT().
 148
 149   @param  Buffer  A pointer to a 32-bit value that may be unaligned.
 150   @param  Value   The 32-bit value to write to Buffer.
 151
 152   @return The 32-bit value to write to Buffer.
 153
 154 **/
 155 UINT32
 156 EFIAPI
 157 WriteUnaligned32 (
 158   OUT UINT32                    *Buffer,
 159   IN  UINT32                    Value
 160   )
 161 {
 162   ASSERT (Buffer != NULL);
 163
 164   return *Buffer = Value;
 165 }
 166
 167 /**
 168   Reads a 64-bit value from memory that may be unaligned.
 169
 170   This function returns the 64-bit value pointed to by Buffer. The function
 171   guarantees that the read operation does not produce an alignment fault.
 172
 173   If the Buffer is NULL, then ASSERT().
 174
 175   @param  Buffer  A pointer to a 64-bit value that may be unaligned.
 176
 177   @return The 64-bit value read from Buffer.
 178
 179 **/
 180 UINT64
 181 EFIAPI
 182 ReadUnaligned64 (
 183   IN CONST UINT64              *Buffer
 184   )
 185 {
 186   ASSERT (Buffer != NULL);
 187
 188   return *Buffer;
 189 }
 190
 191 /**
 192   Writes a 64-bit value to memory that may be unaligned.
 193
 194   This function writes the 64-bit value specified by Value to Buffer. Value is
 195   returned. The function guarantees that the write operation does not produce
 196   an alignment fault.
 197
 198   If the Buffer is NULL, then ASSERT().
 199
 200   @param  Buffer  A pointer to a 64-bit value that may be unaligned.
 201   @param  Value   The 64-bit value to write to Buffer.
 202
 203   @return The 64-bit value to write to Buffer.
 204
 205 **/
 206 UINT64
 207 EFIAPI
 208 WriteUnaligned64 (
 209   OUT UINT64                    *Buffer,
 210   IN  UINT64                    Value
 211   )
 212 {
 213   ASSERT (Buffer != NULL);
 214
 215   return *Buffer = Value;
 216 }