BitField.c@ 80721

最後變更在這個檔案從80721是 80721,由 vboxsync 提交於 6 年前
Devices/EFI/FirmwareNew: Start upgrade process to edk2-stable201908 (compiles on Windows and works to some extent), bugref:4643
屬性 svn:eol-style 設為 `native`
檔案大小: 33.5 KB

行
1	/** @file
2	Bit field functions of BaseLib.
3
4	Copyright (c) 2006 - 2018, Intel Corporation. All rights reserved.<BR>
5	SPDX-License-Identifier: BSD-2-Clause-Patent
6
7	**/
8
9	#include "BaseLibInternals.h"
10
11	/**
12	Worker function that returns a bit field from Operand.
13
14	Returns the bitfield specified by the StartBit and the EndBit from Operand.
15
16	@param Operand Operand on which to perform the bitfield operation.
17	@param StartBit The ordinal of the least significant bit in the bit field.
18	@param EndBit The ordinal of the most significant bit in the bit field.
19
20	@return The bit field read.
21
22	**/
23	UINTN
24	EFIAPI
25	InternalBaseLibBitFieldReadUint (
26	IN UINTN Operand,
27	IN UINTN StartBit,
28	IN UINTN EndBit
29	)
30	{
31	//
32	// ~((UINTN)-2 << EndBit) is a mask in which bit[0] thru bit[EndBit]
33	// are 1's while bit[EndBit + 1] thru the most significant bit are 0's.
34	//
35	return (Operand & ~((UINTN)-2 << EndBit)) >> StartBit;
36	}
37
38	/**
39	Worker function that reads a bit field from Operand, performs a bitwise OR,
40	and returns the result.
41
42	Performs a bitwise OR between the bit field specified by StartBit and EndBit
43	in Operand and the value specified by AndData. All other bits in Operand are
44	preserved. The new value is returned.
45
46	If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
47
48	@param Operand Operand on which to perform the bitfield operation.
49	@param StartBit The ordinal of the least significant bit in the bit field.
50	@param EndBit The ordinal of the most significant bit in the bit field.
51	@param OrData The value to OR with the read value from the value.
52
53	@return The new value.
54
55	**/
56	UINTN
57	EFIAPI
58	InternalBaseLibBitFieldOrUint (
59	IN UINTN Operand,
60	IN UINTN StartBit,
61	IN UINTN EndBit,
62	IN UINTN OrData
63	)
64	{
65	//
66	// Higher bits in OrData those are not used must be zero.
67	//
68	// EndBit - StartBit + 1 might be 32 while the result right shifting 32 on a 32bit integer is undefined,
69	// So the logic is updated to right shift (EndBit - StartBit) bits and compare the last bit directly.
70	//
71	ASSERT ((OrData >> (EndBit - StartBit)) == ((OrData >> (EndBit - StartBit)) & 1));
72
73	//
74	// ~((UINTN)-2 << EndBit) is a mask in which bit[0] thru bit[EndBit]
75	// are 1's while bit[EndBit + 1] thru the most significant bit are 0's.
76	//
77	return Operand \| ((OrData << StartBit) & ~((UINTN) -2 << EndBit));
78	}
79
80	/**
81	Worker function that reads a bit field from Operand, performs a bitwise AND,
82	and returns the result.
83
84	Performs a bitwise AND between the bit field specified by StartBit and EndBit
85	in Operand and the value specified by AndData. All other bits in Operand are
86	preserved. The new value is returned.
87
88	If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
89
90	@param Operand Operand on which to perform the bitfield operation.
91	@param StartBit The ordinal of the least significant bit in the bit field.
92	@param EndBit The ordinal of the most significant bit in the bit field.
93	@param AndData The value to And with the read value from the value.
94
95	@return The new value.
96
97	**/
98	UINTN
99	EFIAPI
100	InternalBaseLibBitFieldAndUint (
101	IN UINTN Operand,
102	IN UINTN StartBit,
103	IN UINTN EndBit,
104	IN UINTN AndData
105	)
106	{
107	//
108	// Higher bits in AndData those are not used must be zero.
109	//
110	// EndBit - StartBit + 1 might be 32 while the result right shifting 32 on a 32bit integer is undefined,
111	// So the logic is updated to right shift (EndBit - StartBit) bits and compare the last bit directly.
112	//
113	ASSERT ((AndData >> (EndBit - StartBit)) == ((AndData >> (EndBit - StartBit)) & 1));
114
115	//
116	// ~((UINTN)-2 << EndBit) is a mask in which bit[0] thru bit[EndBit]
117	// are 1's while bit[EndBit + 1] thru the most significant bit are 0's.
118	//
119	return Operand & ~((~AndData << StartBit) & ~((UINTN)-2 << EndBit));
120	}
121
122	/**
123	Returns a bit field from an 8-bit value.
124
125	Returns the bitfield specified by the StartBit and the EndBit from Operand.
126
127	If 8-bit operations are not supported, then ASSERT().
128	If StartBit is greater than 7, then ASSERT().
129	If EndBit is greater than 7, then ASSERT().
130	If EndBit is less than StartBit, then ASSERT().
131
132	@param Operand Operand on which to perform the bitfield operation.
133	@param StartBit The ordinal of the least significant bit in the bit field.
134	Range 0..7.
135	@param EndBit The ordinal of the most significant bit in the bit field.
136	Range 0..7.
137
138	@return The bit field read.
139
140	**/
141	UINT8
142	EFIAPI
143	BitFieldRead8 (
144	IN UINT8 Operand,
145	IN UINTN StartBit,
146	IN UINTN EndBit
147	)
148	{
149	ASSERT (EndBit < 8);
150	ASSERT (StartBit <= EndBit);
151	return (UINT8)InternalBaseLibBitFieldReadUint (Operand, StartBit, EndBit);
152	}
153
154	/**
155	Writes a bit field to an 8-bit value, and returns the result.
156
157	Writes Value to the bit field specified by the StartBit and the EndBit in
158	Operand. All other bits in Operand are preserved. The new 8-bit value is
159	returned.
160
161	If 8-bit operations are not supported, then ASSERT().
162	If StartBit is greater than 7, then ASSERT().
163	If EndBit is greater than 7, then ASSERT().
164	If EndBit is less than StartBit, then ASSERT().
165	If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
166
167	@param Operand Operand on which to perform the bitfield operation.
168	@param StartBit The ordinal of the least significant bit in the bit field.
169	Range 0..7.
170	@param EndBit The ordinal of the most significant bit in the bit field.
171	Range 0..7.
172	@param Value The new value of the bit field.
173
174	@return The new 8-bit value.
175
176	**/
177	UINT8
178	EFIAPI
179	BitFieldWrite8 (
180	IN UINT8 Operand,
181	IN UINTN StartBit,
182	IN UINTN EndBit,
183	IN UINT8 Value
184	)
185	{
186	ASSERT (EndBit < 8);
187	ASSERT (StartBit <= EndBit);
188	return BitFieldAndThenOr8 (Operand, StartBit, EndBit, 0, Value);
189	}
190
191	/**
192	Reads a bit field from an 8-bit value, performs a bitwise OR, and returns the
193	result.
194
195	Performs a bitwise OR between the bit field specified by StartBit
196	and EndBit in Operand and the value specified by OrData. All other bits in
197	Operand are preserved. The new 8-bit value is returned.
198
199	If 8-bit operations are not supported, then ASSERT().
200	If StartBit is greater than 7, then ASSERT().
201	If EndBit is greater than 7, then ASSERT().
202	If EndBit is less than StartBit, then ASSERT().
203	If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
204
205	@param Operand Operand on which to perform the bitfield operation.
206	@param StartBit The ordinal of the least significant bit in the bit field.
207	Range 0..7.
208	@param EndBit The ordinal of the most significant bit in the bit field.
209	Range 0..7.
210	@param OrData The value to OR with the read value from the value.
211
212	@return The new 8-bit value.
213
214	**/
215	UINT8
216	EFIAPI
217	BitFieldOr8 (
218	IN UINT8 Operand,
219	IN UINTN StartBit,
220	IN UINTN EndBit,
221	IN UINT8 OrData
222	)
223	{
224	ASSERT (EndBit < 8);
225	ASSERT (StartBit <= EndBit);
226	return (UINT8)InternalBaseLibBitFieldOrUint (Operand, StartBit, EndBit, OrData);
227	}
228
229	/**
230	Reads a bit field from an 8-bit value, performs a bitwise AND, and returns
231	the result.
232
233	Performs a bitwise AND between the bit field specified by StartBit and EndBit
234	in Operand and the value specified by AndData. All other bits in Operand are
235	preserved. The new 8-bit value is returned.
236
237	If 8-bit operations are not supported, then ASSERT().
238	If StartBit is greater than 7, then ASSERT().
239	If EndBit is greater than 7, then ASSERT().
240	If EndBit is less than StartBit, then ASSERT().
241	If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
242
243	@param Operand Operand on which to perform the bitfield operation.
244	@param StartBit The ordinal of the least significant bit in the bit field.
245	Range 0..7.
246	@param EndBit The ordinal of the most significant bit in the bit field.
247	Range 0..7.
248	@param AndData The value to AND with the read value from the value.
249
250	@return The new 8-bit value.
251
252	**/
253	UINT8
254	EFIAPI
255	BitFieldAnd8 (
256	IN UINT8 Operand,
257	IN UINTN StartBit,
258	IN UINTN EndBit,
259	IN UINT8 AndData
260	)
261	{
262	ASSERT (EndBit < 8);
263	ASSERT (StartBit <= EndBit);
264	return (UINT8)InternalBaseLibBitFieldAndUint (Operand, StartBit, EndBit, AndData);
265	}
266
267	/**
268	Reads a bit field from an 8-bit value, performs a bitwise AND followed by a
269	bitwise OR, and returns the result.
270
271	Performs a bitwise AND between the bit field specified by StartBit and EndBit
272	in Operand and the value specified by AndData, followed by a bitwise
273	OR with value specified by OrData. All other bits in Operand are
274	preserved. The new 8-bit value is returned.
275
276	If 8-bit operations are not supported, then ASSERT().
277	If StartBit is greater than 7, then ASSERT().
278	If EndBit is greater than 7, then ASSERT().
279	If EndBit is less than StartBit, then ASSERT().
280	If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
281	If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
282
283	@param Operand Operand on which to perform the bitfield operation.
284	@param StartBit The ordinal of the least significant bit in the bit field.
285	Range 0..7.
286	@param EndBit The ordinal of the most significant bit in the bit field.
287	Range 0..7.
288	@param AndData The value to AND with the read value from the value.
289	@param OrData The value to OR with the result of the AND operation.
290
291	@return The new 8-bit value.
292
293	**/
294	UINT8
295	EFIAPI
296	BitFieldAndThenOr8 (
297	IN UINT8 Operand,
298	IN UINTN StartBit,
299	IN UINTN EndBit,
300	IN UINT8 AndData,
301	IN UINT8 OrData
302	)
303	{
304	ASSERT (EndBit < 8);
305	ASSERT (StartBit <= EndBit);
306	return BitFieldOr8 (
307	BitFieldAnd8 (Operand, StartBit, EndBit, AndData),
308	StartBit,
309	EndBit,
310	OrData
311	);
312	}
313
314	/**
315	Returns a bit field from a 16-bit value.
316
317	Returns the bitfield specified by the StartBit and the EndBit from Operand.
318
319	If 16-bit operations are not supported, then ASSERT().
320	If StartBit is greater than 15, then ASSERT().
321	If EndBit is greater than 15, then ASSERT().
322	If EndBit is less than StartBit, then ASSERT().
323
324	@param Operand Operand on which to perform the bitfield operation.
325	@param StartBit The ordinal of the least significant bit in the bit field.
326	Range 0..15.
327	@param EndBit The ordinal of the most significant bit in the bit field.
328	Range 0..15.
329
330	@return The bit field read.
331
332	**/
333	UINT16
334	EFIAPI
335	BitFieldRead16 (
336	IN UINT16 Operand,
337	IN UINTN StartBit,
338	IN UINTN EndBit
339	)
340	{
341	ASSERT (EndBit < 16);
342	ASSERT (StartBit <= EndBit);
343	return (UINT16)InternalBaseLibBitFieldReadUint (Operand, StartBit, EndBit);
344	}
345
346	/**
347	Writes a bit field to a 16-bit value, and returns the result.
348
349	Writes Value to the bit field specified by the StartBit and the EndBit in
350	Operand. All other bits in Operand are preserved. The new 16-bit value is
351	returned.
352
353	If 16-bit operations are not supported, then ASSERT().
354	If StartBit is greater than 15, then ASSERT().
355	If EndBit is greater than 15, then ASSERT().
356	If EndBit is less than StartBit, then ASSERT().
357	If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
358
359	@param Operand Operand on which to perform the bitfield operation.
360	@param StartBit The ordinal of the least significant bit in the bit field.
361	Range 0..15.
362	@param EndBit The ordinal of the most significant bit in the bit field.
363	Range 0..15.
364	@param Value The new value of the bit field.
365
366	@return The new 16-bit value.
367
368	**/
369	UINT16
370	EFIAPI
371	BitFieldWrite16 (
372	IN UINT16 Operand,
373	IN UINTN StartBit,
374	IN UINTN EndBit,
375	IN UINT16 Value
376	)
377	{
378	ASSERT (EndBit < 16);
379	ASSERT (StartBit <= EndBit);
380	return BitFieldAndThenOr16 (Operand, StartBit, EndBit, 0, Value);
381	}
382
383	/**
384	Reads a bit field from a 16-bit value, performs a bitwise OR, and returns the
385	result.
386
387	Performs a bitwise OR between the bit field specified by StartBit
388	and EndBit in Operand and the value specified by OrData. All other bits in
389	Operand are preserved. The new 16-bit value is returned.
390
391	If 16-bit operations are not supported, then ASSERT().
392	If StartBit is greater than 15, then ASSERT().
393	If EndBit is greater than 15, then ASSERT().
394	If EndBit is less than StartBit, then ASSERT().
395	If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
396
397	@param Operand Operand on which to perform the bitfield operation.
398	@param StartBit The ordinal of the least significant bit in the bit field.
399	Range 0..15.
400	@param EndBit The ordinal of the most significant bit in the bit field.
401	Range 0..15.
402	@param OrData The value to OR with the read value from the value.
403
404	@return The new 16-bit value.
405
406	**/
407	UINT16
408	EFIAPI
409	BitFieldOr16 (
410	IN UINT16 Operand,
411	IN UINTN StartBit,
412	IN UINTN EndBit,
413	IN UINT16 OrData
414	)
415	{
416	ASSERT (EndBit < 16);
417	ASSERT (StartBit <= EndBit);
418	return (UINT16)InternalBaseLibBitFieldOrUint (Operand, StartBit, EndBit, OrData);
419	}
420
421	/**
422	Reads a bit field from a 16-bit value, performs a bitwise AND, and returns
423	the result.
424
425	Performs a bitwise AND between the bit field specified by StartBit and EndBit
426	in Operand and the value specified by AndData. All other bits in Operand are
427	preserved. The new 16-bit value is returned.
428
429	If 16-bit operations are not supported, then ASSERT().
430	If StartBit is greater than 15, then ASSERT().
431	If EndBit is greater than 15, then ASSERT().
432	If EndBit is less than StartBit, then ASSERT().
433	If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
434
435	@param Operand Operand on which to perform the bitfield operation.
436	@param StartBit The ordinal of the least significant bit in the bit field.
437	Range 0..15.
438	@param EndBit The ordinal of the most significant bit in the bit field.
439	Range 0..15.
440	@param AndData The value to AND with the read value from the value.
441
442	@return The new 16-bit value.
443
444	**/
445	UINT16
446	EFIAPI
447	BitFieldAnd16 (
448	IN UINT16 Operand,
449	IN UINTN StartBit,
450	IN UINTN EndBit,
451	IN UINT16 AndData
452	)
453	{
454	ASSERT (EndBit < 16);
455	ASSERT (StartBit <= EndBit);
456	return (UINT16)InternalBaseLibBitFieldAndUint (Operand, StartBit, EndBit, AndData);
457	}
458
459	/**
460	Reads a bit field from a 16-bit value, performs a bitwise AND followed by a
461	bitwise OR, and returns the result.
462
463	Performs a bitwise AND between the bit field specified by StartBit and EndBit
464	in Operand and the value specified by AndData, followed by a bitwise
465	OR with value specified by OrData. All other bits in Operand are
466	preserved. The new 16-bit value is returned.
467
468	If 16-bit operations are not supported, then ASSERT().
469	If StartBit is greater than 15, then ASSERT().
470	If EndBit is greater than 15, then ASSERT().
471	If EndBit is less than StartBit, then ASSERT().
472	If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
473	If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
474
475	@param Operand Operand on which to perform the bitfield operation.
476	@param StartBit The ordinal of the least significant bit in the bit field.
477	Range 0..15.
478	@param EndBit The ordinal of the most significant bit in the bit field.
479	Range 0..15.
480	@param AndData The value to AND with the read value from the value.
481	@param OrData The value to OR with the result of the AND operation.
482
483	@return The new 16-bit value.
484
485	**/
486	UINT16
487	EFIAPI
488	BitFieldAndThenOr16 (
489	IN UINT16 Operand,
490	IN UINTN StartBit,
491	IN UINTN EndBit,
492	IN UINT16 AndData,
493	IN UINT16 OrData
494	)
495	{
496	ASSERT (EndBit < 16);
497	ASSERT (StartBit <= EndBit);
498	return BitFieldOr16 (
499	BitFieldAnd16 (Operand, StartBit, EndBit, AndData),
500	StartBit,
501	EndBit,
502	OrData
503	);
504	}
505
506	/**
507	Returns a bit field from a 32-bit value.
508
509	Returns the bitfield specified by the StartBit and the EndBit from Operand.
510
511	If 32-bit operations are not supported, then ASSERT().
512	If StartBit is greater than 31, then ASSERT().
513	If EndBit is greater than 31, then ASSERT().
514	If EndBit is less than StartBit, then ASSERT().
515
516	@param Operand Operand on which to perform the bitfield operation.
517	@param StartBit The ordinal of the least significant bit in the bit field.
518	Range 0..31.
519	@param EndBit The ordinal of the most significant bit in the bit field.
520	Range 0..31.
521
522	@return The bit field read.
523
524	**/
525	UINT32
526	EFIAPI
527	BitFieldRead32 (
528	IN UINT32 Operand,
529	IN UINTN StartBit,
530	IN UINTN EndBit
531	)
532	{
533	ASSERT (EndBit < 32);
534	ASSERT (StartBit <= EndBit);
535	return (UINT32)InternalBaseLibBitFieldReadUint (Operand, StartBit, EndBit);
536	}
537
538	/**
539	Writes a bit field to a 32-bit value, and returns the result.
540
541	Writes Value to the bit field specified by the StartBit and the EndBit in
542	Operand. All other bits in Operand are preserved. The new 32-bit value is
543	returned.
544
545	If 32-bit operations are not supported, then ASSERT().
546	If StartBit is greater than 31, then ASSERT().
547	If EndBit is greater than 31, then ASSERT().
548	If EndBit is less than StartBit, then ASSERT().
549	If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
550
551	@param Operand Operand on which to perform the bitfield operation.
552	@param StartBit The ordinal of the least significant bit in the bit field.
553	Range 0..31.
554	@param EndBit The ordinal of the most significant bit in the bit field.
555	Range 0..31.
556	@param Value The new value of the bit field.
557
558	@return The new 32-bit value.
559
560	**/
561	UINT32
562	EFIAPI
563	BitFieldWrite32 (
564	IN UINT32 Operand,
565	IN UINTN StartBit,
566	IN UINTN EndBit,
567	IN UINT32 Value
568	)
569	{
570	ASSERT (EndBit < 32);
571	ASSERT (StartBit <= EndBit);
572	return BitFieldAndThenOr32 (Operand, StartBit, EndBit, 0, Value);
573	}
574
575	/**
576	Reads a bit field from a 32-bit value, performs a bitwise OR, and returns the
577	result.
578
579	Performs a bitwise OR between the bit field specified by StartBit
580	and EndBit in Operand and the value specified by OrData. All other bits in
581	Operand are preserved. The new 32-bit value is returned.
582
583	If 32-bit operations are not supported, then ASSERT().
584	If StartBit is greater than 31, then ASSERT().
585	If EndBit is greater than 31, then ASSERT().
586	If EndBit is less than StartBit, then ASSERT().
587	If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
588
589	@param Operand Operand on which to perform the bitfield operation.
590	@param StartBit The ordinal of the least significant bit in the bit field.
591	Range 0..31.
592	@param EndBit The ordinal of the most significant bit in the bit field.
593	Range 0..31.
594	@param OrData The value to OR with the read value from the value.
595
596	@return The new 32-bit value.
597
598	**/
599	UINT32
600	EFIAPI
601	BitFieldOr32 (
602	IN UINT32 Operand,
603	IN UINTN StartBit,
604	IN UINTN EndBit,
605	IN UINT32 OrData
606	)
607	{
608	ASSERT (EndBit < 32);
609	ASSERT (StartBit <= EndBit);
610	return (UINT32)InternalBaseLibBitFieldOrUint (Operand, StartBit, EndBit, OrData);
611	}
612
613	/**
614	Reads a bit field from a 32-bit value, performs a bitwise AND, and returns
615	the result.
616
617	Performs a bitwise AND between the bit field specified by StartBit and EndBit
618	in Operand and the value specified by AndData. All other bits in Operand are
619	preserved. The new 32-bit value is returned.
620
621	If 32-bit operations are not supported, then ASSERT().
622	If StartBit is greater than 31, then ASSERT().
623	If EndBit is greater than 31, then ASSERT().
624	If EndBit is less than StartBit, then ASSERT().
625	If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
626
627	@param Operand Operand on which to perform the bitfield operation.
628	@param StartBit The ordinal of the least significant bit in the bit field.
629	Range 0..31.
630	@param EndBit The ordinal of the most significant bit in the bit field.
631	Range 0..31.
632	@param AndData The value to AND with the read value from the value.
633
634	@return The new 32-bit value.
635
636	**/
637	UINT32
638	EFIAPI
639	BitFieldAnd32 (
640	IN UINT32 Operand,
641	IN UINTN StartBit,
642	IN UINTN EndBit,
643	IN UINT32 AndData
644	)
645	{
646	ASSERT (EndBit < 32);
647	ASSERT (StartBit <= EndBit);
648	return (UINT32)InternalBaseLibBitFieldAndUint (Operand, StartBit, EndBit, AndData);
649	}
650
651	/**
652	Reads a bit field from a 32-bit value, performs a bitwise AND followed by a
653	bitwise OR, and returns the result.
654
655	Performs a bitwise AND between the bit field specified by StartBit and EndBit
656	in Operand and the value specified by AndData, followed by a bitwise
657	OR with value specified by OrData. All other bits in Operand are
658	preserved. The new 32-bit value is returned.
659
660	If 32-bit operations are not supported, then ASSERT().
661	If StartBit is greater than 31, then ASSERT().
662	If EndBit is greater than 31, then ASSERT().
663	If EndBit is less than StartBit, then ASSERT().
664	If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
665	If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
666
667	@param Operand Operand on which to perform the bitfield operation.
668	@param StartBit The ordinal of the least significant bit in the bit field.
669	Range 0..31.
670	@param EndBit The ordinal of the most significant bit in the bit field.
671	Range 0..31.
672	@param AndData The value to AND with the read value from the value.
673	@param OrData The value to OR with the result of the AND operation.
674
675	@return The new 32-bit value.
676
677	**/
678	UINT32
679	EFIAPI
680	BitFieldAndThenOr32 (
681	IN UINT32 Operand,
682	IN UINTN StartBit,
683	IN UINTN EndBit,
684	IN UINT32 AndData,
685	IN UINT32 OrData
686	)
687	{
688	ASSERT (EndBit < 32);
689	ASSERT (StartBit <= EndBit);
690	return BitFieldOr32 (
691	BitFieldAnd32 (Operand, StartBit, EndBit, AndData),
692	StartBit,
693	EndBit,
694	OrData
695	);
696	}
697
698	/**
699	Returns a bit field from a 64-bit value.
700
701	Returns the bitfield specified by the StartBit and the EndBit from Operand.
702
703	If 64-bit operations are not supported, then ASSERT().
704	If StartBit is greater than 63, then ASSERT().
705	If EndBit is greater than 63, then ASSERT().
706	If EndBit is less than StartBit, then ASSERT().
707
708	@param Operand Operand on which to perform the bitfield operation.
709	@param StartBit The ordinal of the least significant bit in the bit field.
710	Range 0..63.
711	@param EndBit The ordinal of the most significant bit in the bit field.
712	Range 0..63.
713
714	@return The bit field read.
715
716	**/
717	UINT64
718	EFIAPI
719	BitFieldRead64 (
720	IN UINT64 Operand,
721	IN UINTN StartBit,
722	IN UINTN EndBit
723	)
724	{
725	ASSERT (EndBit < 64);
726	ASSERT (StartBit <= EndBit);
727	return RShiftU64 (Operand & ~LShiftU64 ((UINT64)-2, EndBit), StartBit);
728	}
729
730	/**
731	Writes a bit field to a 64-bit value, and returns the result.
732
733	Writes Value to the bit field specified by the StartBit and the EndBit in
734	Operand. All other bits in Operand are preserved. The new 64-bit value is
735	returned.
736
737	If 64-bit operations are not supported, then ASSERT().
738	If StartBit is greater than 63, then ASSERT().
739	If EndBit is greater than 63, then ASSERT().
740	If EndBit is less than StartBit, then ASSERT().
741	If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
742
743	@param Operand Operand on which to perform the bitfield operation.
744	@param StartBit The ordinal of the least significant bit in the bit field.
745	Range 0..63.
746	@param EndBit The ordinal of the most significant bit in the bit field.
747	Range 0..63.
748	@param Value The new value of the bit field.
749
750	@return The new 64-bit value.
751
752	**/
753	UINT64
754	EFIAPI
755	BitFieldWrite64 (
756	IN UINT64 Operand,
757	IN UINTN StartBit,
758	IN UINTN EndBit,
759	IN UINT64 Value
760	)
761	{
762	ASSERT (EndBit < 64);
763	ASSERT (StartBit <= EndBit);
764	return BitFieldAndThenOr64 (Operand, StartBit, EndBit, 0, Value);
765	}
766
767	/**
768	Reads a bit field from a 64-bit value, performs a bitwise OR, and returns the
769	result.
770
771	Performs a bitwise OR between the bit field specified by StartBit
772	and EndBit in Operand and the value specified by OrData. All other bits in
773	Operand are preserved. The new 64-bit value is returned.
774
775	If 64-bit operations are not supported, then ASSERT().
776	If StartBit is greater than 63, then ASSERT().
777	If EndBit is greater than 63, then ASSERT().
778	If EndBit is less than StartBit, then ASSERT().
779	If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
780
781	@param Operand Operand on which to perform the bitfield operation.
782	@param StartBit The ordinal of the least significant bit in the bit field.
783	Range 0..63.
784	@param EndBit The ordinal of the most significant bit in the bit field.
785	Range 0..63.
786	@param OrData The value to OR with the read value from the value
787
788	@return The new 64-bit value.
789
790	**/
791	UINT64
792	EFIAPI
793	BitFieldOr64 (
794	IN UINT64 Operand,
795	IN UINTN StartBit,
796	IN UINTN EndBit,
797	IN UINT64 OrData
798	)
799	{
800	UINT64 Value1;
801	UINT64 Value2;
802
803	ASSERT (EndBit < 64);
804	ASSERT (StartBit <= EndBit);
805	//
806	// Higher bits in OrData those are not used must be zero.
807	//
808	// EndBit - StartBit + 1 might be 64 while the result right shifting 64 on RShiftU64() API is invalid,
809	// So the logic is updated to right shift (EndBit - StartBit) bits and compare the last bit directly.
810	//
811	ASSERT (RShiftU64 (OrData, EndBit - StartBit) == (RShiftU64 (OrData, EndBit - StartBit) & 1));
812
813	Value1 = LShiftU64 (OrData, StartBit);
814	Value2 = LShiftU64 ((UINT64) - 2, EndBit);
815
816	return Operand \| (Value1 & ~Value2);
817	}
818
819	/**
820	Reads a bit field from a 64-bit value, performs a bitwise AND, and returns
821	the result.
822
823	Performs a bitwise AND between the bit field specified by StartBit and EndBit
824	in Operand and the value specified by AndData. All other bits in Operand are
825	preserved. The new 64-bit value is returned.
826
827	If 64-bit operations are not supported, then ASSERT().
828	If StartBit is greater than 63, then ASSERT().
829	If EndBit is greater than 63, then ASSERT().
830	If EndBit is less than StartBit, then ASSERT().
831	If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
832
833	@param Operand Operand on which to perform the bitfield operation.
834	@param StartBit The ordinal of the least significant bit in the bit field.
835	Range 0..63.
836	@param EndBit The ordinal of the most significant bit in the bit field.
837	Range 0..63.
838	@param AndData The value to AND with the read value from the value.
839
840	@return The new 64-bit value.
841
842	**/
843	UINT64
844	EFIAPI
845	BitFieldAnd64 (
846	IN UINT64 Operand,
847	IN UINTN StartBit,
848	IN UINTN EndBit,
849	IN UINT64 AndData
850	)
851	{
852	UINT64 Value1;
853	UINT64 Value2;
854
855	ASSERT (EndBit < 64);
856	ASSERT (StartBit <= EndBit);
857	//
858	// Higher bits in AndData those are not used must be zero.
859	//
860	// EndBit - StartBit + 1 might be 64 while the right shifting 64 on RShiftU64() API is invalid,
861	// So the logic is updated to right shift (EndBit - StartBit) bits and compare the last bit directly.
862	//
863	ASSERT (RShiftU64 (AndData, EndBit - StartBit) == (RShiftU64 (AndData, EndBit - StartBit) & 1));
864
865	Value1 = LShiftU64 (~AndData, StartBit);
866	Value2 = LShiftU64 ((UINT64)-2, EndBit);
867
868	return Operand & ~(Value1 & ~Value2);
869	}
870
871	/**
872	Reads a bit field from a 64-bit value, performs a bitwise AND followed by a
873	bitwise OR, and returns the result.
874
875	Performs a bitwise AND between the bit field specified by StartBit and EndBit
876	in Operand and the value specified by AndData, followed by a bitwise
877	OR with value specified by OrData. All other bits in Operand are
878	preserved. The new 64-bit value is returned.
879
880	If 64-bit operations are not supported, then ASSERT().
881	If StartBit is greater than 63, then ASSERT().
882	If EndBit is greater than 63, then ASSERT().
883	If EndBit is less than StartBit, then ASSERT().
884	If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
885	If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
886
887	@param Operand Operand on which to perform the bitfield operation.
888	@param StartBit The ordinal of the least significant bit in the bit field.
889	Range 0..63.
890	@param EndBit The ordinal of the most significant bit in the bit field.
891	Range 0..63.
892	@param AndData The value to AND with the read value from the value.
893	@param OrData The value to OR with the result of the AND operation.
894
895	@return The new 64-bit value.
896
897	**/
898	UINT64
899	EFIAPI
900	BitFieldAndThenOr64 (
901	IN UINT64 Operand,
902	IN UINTN StartBit,
903	IN UINTN EndBit,
904	IN UINT64 AndData,
905	IN UINT64 OrData
906	)
907	{
908	ASSERT (EndBit < 64);
909	ASSERT (StartBit <= EndBit);
910	return BitFieldOr64 (
911	BitFieldAnd64 (Operand, StartBit, EndBit, AndData),
912	StartBit,
913	EndBit,
914	OrData
915	);
916	}
917
918	/**
919	Reads a bit field from a 32-bit value, counts and returns
920	the number of set bits.
921
922	Counts the number of set bits in the bit field specified by
923	StartBit and EndBit in Operand. The count is returned.
924
925	If StartBit is greater than 31, then ASSERT().
926	If EndBit is greater than 31, then ASSERT().
927	If EndBit is less than StartBit, then ASSERT().
928
929	@param Operand Operand on which to perform the bitfield operation.
930	@param StartBit The ordinal of the least significant bit in the bit field.
931	Range 0..31.
932	@param EndBit The ordinal of the most significant bit in the bit field.
933	Range 0..31.
934
935	@return The number of bits set between StartBit and EndBit.
936
937	**/
938	UINT8
939	EFIAPI
940	BitFieldCountOnes32 (
941	IN UINT32 Operand,
942	IN UINTN StartBit,
943	IN UINTN EndBit
944	)
945	{
946	UINT32 Count;
947
948	ASSERT (EndBit < 32);
949	ASSERT (StartBit <= EndBit);
950
951	Count = BitFieldRead32 (Operand, StartBit, EndBit);
952	Count -= ((Count >> 1) & 0x55555555);
953	Count = (Count & 0x33333333) + ((Count >> 2) & 0x33333333);
954	Count += Count >> 4;
955	Count &= 0x0F0F0F0F;
956	Count += Count >> 8;
957	Count += Count >> 16;
958
959	return (UINT8) Count & 0x3F;
960	}
961
962	/**
963	Reads a bit field from a 64-bit value, counts and returns
964	the number of set bits.
965
966	Counts the number of set bits in the bit field specified by
967	StartBit and EndBit in Operand. The count is returned.
968
969	If StartBit is greater than 63, then ASSERT().
970	If EndBit is greater than 63, then ASSERT().
971	If EndBit is less than StartBit, then ASSERT().
972
973	@param Operand Operand on which to perform the bitfield operation.
974	@param StartBit The ordinal of the least significant bit in the bit field.
975	Range 0..63.
976	@param EndBit The ordinal of the most significant bit in the bit field.
977	Range 0..63.
978
979	@return The number of bits set between StartBit and EndBit.
980
981	**/
982	UINT8
983	EFIAPI
984	BitFieldCountOnes64 (
985	IN UINT64 Operand,
986	IN UINTN StartBit,
987	IN UINTN EndBit
988	)
989	{
990	UINT64 BitField;
991	UINT8 Count;
992
993	ASSERT (EndBit < 64);
994	ASSERT (StartBit <= EndBit);
995
996	BitField = BitFieldRead64 (Operand, StartBit, EndBit);
997	Count = BitFieldCountOnes32 ((UINT32) BitField, 0, 31);
998	Count += BitFieldCountOnes32 ((UINT32) RShiftU64(BitField, 32), 0, 31);
999
1000	return Count;
1001	}
1002

注意: 瀏覽 TracBrowser 來幫助您使用儲存庫瀏覽器

source: vbox/trunk/src/VBox/Devices/EFI/FirmwareNew/MdePkg/Library/BaseLib/BitField.c@ 80721

以其他格式下載: