TianoCore EDK2 master
Base.h
Go to the documentation of this file.
1
15#ifndef __BASE_H__
16#define __BASE_H__
17
18//
19// Include processor specific binding
20//
21#include <ProcessorBind.h>
22
23#if defined (_MSC_EXTENSIONS)
24//
25// Disable warning when last field of data structure is a zero sized array.
26//
27 #pragma warning ( disable : 4200 )
28#endif
29
30//
31// The Microsoft* C compiler can removed references to unreferenced data items
32// if the /OPT:REF linker option is used. We defined a macro as this is a
33// a non standard extension
34//
35#if defined (_MSC_VER) && _MSC_VER < 1800 && !defined (MDE_CPU_EBC)
41#define GLOBAL_REMOVE_IF_UNREFERENCED __declspec(selectany)
42#else
48#define GLOBAL_REMOVE_IF_UNREFERENCED
49#endif
50
51//
52// Should be used in combination with NORETURN to avoid 'noreturn' returns
53// warnings.
54//
55#ifndef UNREACHABLE
56 #ifdef __GNUC__
61#define UNREACHABLE() __builtin_unreachable ()
62 #elif defined (__has_feature)
63 #if __has_builtin (__builtin_unreachable)
68#define UNREACHABLE() __builtin_unreachable ()
69 #endif
70 #endif
71
72 #ifndef UNREACHABLE
77#define UNREACHABLE()
78 #endif
79#endif
80
81//
82// Signaling compilers and analyzers that a certain function cannot return may
83// remove all following code and thus lead to better optimization and less
84// false positives.
85//
86#ifndef NORETURN
87 #if defined (__GNUC__) || defined (__clang__)
93#define NORETURN __attribute__((noreturn))
94 #elif defined (_MSC_EXTENSIONS) && !defined (MDE_CPU_EBC)
100#define NORETURN __declspec(noreturn)
101 #else
107#define NORETURN
108 #endif
109#endif
110
111//
112// Should be used in combination with ANALYZER_NORETURN to avoid 'noreturn'
113// returns warnings.
114//
115#ifndef ANALYZER_UNREACHABLE
116 #ifdef __clang_analyzer__
117 #if __has_builtin (__builtin_unreachable)
122#define ANALYZER_UNREACHABLE() __builtin_unreachable ()
123 #endif
124 #endif
125
126 #ifndef ANALYZER_UNREACHABLE
131#define ANALYZER_UNREACHABLE()
132 #endif
133#endif
134
135//
136// Static Analyzers may issue errors about potential NULL-dereferences when
137// dereferencing a pointer, that has been checked before, outside of a
138// NULL-check. This may lead to false positives, such as when using ASSERT()
139// for verification.
140//
141#ifndef ANALYZER_NORETURN
142 #ifdef __has_feature
143 #if __has_feature (attribute_analyzer_noreturn)
148#define ANALYZER_NORETURN __attribute__((analyzer_noreturn))
149 #endif
150 #endif
151
152 #ifndef ANALYZER_NORETURN
157#define ANALYZER_NORETURN
158 #endif
159#endif
160
165#ifndef RETURNS_TWICE
166 #if defined (__GNUC__) || defined (__clang__)
171#define RETURNS_TWICE __attribute__((returns_twice))
172 #else
177#define RETURNS_TWICE
178 #endif
179#endif
180
181//
182// For symbol name in assembly code, an extra "_" is sometimes necessary
183//
184
188#define _CONCATENATE(a, b) __CONCATENATE(a, b)
189#define __CONCATENATE(a, b) a ## b
190
195#define ASM_PFX(name) _CONCATENATE (__USER_LABEL_PREFIX__, name)
196
197#ifdef __APPLE__
198//
199// Apple extension that is used by the linker to optimize code size
200// with assembly functions. Put at the end of your .S files
201//
202#define ASM_FUNCTION_REMOVE_IF_UNREFERENCED .subsections_via_symbols
203#else
204#define ASM_FUNCTION_REMOVE_IF_UNREFERENCED
205#endif
206
207#define PACKED
208
213typedef struct {
214 UINT32 Data1;
215 UINT16 Data2;
216 UINT16 Data3;
217 UINT8 Data4[8];
218} GUID;
219
223typedef struct {
224 UINT8 Addr[4];
226
230typedef struct {
231 UINT8 Addr[16];
233
234//
235// 8-bytes unsigned value that represents a physical system address.
236//
237typedef UINT64 PHYSICAL_ADDRESS;
238
242typedef struct _LIST_ENTRY LIST_ENTRY;
243
248 LIST_ENTRY *ForwardLink;
249 LIST_ENTRY *BackLink;
250};
251
252//
253// Modifiers to abstract standard types to aid in debug of problems
254//
255
259#define CONST const
260
264#define STATIC static
265
269#define VOID void
270
271//
272// Modifiers for Data Types used to self document code.
273// This concept is borrowed for UEFI specification.
274//
275
279#define IN
280
284#define OUT
285
290#define OPTIONAL
291
292//
293// UEFI specification claims 1 and 0. We are concerned about the
294// compiler portability so we did it this way.
295//
296
301#define TRUE ((BOOLEAN)(1==1))
302
307#define FALSE ((BOOLEAN)(0==1))
308
312#define NULL ((VOID *) 0)
313
314//
315// Null character
316//
317#define CHAR_NULL 0x0000
318
322#define MAX_INT8 ((INT8)0x7F)
323#define MAX_UINT8 ((UINT8)0xFF)
324#define MAX_INT16 ((INT16)0x7FFF)
325#define MAX_UINT16 ((UINT16)0xFFFF)
326#define MAX_INT32 ((INT32)0x7FFFFFFF)
327#define MAX_UINT32 ((UINT32)0xFFFFFFFF)
328#define MAX_INT64 ((INT64)0x7FFFFFFFFFFFFFFFULL)
329#define MAX_UINT64 ((UINT64)0xFFFFFFFFFFFFFFFFULL)
330
334#define MIN_INT8 (((INT8) -127) - 1)
335#define MIN_INT16 (((INT16) -32767) - 1)
336#define MIN_INT32 (((INT32) -2147483647) - 1)
337#define MIN_INT64 (((INT64) -9223372036854775807LL) - 1)
338
339#define BIT0 0x00000001
340#define BIT1 0x00000002
341#define BIT2 0x00000004
342#define BIT3 0x00000008
343#define BIT4 0x00000010
344#define BIT5 0x00000020
345#define BIT6 0x00000040
346#define BIT7 0x00000080
347#define BIT8 0x00000100
348#define BIT9 0x00000200
349#define BIT10 0x00000400
350#define BIT11 0x00000800
351#define BIT12 0x00001000
352#define BIT13 0x00002000
353#define BIT14 0x00004000
354#define BIT15 0x00008000
355#define BIT16 0x00010000
356#define BIT17 0x00020000
357#define BIT18 0x00040000
358#define BIT19 0x00080000
359#define BIT20 0x00100000
360#define BIT21 0x00200000
361#define BIT22 0x00400000
362#define BIT23 0x00800000
363#define BIT24 0x01000000
364#define BIT25 0x02000000
365#define BIT26 0x04000000
366#define BIT27 0x08000000
367#define BIT28 0x10000000
368#define BIT29 0x20000000
369#define BIT30 0x40000000
370#define BIT31 0x80000000
371#define BIT32 0x0000000100000000ULL
372#define BIT33 0x0000000200000000ULL
373#define BIT34 0x0000000400000000ULL
374#define BIT35 0x0000000800000000ULL
375#define BIT36 0x0000001000000000ULL
376#define BIT37 0x0000002000000000ULL
377#define BIT38 0x0000004000000000ULL
378#define BIT39 0x0000008000000000ULL
379#define BIT40 0x0000010000000000ULL
380#define BIT41 0x0000020000000000ULL
381#define BIT42 0x0000040000000000ULL
382#define BIT43 0x0000080000000000ULL
383#define BIT44 0x0000100000000000ULL
384#define BIT45 0x0000200000000000ULL
385#define BIT46 0x0000400000000000ULL
386#define BIT47 0x0000800000000000ULL
387#define BIT48 0x0001000000000000ULL
388#define BIT49 0x0002000000000000ULL
389#define BIT50 0x0004000000000000ULL
390#define BIT51 0x0008000000000000ULL
391#define BIT52 0x0010000000000000ULL
392#define BIT53 0x0020000000000000ULL
393#define BIT54 0x0040000000000000ULL
394#define BIT55 0x0080000000000000ULL
395#define BIT56 0x0100000000000000ULL
396#define BIT57 0x0200000000000000ULL
397#define BIT58 0x0400000000000000ULL
398#define BIT59 0x0800000000000000ULL
399#define BIT60 0x1000000000000000ULL
400#define BIT61 0x2000000000000000ULL
401#define BIT62 0x4000000000000000ULL
402#define BIT63 0x8000000000000000ULL
403
404#define SIZE_1KB 0x00000400
405#define SIZE_2KB 0x00000800
406#define SIZE_4KB 0x00001000
407#define SIZE_8KB 0x00002000
408#define SIZE_16KB 0x00004000
409#define SIZE_32KB 0x00008000
410#define SIZE_64KB 0x00010000
411#define SIZE_128KB 0x00020000
412#define SIZE_256KB 0x00040000
413#define SIZE_512KB 0x00080000
414#define SIZE_1MB 0x00100000
415#define SIZE_2MB 0x00200000
416#define SIZE_4MB 0x00400000
417#define SIZE_8MB 0x00800000
418#define SIZE_16MB 0x01000000
419#define SIZE_32MB 0x02000000
420#define SIZE_64MB 0x04000000
421#define SIZE_128MB 0x08000000
422#define SIZE_256MB 0x10000000
423#define SIZE_512MB 0x20000000
424#define SIZE_1GB 0x40000000
425#define SIZE_2GB 0x80000000
426#define SIZE_4GB 0x0000000100000000ULL
427#define SIZE_8GB 0x0000000200000000ULL
428#define SIZE_16GB 0x0000000400000000ULL
429#define SIZE_32GB 0x0000000800000000ULL
430#define SIZE_64GB 0x0000001000000000ULL
431#define SIZE_128GB 0x0000002000000000ULL
432#define SIZE_256GB 0x0000004000000000ULL
433#define SIZE_512GB 0x0000008000000000ULL
434#define SIZE_1TB 0x0000010000000000ULL
435#define SIZE_2TB 0x0000020000000000ULL
436#define SIZE_4TB 0x0000040000000000ULL
437#define SIZE_8TB 0x0000080000000000ULL
438#define SIZE_16TB 0x0000100000000000ULL
439#define SIZE_32TB 0x0000200000000000ULL
440#define SIZE_64TB 0x0000400000000000ULL
441#define SIZE_128TB 0x0000800000000000ULL
442#define SIZE_256TB 0x0001000000000000ULL
443#define SIZE_512TB 0x0002000000000000ULL
444#define SIZE_1PB 0x0004000000000000ULL
445#define SIZE_2PB 0x0008000000000000ULL
446#define SIZE_4PB 0x0010000000000000ULL
447#define SIZE_8PB 0x0020000000000000ULL
448#define SIZE_16PB 0x0040000000000000ULL
449#define SIZE_32PB 0x0080000000000000ULL
450#define SIZE_64PB 0x0100000000000000ULL
451#define SIZE_128PB 0x0200000000000000ULL
452#define SIZE_256PB 0x0400000000000000ULL
453#define SIZE_512PB 0x0800000000000000ULL
454#define SIZE_1EB 0x1000000000000000ULL
455#define SIZE_2EB 0x2000000000000000ULL
456#define SIZE_4EB 0x4000000000000000ULL
457#define SIZE_8EB 0x8000000000000000ULL
458
459#define BASE_1KB 0x00000400
460#define BASE_2KB 0x00000800
461#define BASE_4KB 0x00001000
462#define BASE_8KB 0x00002000
463#define BASE_16KB 0x00004000
464#define BASE_32KB 0x00008000
465#define BASE_64KB 0x00010000
466#define BASE_128KB 0x00020000
467#define BASE_256KB 0x00040000
468#define BASE_512KB 0x00080000
469#define BASE_1MB 0x00100000
470#define BASE_2MB 0x00200000
471#define BASE_4MB 0x00400000
472#define BASE_8MB 0x00800000
473#define BASE_16MB 0x01000000
474#define BASE_32MB 0x02000000
475#define BASE_64MB 0x04000000
476#define BASE_128MB 0x08000000
477#define BASE_256MB 0x10000000
478#define BASE_512MB 0x20000000
479#define BASE_1GB 0x40000000
480#define BASE_2GB 0x80000000
481#define BASE_4GB 0x0000000100000000ULL
482#define BASE_8GB 0x0000000200000000ULL
483#define BASE_16GB 0x0000000400000000ULL
484#define BASE_32GB 0x0000000800000000ULL
485#define BASE_64GB 0x0000001000000000ULL
486#define BASE_128GB 0x0000002000000000ULL
487#define BASE_256GB 0x0000004000000000ULL
488#define BASE_512GB 0x0000008000000000ULL
489#define BASE_1TB 0x0000010000000000ULL
490#define BASE_2TB 0x0000020000000000ULL
491#define BASE_4TB 0x0000040000000000ULL
492#define BASE_8TB 0x0000080000000000ULL
493#define BASE_16TB 0x0000100000000000ULL
494#define BASE_32TB 0x0000200000000000ULL
495#define BASE_64TB 0x0000400000000000ULL
496#define BASE_128TB 0x0000800000000000ULL
497#define BASE_256TB 0x0001000000000000ULL
498#define BASE_512TB 0x0002000000000000ULL
499#define BASE_1PB 0x0004000000000000ULL
500#define BASE_2PB 0x0008000000000000ULL
501#define BASE_4PB 0x0010000000000000ULL
502#define BASE_8PB 0x0020000000000000ULL
503#define BASE_16PB 0x0040000000000000ULL
504#define BASE_32PB 0x0080000000000000ULL
505#define BASE_64PB 0x0100000000000000ULL
506#define BASE_128PB 0x0200000000000000ULL
507#define BASE_256PB 0x0400000000000000ULL
508#define BASE_512PB 0x0800000000000000ULL
509#define BASE_1EB 0x1000000000000000ULL
510#define BASE_2EB 0x2000000000000000ULL
511#define BASE_4EB 0x4000000000000000ULL
512#define BASE_8EB 0x8000000000000000ULL
513
514//
515// Support for variable argument lists in freestanding edk2 modules.
516//
517// For modules that use the ISO C library interfaces for variable
518// argument lists, refer to "StdLib/Include/stdarg.h".
519//
520// VA_LIST - typedef for argument list.
521// VA_START (VA_LIST Marker, argument before the ...) - Init Marker for use.
522// VA_END (VA_LIST Marker) - Clear Marker
523// VA_ARG (VA_LIST Marker, var arg type) - Use Marker to get an argument from
524// the ... list. You must know the type and pass it in this macro. Type
525// must be compatible with the type of the actual next argument (as promoted
526// according to the default argument promotions.)
527// VA_COPY (VA_LIST Dest, VA_LIST Start) - Initialize Dest as a copy of Start.
528//
529// Example:
530//
531// UINTN
532// EFIAPI
533// ExampleVarArg (
534// IN UINTN NumberOfArgs,
535// ...
536// )
537// {
538// VA_LIST Marker;
539// UINTN Index;
540// UINTN Result;
541//
542// //
543// // Initialize the Marker
544// //
545// VA_START (Marker, NumberOfArgs);
546// for (Index = 0, Result = 0; Index < NumberOfArgs; Index++) {
547// //
548// // The ... list is a series of UINTN values, so sum them up.
549// //
550// Result += VA_ARG (Marker, UINTN);
551// }
552//
553// VA_END (Marker);
554// return Result;
555// }
556//
557// Notes:
558// - Functions that call VA_START() / VA_END() must have a variable
559// argument list and must be declared EFIAPI.
560// - Functions that call VA_COPY() / VA_END() must be declared EFIAPI.
561// - Functions that only use VA_LIST and VA_ARG() need not be EFIAPI.
562//
563
571#define _INT_SIZE_OF(n) ((sizeof (n) + sizeof (UINTN) - 1) &~(sizeof (UINTN) - 1))
572
573#if defined (_M_ARM) || defined (_M_ARM64)
574//
575// MSFT ARM variable argument list support.
576//
577
578typedef char *VA_LIST;
579
580#define VA_START(Marker, Parameter) __va_start (&Marker, &Parameter, _INT_SIZE_OF (Parameter), __alignof(Parameter), &Parameter)
581#define VA_ARG(Marker, TYPE) (*(TYPE *) ((Marker += _INT_SIZE_OF (TYPE) + ((-(INTN)Marker) & (sizeof(TYPE) - 1))) - _INT_SIZE_OF (TYPE)))
582#define VA_END(Marker) (Marker = (VA_LIST) 0)
583#define VA_COPY(Dest, Start) ((void)((Dest) = (Start)))
584
585#elif defined (__GNUC__) || defined (__clang__)
586
587 #if defined (MDE_CPU_X64) && !defined (NO_MSABI_VA_FUNCS)
588//
589// X64 only. Use MS ABI version of GCC built-in macros for variable argument lists.
590//
594
599typedef __builtin_ms_va_list VA_LIST;
600
601#define VA_START(Marker, Parameter) __builtin_ms_va_start (Marker, Parameter)
602
603#define VA_ARG(Marker, TYPE) ((sizeof (TYPE) < sizeof (UINTN)) ? (TYPE)(__builtin_va_arg (Marker, UINTN)) : (TYPE)(__builtin_va_arg (Marker, TYPE)))
604
605#define VA_END(Marker) __builtin_ms_va_end (Marker)
606
607#define VA_COPY(Dest, Start) __builtin_ms_va_copy (Dest, Start)
608
609 #else
610//
611// Use GCC built-in macros for variable argument lists.
612//
613
618typedef __builtin_va_list VA_LIST;
619
620#define VA_START(Marker, Parameter) __builtin_va_start (Marker, Parameter)
621
622#define VA_ARG(Marker, TYPE) ((sizeof (TYPE) < sizeof (UINTN)) ? (TYPE)(__builtin_va_arg (Marker, UINTN)) : (TYPE)(__builtin_va_arg (Marker, TYPE)))
623
624#define VA_END(Marker) __builtin_va_end (Marker)
625
626#define VA_COPY(Dest, Start) __builtin_va_copy (Dest, Start)
627
628 #endif
629
630#else
635typedef CHAR8 *VA_LIST;
636
653#define VA_START(Marker, Parameter) (Marker = (VA_LIST) ((UINTN) & (Parameter) + _INT_SIZE_OF (Parameter)))
654
671#define VA_ARG(Marker, TYPE) (*(TYPE *) ((Marker += _INT_SIZE_OF (TYPE)) - _INT_SIZE_OF (TYPE)))
672
683#define VA_END(Marker) (Marker = (VA_LIST) 0)
684
696#define VA_COPY(Dest, Start) ((void)((Dest) = (Start)))
697
698#endif
699
704
712#define _BASE_INT_SIZE_OF(TYPE) ((sizeof (TYPE) + sizeof (UINTN) - 1) / sizeof (UINTN))
713
730#define BASE_ARG(Marker, TYPE) (*(TYPE *) ((Marker += _BASE_INT_SIZE_OF (TYPE)) - _BASE_INT_SIZE_OF (TYPE)))
731
745#if (defined (__GNUC__) && __GNUC__ >= 4) || defined (__clang__)
746#define OFFSET_OF(TYPE, Field) ((UINTN) __builtin_offsetof(TYPE, Field))
747#endif
748
749#ifndef OFFSET_OF
750#define OFFSET_OF(TYPE, Field) ((UINTN) &(((TYPE *)0)->Field))
751#endif
752
761#ifdef MDE_CPU_EBC
762#define STATIC_ASSERT(Expression, Message)
763#elif defined (_MSC_EXTENSIONS)
764#define STATIC_ASSERT static_assert
765#else
766#define STATIC_ASSERT _Static_assert
767#endif
768
769//
770// Verify that ProcessorBind.h produced UEFI Data Types that are compliant with
771// Section 2.3.1 of the UEFI 2.3 Specification.
772//
773
774STATIC_ASSERT (sizeof (BOOLEAN) == 1, "sizeof (BOOLEAN) does not meet UEFI Specification Data Type requirements");
775STATIC_ASSERT (sizeof (INT8) == 1, "sizeof (INT8) does not meet UEFI Specification Data Type requirements");
776STATIC_ASSERT (sizeof (UINT8) == 1, "sizeof (UINT8) does not meet UEFI Specification Data Type requirements");
777STATIC_ASSERT (sizeof (INT16) == 2, "sizeof (INT16) does not meet UEFI Specification Data Type requirements");
778STATIC_ASSERT (sizeof (UINT16) == 2, "sizeof (UINT16) does not meet UEFI Specification Data Type requirements");
779STATIC_ASSERT (sizeof (INT32) == 4, "sizeof (INT32) does not meet UEFI Specification Data Type requirements");
780STATIC_ASSERT (sizeof (UINT32) == 4, "sizeof (UINT32) does not meet UEFI Specification Data Type requirements");
781STATIC_ASSERT (sizeof (INT64) == 8, "sizeof (INT64) does not meet UEFI Specification Data Type requirements");
782STATIC_ASSERT (sizeof (UINT64) == 8, "sizeof (UINT64) does not meet UEFI Specification Data Type requirements");
783STATIC_ASSERT (sizeof (CHAR8) == 1, "sizeof (CHAR8) does not meet UEFI Specification Data Type requirements");
784STATIC_ASSERT (sizeof (CHAR16) == 2, "sizeof (CHAR16) does not meet UEFI Specification Data Type requirements");
785STATIC_ASSERT (sizeof (L'A') == 2, "sizeof (L'A') does not meet UEFI Specification Data Type requirements");
786STATIC_ASSERT (sizeof (L"A") == 4, "sizeof (L\"A\") does not meet UEFI Specification Data Type requirements");
787
788//
789// The following three enum types are used to verify that the compiler
790// configuration for enum types is compliant with Section 2.3.1 of the
791// UEFI 2.3 Specification. These enum types and enum values are not
792// intended to be used. A prefix of '__' is used avoid conflicts with
793// other types.
794//
795typedef enum {
796 __VerifyUint8EnumValue = 0xff
797} __VERIFY_UINT8_ENUM_SIZE;
798
799typedef enum {
800 __VerifyUint16EnumValue = 0xffff
801} __VERIFY_UINT16_ENUM_SIZE;
802
803typedef enum {
804 __VerifyUint32EnumValue = 0xffffffff
805} __VERIFY_UINT32_ENUM_SIZE;
806
807STATIC_ASSERT (sizeof (__VERIFY_UINT8_ENUM_SIZE) == 4, "Size of enum does not meet UEFI Specification Data Type requirements");
808STATIC_ASSERT (sizeof (__VERIFY_UINT16_ENUM_SIZE) == 4, "Size of enum does not meet UEFI Specification Data Type requirements");
809STATIC_ASSERT (sizeof (__VERIFY_UINT32_ENUM_SIZE) == 4, "Size of enum does not meet UEFI Specification Data Type requirements");
810
830#define BASE_CR(Record, TYPE, Field) ((TYPE *) ((CHAR8 *) (Record) - OFFSET_OF (TYPE, Field)))
831
844#define ALIGN_VALUE(Value, Alignment) ((Value) + (((Alignment) - (Value)) & ((Alignment) - 1)))
845
859#define ALIGN_POINTER(Pointer, Alignment) ((VOID *) (ALIGN_VALUE ((UINTN)(Pointer), (Alignment))))
860
873#define ALIGN_VARIABLE(Value) ALIGN_VALUE ((Value), sizeof (UINTN))
874
888#define MAX(a, b) \
889 (((a) > (b)) ? (a) : (b))
890
903#define MIN(a, b) \
904 (((a) < (b)) ? (a) : (b))
905
916#define ABS(a) \
917 (((a) < 0) ? (-(a)) : (a))
918
919//
920// Status codes common to all execution phases
921//
922typedef UINTN RETURN_STATUS;
923
933#define ENCODE_ERROR(StatusCode) ((RETURN_STATUS)(MAX_BIT | (StatusCode)))
934
944#define ENCODE_WARNING(StatusCode) ((RETURN_STATUS)(StatusCode))
945
957#define RETURN_ERROR(StatusCode) (((INTN)(RETURN_STATUS)(StatusCode)) < 0)
958
962#define RETURN_SUCCESS 0
963
967#define RETURN_LOAD_ERROR ENCODE_ERROR (1)
968
972#define RETURN_INVALID_PARAMETER ENCODE_ERROR (2)
973
977#define RETURN_UNSUPPORTED ENCODE_ERROR (3)
978
982#define RETURN_BAD_BUFFER_SIZE ENCODE_ERROR (4)
983
989#define RETURN_BUFFER_TOO_SMALL ENCODE_ERROR (5)
990
994#define RETURN_NOT_READY ENCODE_ERROR (6)
995
1000#define RETURN_DEVICE_ERROR ENCODE_ERROR (7)
1001
1005#define RETURN_WRITE_PROTECTED ENCODE_ERROR (8)
1006
1010#define RETURN_OUT_OF_RESOURCES ENCODE_ERROR (9)
1011
1016#define RETURN_VOLUME_CORRUPTED ENCODE_ERROR (10)
1017
1021#define RETURN_VOLUME_FULL ENCODE_ERROR (11)
1022
1027#define RETURN_NO_MEDIA ENCODE_ERROR (12)
1028
1033#define RETURN_MEDIA_CHANGED ENCODE_ERROR (13)
1034
1038#define RETURN_NOT_FOUND ENCODE_ERROR (14)
1039
1043#define RETURN_ACCESS_DENIED ENCODE_ERROR (15)
1044
1048#define RETURN_NO_RESPONSE ENCODE_ERROR (16)
1049
1053#define RETURN_NO_MAPPING ENCODE_ERROR (17)
1054
1058#define RETURN_TIMEOUT ENCODE_ERROR (18)
1059
1063#define RETURN_NOT_STARTED ENCODE_ERROR (19)
1064
1068#define RETURN_ALREADY_STARTED ENCODE_ERROR (20)
1069
1073#define RETURN_ABORTED ENCODE_ERROR (21)
1074
1078#define RETURN_ICMP_ERROR ENCODE_ERROR (22)
1079
1083#define RETURN_TFTP_ERROR ENCODE_ERROR (23)
1084
1088#define RETURN_PROTOCOL_ERROR ENCODE_ERROR (24)
1089
1094#define RETURN_INCOMPATIBLE_VERSION ENCODE_ERROR (25)
1095
1099#define RETURN_SECURITY_VIOLATION ENCODE_ERROR (26)
1100
1104#define RETURN_CRC_ERROR ENCODE_ERROR (27)
1105
1109#define RETURN_END_OF_MEDIA ENCODE_ERROR (28)
1110
1114#define RETURN_END_OF_FILE ENCODE_ERROR (31)
1115
1119#define RETURN_INVALID_LANGUAGE ENCODE_ERROR (32)
1120
1126#define RETURN_COMPROMISED_DATA ENCODE_ERROR (33)
1127
1131#define RETURN_HTTP_ERROR ENCODE_ERROR (35)
1132
1137#define RETURN_WARN_UNKNOWN_GLYPH ENCODE_WARNING (1)
1138
1142#define RETURN_WARN_DELETE_FAILURE ENCODE_WARNING (2)
1143
1148#define RETURN_WARN_WRITE_FAILURE ENCODE_WARNING (3)
1149
1154#define RETURN_WARN_BUFFER_TOO_SMALL ENCODE_WARNING (4)
1155
1160#define RETURN_WARN_STALE_DATA ENCODE_WARNING (5)
1161
1165#define RETURN_WARN_FILE_SYSTEM ENCODE_WARNING (6)
1166
1179#define SIGNATURE_16(A, B) ((A) | (B << 8))
1180
1196#define SIGNATURE_32(A, B, C, D) (SIGNATURE_16 (A, B) | (SIGNATURE_16 (C, D) << 16))
1197
1217#define SIGNATURE_64(A, B, C, D, E, F, G, H) \
1218 (SIGNATURE_32 (A, B, C, D) | ((UINT64) (SIGNATURE_32 (E, F, G, H)) << 32))
1219
1220#if defined (_MSC_EXTENSIONS) && !defined (__INTEL_COMPILER) && !defined (MDE_CPU_EBC)
1221void *
1222_ReturnAddress (
1223 void
1224 );
1225
1226 #pragma intrinsic(_ReturnAddress)
1227
1240#define RETURN_ADDRESS(L) ((L == 0) ? _ReturnAddress() : (VOID *) 0)
1241#elif defined (__GNUC__) || defined (__clang__)
1242
1254#define RETURN_ADDRESS(L) __builtin_return_address (L)
1255#else
1256
1265#define RETURN_ADDRESS(L) ((VOID *) 0)
1266#endif
1267
1279#define ARRAY_SIZE(Array) (sizeof (Array) / sizeof ((Array)[0]))
1280
1281#endif
UINT64 UINTN
#define STATIC_ASSERT
Definition: Base.h:766
CHAR8 * VA_LIST
Definition: Base.h:635
UINTN * BASE_LIST
Definition: Base.h:703
Definition: Base.h:213