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