/src/hbfa-fl/HBFA/UefiHostTestPkg/Library/BaseLibHost/Unaligned.c

Source (jump to first uncovered line)
/** @file
  Unaligned access functions of BaseLib.

  Copyright (c) 2006 - 2010, Intel Corporation. All rights reserved.<BR>
  SPDX-License-Identifier: BSD-2-Clause-Patent

**/

#include <Base.h>
#include <Library/BaseLib.h>
#include <Library/DebugLib.h>

/**
  Reads a 16-bit value from memory that may be unaligned.

  This function returns the 16-bit value pointed to by Buffer. The function
  guarantees that the read operation does not produce an alignment fault.

  If the Buffer is NULL, then ASSERT().

  @param  Buffer  A pointer to a 16-bit value that may be unaligned.

  @return The 16-bit value read from Buffer.

**/
UINT16
EFIAPI
ReadUnaligned16 (
  IN CONST UINT16              *Buffer
  )
{
  ASSERT (Buffer != NULL);

  return *Buffer;
}

/**
  Writes a 16-bit value to memory that may be unaligned.

  This function writes the 16-bit value specified by Value to Buffer. Value is
  returned. The function guarantees that the write operation does not produce
  an alignment fault.

  If the Buffer is NULL, then ASSERT().

  @param  Buffer  A pointer to a 16-bit value that may be unaligned.
  @param  Value   16-bit value to write to Buffer.

  @return The 16-bit value to write to Buffer.

**/
UINT16
EFIAPI
WriteUnaligned16 (
  OUT UINT16                    *Buffer,
  IN  UINT16                    Value
  )
{
  ASSERT (Buffer != NULL);

  return *Buffer = Value;
}

/**
  Reads a 24-bit value from memory that may be unaligned.

  This function returns the 24-bit value pointed to by Buffer. The function
  guarantees that the read operation does not produce an alignment fault.

  If the Buffer is NULL, then ASSERT().

  @param  Buffer  A pointer to a 24-bit value that may be unaligned.

  @return The 24-bit value read from Buffer.

**/
UINT32
EFIAPI
ReadUnaligned24 (
  IN CONST UINT32              *Buffer
  )
{
  ASSERT (Buffer != NULL);

  return *Buffer & 0xffffff;
}

/**
  Writes a 24-bit value to memory that may be unaligned.

  This function writes the 24-bit value specified by Value to Buffer. Value is
  returned. The function guarantees that the write operation does not produce
  an alignment fault.

  If the Buffer is NULL, then ASSERT().

  @param  Buffer  A pointer to a 24-bit value that may be unaligned.
  @param  Value   24-bit value to write to Buffer.

  @return The 24-bit value to write to Buffer.

**/
UINT32
EFIAPI
WriteUnaligned24 (
  OUT UINT32                    *Buffer,
  IN  UINT32                    Value
  )
{
  ASSERT (Buffer != NULL);

  *Buffer = BitFieldWrite32 (*Buffer, 0, 23, Value);
  return Value;
}

/**
  Reads a 32-bit value from memory that may be unaligned.

  This function returns the 32-bit value pointed to by Buffer. The function
  guarantees that the read operation does not produce an alignment fault.

  If the Buffer is NULL, then ASSERT().

  @param  Buffer  A pointer to a 32-bit value that may be unaligned.

  @return The 32-bit value read from Buffer.

**/
UINT32
EFIAPI
ReadUnaligned32 (
  IN CONST UINT32              *Buffer
  )
{
  ASSERT (Buffer != NULL);

  return *Buffer;
}

/**
  Writes a 32-bit value to memory that may be unaligned.

  This function writes the 32-bit value specified by Value to Buffer. Value is
  returned. The function guarantees that the write operation does not produce
  an alignment fault.

  If the Buffer is NULL, then ASSERT().

  @param  Buffer  A pointer to a 32-bit value that may be unaligned.
  @param  Value   The 32-bit value to write to Buffer.

  @return The 32-bit value to write to Buffer.

**/
UINT32
EFIAPI
WriteUnaligned32 (
  OUT UINT32                    *Buffer,
  IN  UINT32                    Value
  )
{
  ASSERT (Buffer != NULL);

  return *Buffer = Value;
}

/**
  Reads a 64-bit value from memory that may be unaligned.

  This function returns the 64-bit value pointed to by Buffer. The function
  guarantees that the read operation does not produce an alignment fault.

  If the Buffer is NULL, then ASSERT().

  @param  Buffer  A pointer to a 64-bit value that may be unaligned.

  @return The 64-bit value read from Buffer.

**/
UINT64
EFIAPI
ReadUnaligned64 (
  IN CONST UINT64              *Buffer
  )
{
  ASSERT (Buffer != NULL);

  return *Buffer;
}

/**
  Writes a 64-bit value to memory that may be unaligned.

  This function writes the 64-bit value specified by Value to Buffer. Value is
  returned. The function guarantees that the write operation does not produce
  an alignment fault.

  If the Buffer is NULL, then ASSERT().

  @param  Buffer  A pointer to a 64-bit value that may be unaligned.
  @param  Value   The 64-bit value to write to Buffer.

  @return The 64-bit value to write to Buffer.

**/
UINT64
EFIAPI
WriteUnaligned64 (
  OUT UINT64                    *Buffer,
  IN  UINT64                    Value
  )
{
  ASSERT (Buffer != NULL);

  return *Buffer = Value;
}

Coverage Report

Created: 2024-10-17 06:29

Line	Count	Source (jump to first uncovered line)
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		#include <Base.h>
10		#include <Library/BaseLib.h>
11		#include <Library/DebugLib.h>
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	56	{
32	56	ASSERT (Buffer != NULL);
33
34	56	return *Buffer;
35	56	}
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	429	{
59	429	ASSERT (Buffer != NULL);
60
61	429	return *Buffer = Value;
62	429	}
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	0	{
83	0	ASSERT (Buffer != NULL);
84
85	0	return *Buffer & 0xffffff;
86	0	}
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	0	{
110	0	ASSERT (Buffer != NULL);
111
112	0	Buffer = BitFieldWrite32 (Buffer, 0, 23, Value);
113	0	return Value;
114	0	}
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	143	{
135	143	ASSERT (Buffer != NULL);
136
137	143	return *Buffer;
138	143	}
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	143	{
162	143	ASSERT (Buffer != NULL);
163
164	143	return *Buffer = Value;
165	143	}
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	0	{
186	0	ASSERT (Buffer != NULL);
187
188	0	return *Buffer;
189	0	}
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	0	{
213	0	ASSERT (Buffer != NULL);
214
215	0	return *Buffer = Value;
216	0	}