OvmfPkg/XenBusDxe: Fix a nasm warning about instruction not lockable.
[mirror_edk2.git] / MdePkg / Include / Base.h
CommitLineData
959ccb23 1/** @file\r
959ccb23 2 Root include file for Mde Package Base type modules\r
3\r
818ff8c2 4 This is the include file for any module of type base. Base modules only use\r
5 types defined via this include file and can be ported easily to any\r
959ccb23 6 environment. There are a set of base libraries in the Mde Package that can\r
7 be used to implement base modules.\r
8\r
dad83a8c 9Copyright (c) 2006 - 2014, Intel Corporation. All rights reserved.<BR>\r
9df063a0
HT
10Portions copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>\r
11This program and the accompanying materials\r
959ccb23 12are licensed and made available under the terms and conditions of the BSD License\r
13which accompanies this distribution. The full text of the license may be found at\r
af2dc6a7 14http://opensource.org/licenses/bsd-license.php.\r
959ccb23 15\r
16THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
17WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
18\r
19**/\r
20\r
21\r
22#ifndef __BASE_H__\r
23#define __BASE_H__\r
24\r
25//\r
26// Include processor specific binding\r
27//\r
28#include <ProcessorBind.h>\r
29\r
6c3fa13c 30\r
31/**\r
32 Verifies the storage size of a given data type.\r
818ff8c2 33\r
6c3fa13c 34 This macro generates a divide by zero error or a zero size array declaration in\r
35 the preprocessor if the size is incorrect. These are declared as "extern" so\r
36 the space for these arrays will not be in the modules.\r
37\r
38 @param TYPE The date type to determine the size of.\r
39 @param Size The expected size for the TYPE.\r
40\r
41**/\r
42#define VERIFY_SIZE_OF(TYPE, Size) extern UINT8 _VerifySizeof##TYPE[(sizeof(TYPE) == (Size)) / (sizeof(TYPE) == (Size))]\r
43\r
52aa9e13 44//\r
818ff8c2 45// Verify that ProcessorBind.h produced UEFI Data Types that are compliant with\r
46// Section 2.3.1 of the UEFI 2.3 Specification.\r
52aa9e13 47//\r
6c3fa13c 48VERIFY_SIZE_OF (BOOLEAN, 1);\r
49VERIFY_SIZE_OF (INT8, 1);\r
50VERIFY_SIZE_OF (UINT8, 1);\r
51VERIFY_SIZE_OF (INT16, 2);\r
52VERIFY_SIZE_OF (UINT16, 2);\r
53VERIFY_SIZE_OF (INT32, 4);\r
54VERIFY_SIZE_OF (UINT32, 4);\r
55VERIFY_SIZE_OF (INT64, 8);\r
56VERIFY_SIZE_OF (UINT64, 8);\r
57VERIFY_SIZE_OF (CHAR8, 1);\r
58VERIFY_SIZE_OF (CHAR16, 2);\r
52aa9e13 59\r
dda3a6ce 60//\r
61// The Microsoft* C compiler can removed references to unreferenced data items\r
818ff8c2 62// if the /OPT:REF linker option is used. We defined a macro as this is a\r
dda3a6ce 63// a non standard extension\r
64//\r
ab00035d 65#if defined(_MSC_EXTENSIONS) && !defined (MDE_CPU_EBC)\r
dda3a6ce 66 ///\r
818ff8c2 67 /// Remove global variable from the linked image if there are no references to\r
dda3a6ce 68 /// it after all compiler and linker optimizations have been performed.\r
69 ///\r
70 ///\r
71 #define GLOBAL_REMOVE_IF_UNREFERENCED __declspec(selectany)\r
72#else\r
73 ///\r
818ff8c2 74 /// Remove the global variable from the linked image if there are no references\r
af2dc6a7 75 /// to it after all compiler and linker optimizations have been performed.\r
dda3a6ce 76 ///\r
77 ///\r
78 #define GLOBAL_REMOVE_IF_UNREFERENCED\r
79#endif\r
80\r
81//\r
02eef553 82// For symbol name in assembly code, an extra "_" is sometimes necessary\r
dda3a6ce 83//\r
dda3a6ce 84\r
02eef553
JJ
85///\r
86/// Private worker functions for ASM_PFX()\r
87///\r
88#define _CONCATENATE(a, b) __CONCATENATE(a, b)\r
89#define __CONCATENATE(a, b) a ## b\r
90\r
91///\r
92/// The __USER_LABEL_PREFIX__ macro predefined by GNUC represents the prefix\r
93/// on symbols in assembly language.\r
94///\r
95#define ASM_PFX(name) _CONCATENATE (__USER_LABEL_PREFIX__, name)\r
dda3a6ce 96\r
97#if __APPLE__\r
98 //\r
818ff8c2 99 // Apple extension that is used by the linker to optimize code size\r
dda3a6ce 100 // with assembly functions. Put at the end of your .S files\r
101 //\r
102 #define ASM_FUNCTION_REMOVE_IF_UNREFERENCED .subsections_via_symbols\r
103#else\r
104 #define ASM_FUNCTION_REMOVE_IF_UNREFERENCED\r
105#endif\r
106\r
107#ifdef __CC_ARM\r
108 //\r
818ff8c2 109 // Older RVCT ARM compilers don't fully support #pragma pack and require __packed\r
dda3a6ce 110 // as a prefix for the structure.\r
111 //\r
112 #define PACKED __packed\r
113#else\r
114 #define PACKED\r
115#endif\r
116\r
f4ec40ab 117///\r
818ff8c2 118/// 128 bit buffer containing a unique identifier value.\r
f4ec40ab 119/// Unless otherwise specified, aligned on a 64 bit boundary.\r
120///\r
959ccb23 121typedef struct {\r
122 UINT32 Data1;\r
123 UINT16 Data2;\r
124 UINT16 Data3;\r
125 UINT8 Data4[8];\r
126} GUID;\r
127\r
3963c4bf 128//\r
129// 8-bytes unsigned value that represents a physical system address.\r
130//\r
959ccb23 131typedef UINT64 PHYSICAL_ADDRESS;\r
132\r
62991af2 133///\r
f4ec40ab 134/// LIST_ENTRY structure definition.\r
62991af2 135///\r
959ccb23 136typedef struct _LIST_ENTRY LIST_ENTRY;\r
137\r
f4ec40ab 138///\r
139/// _LIST_ENTRY structure definition.\r
140///\r
959ccb23 141struct _LIST_ENTRY {\r
142 LIST_ENTRY *ForwardLink;\r
143 LIST_ENTRY *BackLink;\r
144};\r
145\r
146//\r
3963c4bf 147// Modifiers to abstract standard types to aid in debug of problems\r
959ccb23 148//\r
f4ec40ab 149\r
150///\r
af2dc6a7 151/// Datum is read-only.\r
f4ec40ab 152///\r
959ccb23 153#define CONST const\r
f4ec40ab 154\r
155///\r
af2dc6a7 156/// Datum is scoped to the current file or function.\r
f4ec40ab 157///\r
959ccb23 158#define STATIC static\r
f4ec40ab 159\r
160///\r
af2dc6a7 161/// Undeclared type.\r
f4ec40ab 162///\r
959ccb23 163#define VOID void\r
164\r
165//\r
166// Modifiers for Data Types used to self document code.\r
167// This concept is borrowed for UEFI specification.\r
168//\r
f4ec40ab 169\r
170///\r
af2dc6a7 171/// Datum is passed to the function.\r
f4ec40ab 172///\r
959ccb23 173#define IN\r
f4ec40ab 174\r
175///\r
af2dc6a7 176/// Datum is returned from the function.\r
f4ec40ab 177///\r
959ccb23 178#define OUT\r
f4ec40ab 179\r
180///\r
181/// Passing the datum to the function is optional, and a NULL\r
af2dc6a7 182/// is passed if the value is not supplied.\r
f4ec40ab 183///\r
959ccb23 184#define OPTIONAL\r
959ccb23 185\r
959ccb23 186//\r
818ff8c2 187// UEFI specification claims 1 and 0. We are concerned about the\r
959ccb23 188// complier portability so we did it this way.\r
189//\r
f4ec40ab 190\r
191///\r
192/// Boolean true value. UEFI Specification defines this value to be 1,\r
193/// but this form is more portable.\r
194///\r
959ccb23 195#define TRUE ((BOOLEAN)(1==1))\r
f4ec40ab 196\r
197///\r
198/// Boolean false value. UEFI Specification defines this value to be 0,\r
199/// but this form is more portable.\r
200///\r
959ccb23 201#define FALSE ((BOOLEAN)(0==1))\r
959ccb23 202\r
f4ec40ab 203///\r
204/// NULL pointer (VOID *)\r
205///\r
959ccb23 206#define NULL ((VOID *) 0)\r
959ccb23 207\r
068a82fc
LG
208///\r
209/// Maximum values for common UEFI Data Types\r
210///\r
211#define MAX_INT8 ((INT8)0x7F)\r
212#define MAX_UINT8 ((UINT8)0xFF)\r
213#define MAX_INT16 ((INT16)0x7FFF)\r
214#define MAX_UINT16 ((UINT16)0xFFFF)\r
215#define MAX_INT32 ((INT32)0x7FFFFFFF)\r
216#define MAX_UINT32 ((UINT32)0xFFFFFFFF)\r
217#define MAX_INT64 ((INT64)0x7FFFFFFFFFFFFFFFULL)\r
218#define MAX_UINT64 ((UINT64)0xFFFFFFFFFFFFFFFFULL)\r
3963c4bf 219\r
959ccb23 220#define BIT0 0x00000001\r
221#define BIT1 0x00000002\r
222#define BIT2 0x00000004\r
223#define BIT3 0x00000008\r
224#define BIT4 0x00000010\r
225#define BIT5 0x00000020\r
226#define BIT6 0x00000040\r
227#define BIT7 0x00000080\r
228#define BIT8 0x00000100\r
229#define BIT9 0x00000200\r
230#define BIT10 0x00000400\r
231#define BIT11 0x00000800\r
232#define BIT12 0x00001000\r
233#define BIT13 0x00002000\r
234#define BIT14 0x00004000\r
235#define BIT15 0x00008000\r
236#define BIT16 0x00010000\r
237#define BIT17 0x00020000\r
238#define BIT18 0x00040000\r
239#define BIT19 0x00080000\r
240#define BIT20 0x00100000\r
241#define BIT21 0x00200000\r
242#define BIT22 0x00400000\r
243#define BIT23 0x00800000\r
244#define BIT24 0x01000000\r
245#define BIT25 0x02000000\r
246#define BIT26 0x04000000\r
247#define BIT27 0x08000000\r
248#define BIT28 0x10000000\r
249#define BIT29 0x20000000\r
250#define BIT30 0x40000000\r
251#define BIT31 0x80000000\r
4d24730c 252#define BIT32 0x0000000100000000ULL\r
253#define BIT33 0x0000000200000000ULL\r
254#define BIT34 0x0000000400000000ULL\r
255#define BIT35 0x0000000800000000ULL\r
256#define BIT36 0x0000001000000000ULL\r
257#define BIT37 0x0000002000000000ULL\r
258#define BIT38 0x0000004000000000ULL\r
259#define BIT39 0x0000008000000000ULL\r
260#define BIT40 0x0000010000000000ULL\r
261#define BIT41 0x0000020000000000ULL\r
262#define BIT42 0x0000040000000000ULL\r
263#define BIT43 0x0000080000000000ULL\r
264#define BIT44 0x0000100000000000ULL\r
265#define BIT45 0x0000200000000000ULL\r
266#define BIT46 0x0000400000000000ULL\r
267#define BIT47 0x0000800000000000ULL\r
268#define BIT48 0x0001000000000000ULL\r
269#define BIT49 0x0002000000000000ULL\r
270#define BIT50 0x0004000000000000ULL\r
271#define BIT51 0x0008000000000000ULL\r
272#define BIT52 0x0010000000000000ULL\r
273#define BIT53 0x0020000000000000ULL\r
274#define BIT54 0x0040000000000000ULL\r
275#define BIT55 0x0080000000000000ULL\r
276#define BIT56 0x0100000000000000ULL\r
277#define BIT57 0x0200000000000000ULL\r
278#define BIT58 0x0400000000000000ULL\r
279#define BIT59 0x0800000000000000ULL\r
280#define BIT60 0x1000000000000000ULL\r
281#define BIT61 0x2000000000000000ULL\r
282#define BIT62 0x4000000000000000ULL\r
283#define BIT63 0x8000000000000000ULL\r
959ccb23 284\r
2e121e9a 285#define SIZE_1KB 0x00000400\r
286#define SIZE_2KB 0x00000800\r
287#define SIZE_4KB 0x00001000\r
288#define SIZE_8KB 0x00002000\r
289#define SIZE_16KB 0x00004000\r
290#define SIZE_32KB 0x00008000\r
291#define SIZE_64KB 0x00010000\r
292#define SIZE_128KB 0x00020000\r
293#define SIZE_256KB 0x00040000\r
294#define SIZE_512KB 0x00080000\r
295#define SIZE_1MB 0x00100000\r
296#define SIZE_2MB 0x00200000\r
297#define SIZE_4MB 0x00400000\r
298#define SIZE_8MB 0x00800000\r
299#define SIZE_16MB 0x01000000\r
300#define SIZE_32MB 0x02000000\r
301#define SIZE_64MB 0x04000000\r
302#define SIZE_128MB 0x08000000\r
303#define SIZE_256MB 0x10000000\r
304#define SIZE_512MB 0x20000000\r
305#define SIZE_1GB 0x40000000\r
306#define SIZE_2GB 0x80000000\r
307#define SIZE_4GB 0x0000000100000000ULL\r
308#define SIZE_8GB 0x0000000200000000ULL\r
309#define SIZE_16GB 0x0000000400000000ULL\r
310#define SIZE_32GB 0x0000000800000000ULL\r
311#define SIZE_64GB 0x0000001000000000ULL\r
312#define SIZE_128GB 0x0000002000000000ULL\r
313#define SIZE_256GB 0x0000004000000000ULL\r
314#define SIZE_512GB 0x0000008000000000ULL\r
315#define SIZE_1TB 0x0000010000000000ULL\r
316#define SIZE_2TB 0x0000020000000000ULL\r
317#define SIZE_4TB 0x0000040000000000ULL\r
318#define SIZE_8TB 0x0000080000000000ULL\r
319#define SIZE_16TB 0x0000100000000000ULL\r
320#define SIZE_32TB 0x0000200000000000ULL\r
321#define SIZE_64TB 0x0000400000000000ULL\r
322#define SIZE_128TB 0x0000800000000000ULL\r
323#define SIZE_256TB 0x0001000000000000ULL\r
324#define SIZE_512TB 0x0002000000000000ULL\r
325#define SIZE_1PB 0x0004000000000000ULL\r
326#define SIZE_2PB 0x0008000000000000ULL\r
327#define SIZE_4PB 0x0010000000000000ULL\r
328#define SIZE_8PB 0x0020000000000000ULL\r
329#define SIZE_16PB 0x0040000000000000ULL\r
330#define SIZE_32PB 0x0080000000000000ULL\r
331#define SIZE_64PB 0x0100000000000000ULL\r
332#define SIZE_128PB 0x0200000000000000ULL\r
333#define SIZE_256PB 0x0400000000000000ULL\r
334#define SIZE_512PB 0x0800000000000000ULL\r
335#define SIZE_1EB 0x1000000000000000ULL\r
336#define SIZE_2EB 0x2000000000000000ULL\r
337#define SIZE_4EB 0x4000000000000000ULL\r
338#define SIZE_8EB 0x8000000000000000ULL\r
818ff8c2 339\r
2e121e9a 340#define BASE_1KB 0x00000400\r
341#define BASE_2KB 0x00000800\r
342#define BASE_4KB 0x00001000\r
343#define BASE_8KB 0x00002000\r
344#define BASE_16KB 0x00004000\r
345#define BASE_32KB 0x00008000\r
346#define BASE_64KB 0x00010000\r
347#define BASE_128KB 0x00020000\r
348#define BASE_256KB 0x00040000\r
349#define BASE_512KB 0x00080000\r
350#define BASE_1MB 0x00100000\r
351#define BASE_2MB 0x00200000\r
352#define BASE_4MB 0x00400000\r
353#define BASE_8MB 0x00800000\r
354#define BASE_16MB 0x01000000\r
355#define BASE_32MB 0x02000000\r
356#define BASE_64MB 0x04000000\r
357#define BASE_128MB 0x08000000\r
358#define BASE_256MB 0x10000000\r
359#define BASE_512MB 0x20000000\r
360#define BASE_1GB 0x40000000\r
361#define BASE_2GB 0x80000000\r
362#define BASE_4GB 0x0000000100000000ULL\r
363#define BASE_8GB 0x0000000200000000ULL\r
364#define BASE_16GB 0x0000000400000000ULL\r
365#define BASE_32GB 0x0000000800000000ULL\r
366#define BASE_64GB 0x0000001000000000ULL\r
367#define BASE_128GB 0x0000002000000000ULL\r
368#define BASE_256GB 0x0000004000000000ULL\r
369#define BASE_512GB 0x0000008000000000ULL\r
370#define BASE_1TB 0x0000010000000000ULL\r
371#define BASE_2TB 0x0000020000000000ULL\r
372#define BASE_4TB 0x0000040000000000ULL\r
373#define BASE_8TB 0x0000080000000000ULL\r
374#define BASE_16TB 0x0000100000000000ULL\r
375#define BASE_32TB 0x0000200000000000ULL\r
376#define BASE_64TB 0x0000400000000000ULL\r
377#define BASE_128TB 0x0000800000000000ULL\r
378#define BASE_256TB 0x0001000000000000ULL\r
379#define BASE_512TB 0x0002000000000000ULL\r
380#define BASE_1PB 0x0004000000000000ULL\r
381#define BASE_2PB 0x0008000000000000ULL\r
382#define BASE_4PB 0x0010000000000000ULL\r
383#define BASE_8PB 0x0020000000000000ULL\r
384#define BASE_16PB 0x0040000000000000ULL\r
385#define BASE_32PB 0x0080000000000000ULL\r
386#define BASE_64PB 0x0100000000000000ULL\r
387#define BASE_128PB 0x0200000000000000ULL\r
388#define BASE_256PB 0x0400000000000000ULL\r
389#define BASE_512PB 0x0800000000000000ULL\r
390#define BASE_1EB 0x1000000000000000ULL\r
391#define BASE_2EB 0x2000000000000000ULL\r
392#define BASE_4EB 0x4000000000000000ULL\r
393#define BASE_8EB 0x8000000000000000ULL\r
394\r
959ccb23 395//\r
396// Support for variable length argument lists using the ANSI standard.\r
818ff8c2 397//\r
3963c4bf 398// Since we are using the ANSI standard we used the standard naming and\r
399// did not follow the coding convention\r
959ccb23 400//\r
401// VA_LIST - typedef for argument list.\r
402// VA_START (VA_LIST Marker, argument before the ...) - Init Marker for use.\r
403// VA_END (VA_LIST Marker) - Clear Marker\r
3963c4bf 404// VA_ARG (VA_LIST Marker, var arg size) - Use Marker to get an argument from\r
959ccb23 405// the ... list. You must know the size and pass it in this macro.\r
265fa9fa 406// VA_COPY (VA_LIST Dest, VA_LIST Start) - Initialize Dest as a copy of Start.\r
959ccb23 407//\r
408// example:\r
409//\r
410// UINTN\r
411// ExampleVarArg (\r
412// IN UINTN NumberOfArgs,\r
413// ...\r
414// )\r
415// {\r
416// VA_LIST Marker;\r
417// UINTN Index;\r
418// UINTN Result;\r
419//\r
420// //\r
421// // Initialize the Marker\r
422// //\r
423// VA_START (Marker, NumberOfArgs);\r
424// for (Index = 0, Result = 0; Index < NumberOfArgs; Index++) {\r
425// //\r
426// // The ... list is a series of UINTN values, so average them up.\r
427// //\r
428// Result += VA_ARG (Marker, UINTN);\r
429// }\r
430//\r
431// VA_END (Marker);\r
432// return Result\r
433// }\r
434//\r
0dcec411 435\r
68167fed 436/**\r
437 Return the size of argument that has been aligned to sizeof (UINTN).\r
438\r
af2dc6a7 439 @param n The parameter size to be aligned.\r
68167fed 440\r
af2dc6a7 441 @return The aligned size.\r
68167fed 442**/\r
443#define _INT_SIZE_OF(n) ((sizeof (n) + sizeof (UINTN) - 1) &~(sizeof (UINTN) - 1))\r
444\r
dda3a6ce 445#if defined(__CC_ARM)\r
446//\r
447// RVCT ARM variable argument list support.\r
448//\r
449\r
450///\r
818ff8c2 451/// Variable used to traverse the list of arguments. This type can vary by\r
452/// implementation and could be an array or structure.\r
dda3a6ce 453///\r
454#ifdef __APCS_ADSABI\r
455 typedef int *va_list[1];\r
456 #define VA_LIST va_list\r
457#else\r
458 typedef struct __va_list { void *__ap; } va_list;\r
459 #define VA_LIST va_list\r
460#endif\r
461\r
462#define VA_START(Marker, Parameter) __va_start(Marker, Parameter)\r
463\r
464#define VA_ARG(Marker, TYPE) __va_arg(Marker, TYPE)\r
465\r
466#define VA_END(Marker) ((void)0)\r
467\r
7bbc624a 468// For some ARM RVCT compilers, __va_copy is not defined\r
469#ifndef __va_copy\r
470 #define __va_copy(dest, src) ((void)((dest) = (src)))\r
471#endif\r
472\r
265fa9fa 473#define VA_COPY(Dest, Start) __va_copy (Dest, Start)\r
474\r
4e716b67 475#elif defined(__GNUC__) && !defined(NO_BUILTIN_VA_FUNCS)\r
130a2eec 476//\r
1a2f870c 477// Use GCC built-in macros for variable argument lists.\r
130a2eec 478//\r
dda3a6ce 479\r
480///\r
818ff8c2 481/// Variable used to traverse the list of arguments. This type can vary by\r
482/// implementation and could be an array or structure.\r
dda3a6ce 483///\r
130a2eec 484typedef __builtin_va_list VA_LIST;\r
485\r
6ed623e4 486#define VA_START(Marker, Parameter) __builtin_va_start (Marker, Parameter)\r
959ccb23 487\r
6ed623e4 488#define VA_ARG(Marker, TYPE) ((sizeof (TYPE) < sizeof (UINTN)) ? (TYPE)(__builtin_va_arg (Marker, UINTN)) : (TYPE)(__builtin_va_arg (Marker, TYPE)))\r
130a2eec 489\r
6ed623e4 490#define VA_END(Marker) __builtin_va_end (Marker)\r
130a2eec 491\r
265fa9fa 492#define VA_COPY(Dest, Start) __builtin_va_copy (Dest, Start)\r
493\r
130a2eec 494#else\r
f4ec40ab 495///\r
818ff8c2 496/// Variable used to traverse the list of arguments. This type can vary by\r
497/// implementation and could be an array or structure.\r
f4ec40ab 498///\r
959ccb23 499typedef CHAR8 *VA_LIST;\r
959ccb23 500\r
3963c4bf 501/**\r
818ff8c2 502 Retrieves a pointer to the beginning of a variable argument list, based on\r
503 the name of the parameter that immediately precedes the variable argument list.\r
3963c4bf 504\r
818ff8c2 505 This function initializes Marker to point to the beginning of the variable\r
506 argument list that immediately follows Parameter. The method for computing the\r
507 pointer to the next argument in the argument list is CPU-specific following the\r
af2dc6a7 508 EFIAPI ABI.\r
3963c4bf 509\r
af2dc6a7 510 @param Marker The VA_LIST used to traverse the list of arguments.\r
818ff8c2 511 @param Parameter The name of the parameter that immediately precedes\r
3963c4bf 512 the variable argument list.\r
818ff8c2 513\r
3963c4bf 514 @return A pointer to the beginning of a variable argument list.\r
515\r
516**/\r
a58b9d96 517#define VA_START(Marker, Parameter) (Marker = (VA_LIST) ((UINTN) & (Parameter) + _INT_SIZE_OF (Parameter)))\r
3963c4bf 518\r
519/**\r
818ff8c2 520 Returns an argument of a specified type from a variable argument list and updates\r
521 the pointer to the variable argument list to point to the next argument.\r
3963c4bf 522\r
818ff8c2 523 This function returns an argument of the type specified by TYPE from the beginning\r
524 of the variable argument list specified by Marker. Marker is then updated to point\r
525 to the next argument in the variable argument list. The method for computing the\r
af2dc6a7 526 pointer to the next argument in the argument list is CPU-specific following the EFIAPI ABI.\r
3963c4bf 527\r
dda3a6ce 528 @param Marker VA_LIST used to traverse the list of arguments.\r
818ff8c2 529 @param TYPE The type of argument to retrieve from the beginning\r
3963c4bf 530 of the variable argument list.\r
818ff8c2 531\r
3963c4bf 532 @return An argument of the type specified by TYPE.\r
533\r
534**/\r
535#define VA_ARG(Marker, TYPE) (*(TYPE *) ((Marker += _INT_SIZE_OF (TYPE)) - _INT_SIZE_OF (TYPE)))\r
536\r
537/**\r
538 Terminates the use of a variable argument list.\r
539\r
818ff8c2 540 This function initializes Marker so it can no longer be used with VA_ARG().\r
541 After this macro is used, the only way to access the variable argument list is\r
3963c4bf 542 by using VA_START() again.\r
543\r
dda3a6ce 544 @param Marker VA_LIST used to traverse the list of arguments.\r
818ff8c2 545\r
3963c4bf 546**/\r
547#define VA_END(Marker) (Marker = (VA_LIST) 0)\r
548\r
265fa9fa 549/**\r
550 Initializes a VA_LIST as a copy of an existing VA_LIST.\r
551\r
552 This macro initializes Dest as a copy of Start, as if the VA_START macro had been applied to Dest\r
553 followed by the same sequence of uses of the VA_ARG macro as had previously been used to reach\r
554 the present state of Start. \r
555\r
556 @param Dest VA_LIST used to traverse the list of arguments.\r
557 @param Start VA_LIST used to traverse the list of arguments.\r
558\r
559**/\r
560#define VA_COPY(Dest, Start) ((void)((Dest) = (Start)))\r
561\r
130a2eec 562#endif\r
563\r
68167fed 564///\r
565/// Pointer to the start of a variable argument list stored in a memory buffer. Same as UINT8 *.\r
566///\r
567typedef UINTN *BASE_LIST;\r
568\r
2229029a 569/**\r
570 Returns the size of a data type in sizeof(UINTN) units rounded up to the nearest UINTN boundary.\r
571\r
572 @param TYPE The date type to determine the size of.\r
573\r
574 @return The size of TYPE in sizeof (UINTN) units rounded up to the nearest UINTN boundary.\r
575**/\r
576#define _BASE_INT_SIZE_OF(TYPE) ((sizeof (TYPE) + sizeof (UINTN) - 1) / sizeof (UINTN))\r
577\r
68167fed 578/**\r
818ff8c2 579 Returns an argument of a specified type from a variable argument list and updates\r
580 the pointer to the variable argument list to point to the next argument.\r
68167fed 581\r
818ff8c2 582 This function returns an argument of the type specified by TYPE from the beginning\r
583 of the variable argument list specified by Marker. Marker is then updated to point\r
584 to the next argument in the variable argument list. The method for computing the\r
68167fed 585 pointer to the next argument in the argument list is CPU specific following the EFIAPI ABI.\r
586\r
af2dc6a7 587 @param Marker The pointer to the beginning of a variable argument list.\r
818ff8c2 588 @param TYPE The type of argument to retrieve from the beginning\r
68167fed 589 of the variable argument list.\r
818ff8c2 590\r
68167fed 591 @return An argument of the type specified by TYPE.\r
592\r
593**/\r
2229029a 594#define BASE_ARG(Marker, TYPE) (*(TYPE *) ((Marker += _BASE_INT_SIZE_OF (TYPE)) - _BASE_INT_SIZE_OF (TYPE)))\r
68167fed 595\r
3963c4bf 596/**\r
818ff8c2 597 The macro that returns the byte offset of a field in a data structure.\r
3963c4bf 598\r
818ff8c2 599 This function returns the offset, in bytes, of field specified by Field from the\r
600 beginning of the data structure specified by TYPE. If TYPE does not contain Field,\r
601 the module will not compile.\r
3963c4bf 602\r
818ff8c2 603 @param TYPE The name of the data structure that contains the field specified by Field.\r
3963c4bf 604 @param Field The name of the field in the data structure.\r
818ff8c2 605\r
3963c4bf 606 @return Offset, in bytes, of field.\r
818ff8c2 607\r
3963c4bf 608**/\r
818ff8c2 609#ifdef __GNUC__\r
610#if __GNUC__ >= 4\r
611#define OFFSET_OF(TYPE, Field) ((UINTN) __builtin_offsetof(TYPE, Field))\r
612#endif\r
613#endif\r
614\r
615#ifndef OFFSET_OF\r
959ccb23 616#define OFFSET_OF(TYPE, Field) ((UINTN) &(((TYPE *)0)->Field))\r
818ff8c2 617#endif\r
959ccb23 618\r
3963c4bf 619/**\r
818ff8c2 620 Macro that returns a pointer to the data structure that contains a specified field of\r
621 that data structure. This is a lightweight method to hide information by placing a\r
622 public data structure inside a larger private data structure and using a pointer to\r
3963c4bf 623 the public data structure to retrieve a pointer to the private data structure.\r
624\r
818ff8c2 625 This function computes the offset, in bytes, of field specified by Field from the beginning\r
626 of the data structure specified by TYPE. This offset is subtracted from Record, and is\r
627 used to return a pointer to a data structure of the type specified by TYPE. If the data type\r
628 specified by TYPE does not contain the field specified by Field, then the module will not compile.\r
629\r
630 @param Record Pointer to the field specified by Field within a data structure of type TYPE.\r
631 @param TYPE The name of the data structure type to return. This data structure must\r
632 contain the field specified by Field.\r
3963c4bf 633 @param Field The name of the field in the data structure specified by TYPE to which Record points.\r
818ff8c2 634\r
3963c4bf 635 @return A pointer to the structure from one of it's elements.\r
818ff8c2 636\r
3963c4bf 637**/\r
22ce9dc5 638#define BASE_CR(Record, TYPE, Field) ((TYPE *) ((CHAR8 *) (Record) - (CHAR8 *) &(((TYPE *) 0)->Field)))\r
959ccb23 639\r
3963c4bf 640/**\r
818ff8c2 641 Rounds a value up to the next boundary using a specified alignment.\r
3963c4bf 642\r
818ff8c2 643 This function rounds Value up to the next boundary using the specified Alignment.\r
644 This aligned value is returned.\r
3963c4bf 645\r
646 @param Value The value to round up.\r
647 @param Alignment The alignment boundary used to return the aligned value.\r
818ff8c2 648\r
3963c4bf 649 @return A value up to the next boundary.\r
818ff8c2 650\r
3963c4bf 651**/\r
3fef0f51 652#define ALIGN_VALUE(Value, Alignment) ((Value) + (((Alignment) - (Value)) & ((Alignment) - 1)))\r
653\r
3963c4bf 654/**\r
818ff8c2 655 Adjust a pointer by adding the minimum offset required for it to be aligned on\r
656 a specified alignment boundary.\r
3963c4bf 657\r
818ff8c2 658 This function rounds the pointer specified by Pointer to the next alignment boundary\r
659 specified by Alignment. The pointer to the aligned address is returned.\r
3963c4bf 660\r
f754f721 661 @param Pointer The pointer to round up.\r
3963c4bf 662 @param Alignment The alignment boundary to use to return an aligned pointer.\r
818ff8c2 663\r
3963c4bf 664 @return Pointer to the aligned address.\r
818ff8c2 665\r
3963c4bf 666**/\r
3fef0f51 667#define ALIGN_POINTER(Pointer, Alignment) ((VOID *) (ALIGN_VALUE ((UINTN)(Pointer), (Alignment))))\r
959ccb23 668\r
3963c4bf 669/**\r
818ff8c2 670 Rounds a value up to the next natural boundary for the current CPU.\r
671 This is 4-bytes for 32-bit CPUs and 8-bytes for 64-bit CPUs.\r
3963c4bf 672\r
818ff8c2 673 This function rounds the value specified by Value up to the next natural boundary for the\r
674 current CPU. This rounded value is returned.\r
3963c4bf 675\r
676 @param Value The value to round up.\r
677\r
678 @return Rounded value specified by Value.\r
818ff8c2 679\r
3963c4bf 680**/\r
3fef0f51 681#define ALIGN_VARIABLE(Value) ALIGN_VALUE ((Value), sizeof (UINTN))\r
818ff8c2 682\r
959ccb23 683\r
3963c4bf 684/**\r
818ff8c2 685 Return the maximum of two operands.\r
3963c4bf 686\r
818ff8c2 687 This macro returns the maximum of two operand specified by a and b.\r
3963c4bf 688 Both a and b must be the same numerical types, signed or unsigned.\r
689\r
3963c4bf 690 @param a The first operand with any numerical type.\r
818ff8c2 691 @param b The second operand. Can be any numerical type as long as is\r
a89fa50c 692 the same type as a.\r
818ff8c2 693\r
3963c4bf 694 @return Maximum of two operands.\r
818ff8c2 695\r
3963c4bf 696**/\r
959ccb23 697#define MAX(a, b) \\r
698 (((a) > (b)) ? (a) : (b))\r
699\r
3963c4bf 700/**\r
818ff8c2 701 Return the minimum of two operands.\r
3963c4bf 702\r
818ff8c2 703 This macro returns the minimal of two operand specified by a and b.\r
3963c4bf 704 Both a and b must be the same numerical types, signed or unsigned.\r
705\r
3963c4bf 706 @param a The first operand with any numerical type.\r
707 @param b The second operand. It should be the same any numerical type with a.\r
818ff8c2 708\r
3963c4bf 709 @return Minimum of two operands.\r
818ff8c2 710\r
3963c4bf 711**/\r
959ccb23 712#define MIN(a, b) \\r
713 (((a) < (b)) ? (a) : (b))\r
714\r
8b157410 715/**\r
716 Return the absolute value of a signed operand.\r
717\r
718 This macro returns the absolute value of the signed operand specified by a.\r
719\r
720 @param a The signed operand.\r
721\r
722 @return The absolute value of the signed operand.\r
723\r
724**/\r
725#define ABS(a) \\r
726 (((a) < 0) ? (-(a)) : (a))\r
727\r
959ccb23 728//\r
f4ec40ab 729// Status codes common to all execution phases\r
959ccb23 730//\r
6f906c39 731typedef UINTN RETURN_STATUS;\r
959ccb23 732\r
f4ec40ab 733/**\r
818ff8c2 734 Produces a RETURN_STATUS code with the highest bit set.\r
959ccb23 735\r
818ff8c2 736 @param StatusCode The status code value to convert into a warning code.\r
f4ec40ab 737 StatusCode must be in the range 0x00000000..0x7FFFFFFF.\r
738\r
739 @return The value specified by StatusCode with the highest bit set.\r
740\r
741**/\r
262ffea8 742#define ENCODE_ERROR(StatusCode) ((RETURN_STATUS)(MAX_BIT | (StatusCode)))\r
959ccb23 743\r
f4ec40ab 744/**\r
818ff8c2 745 Produces a RETURN_STATUS code with the highest bit clear.\r
f4ec40ab 746\r
818ff8c2 747 @param StatusCode The status code value to convert into a warning code.\r
f4ec40ab 748 StatusCode must be in the range 0x00000000..0x7FFFFFFF.\r
749\r
750 @return The value specified by StatusCode with the highest bit clear.\r
751\r
752**/\r
262ffea8 753#define ENCODE_WARNING(StatusCode) ((RETURN_STATUS)(StatusCode))\r
f4ec40ab 754\r
755/**\r
818ff8c2 756 Returns TRUE if a specified RETURN_STATUS code is an error code.\r
757\r
758 This function returns TRUE if StatusCode has the high bit set. Otherwise, FALSE is returned.\r
f4ec40ab 759\r
40731047 760 @param StatusCode The status code value to evaluate.\r
f4ec40ab 761\r
762 @retval TRUE The high bit of StatusCode is set.\r
763 @retval FALSE The high bit of StatusCode is clear.\r
764\r
765**/\r
6f906c39 766#define RETURN_ERROR(StatusCode) (((INTN)(RETURN_STATUS)(StatusCode)) < 0)\r
f4ec40ab 767\r
768///\r
769/// The operation completed successfully.\r
770///\r
959ccb23 771#define RETURN_SUCCESS 0\r
f4ec40ab 772\r
773///\r
774/// The image failed to load.\r
775///\r
959ccb23 776#define RETURN_LOAD_ERROR ENCODE_ERROR (1)\r
f4ec40ab 777\r
778///\r
779/// The parameter was incorrect.\r
780///\r
959ccb23 781#define RETURN_INVALID_PARAMETER ENCODE_ERROR (2)\r
f4ec40ab 782\r
783///\r
784/// The operation is not supported.\r
785///\r
959ccb23 786#define RETURN_UNSUPPORTED ENCODE_ERROR (3)\r
f4ec40ab 787\r
788///\r
789/// The buffer was not the proper size for the request.\r
790///\r
959ccb23 791#define RETURN_BAD_BUFFER_SIZE ENCODE_ERROR (4)\r
f4ec40ab 792\r
793///\r
794/// The buffer was not large enough to hold the requested data.\r
795/// The required buffer size is returned in the appropriate\r
796/// parameter when this error occurs.\r
797///\r
959ccb23 798#define RETURN_BUFFER_TOO_SMALL ENCODE_ERROR (5)\r
f4ec40ab 799\r
800///\r
80619162 801/// There is no data pending upon return.\r
f4ec40ab 802///\r
959ccb23 803#define RETURN_NOT_READY ENCODE_ERROR (6)\r
f4ec40ab 804\r
805///\r
806/// The physical device reported an error while attempting the\r
807/// operation.\r
808///\r
959ccb23 809#define RETURN_DEVICE_ERROR ENCODE_ERROR (7)\r
f4ec40ab 810\r
811///\r
812/// The device can not be written to.\r
813///\r
959ccb23 814#define RETURN_WRITE_PROTECTED ENCODE_ERROR (8)\r
f4ec40ab 815\r
816///\r
817/// The resource has run out.\r
818///\r
959ccb23 819#define RETURN_OUT_OF_RESOURCES ENCODE_ERROR (9)\r
f4ec40ab 820\r
821///\r
818ff8c2 822/// An inconsistency was detected on the file system causing the\r
f4ec40ab 823/// operation to fail.\r
824///\r
959ccb23 825#define RETURN_VOLUME_CORRUPTED ENCODE_ERROR (10)\r
f4ec40ab 826\r
827///\r
828/// There is no more space on the file system.\r
829///\r
959ccb23 830#define RETURN_VOLUME_FULL ENCODE_ERROR (11)\r
f4ec40ab 831\r
832///\r
818ff8c2 833/// The device does not contain any medium to perform the\r
f4ec40ab 834/// operation.\r
835///\r
959ccb23 836#define RETURN_NO_MEDIA ENCODE_ERROR (12)\r
f4ec40ab 837\r
838///\r
839/// The medium in the device has changed since the last\r
840/// access.\r
841///\r
959ccb23 842#define RETURN_MEDIA_CHANGED ENCODE_ERROR (13)\r
f4ec40ab 843\r
844///\r
845/// The item was not found.\r
846///\r
959ccb23 847#define RETURN_NOT_FOUND ENCODE_ERROR (14)\r
f4ec40ab 848\r
849///\r
850/// Access was denied.\r
851///\r
959ccb23 852#define RETURN_ACCESS_DENIED ENCODE_ERROR (15)\r
f4ec40ab 853\r
854///\r
855/// The server was not found or did not respond to the request.\r
856///\r
959ccb23 857#define RETURN_NO_RESPONSE ENCODE_ERROR (16)\r
f4ec40ab 858\r
859///\r
860/// A mapping to the device does not exist.\r
861///\r
959ccb23 862#define RETURN_NO_MAPPING ENCODE_ERROR (17)\r
f4ec40ab 863\r
864///\r
865/// A timeout time expired.\r
866///\r
959ccb23 867#define RETURN_TIMEOUT ENCODE_ERROR (18)\r
f4ec40ab 868\r
869///\r
870/// The protocol has not been started.\r
871///\r
959ccb23 872#define RETURN_NOT_STARTED ENCODE_ERROR (19)\r
f4ec40ab 873\r
874///\r
875/// The protocol has already been started.\r
876///\r
959ccb23 877#define RETURN_ALREADY_STARTED ENCODE_ERROR (20)\r
f4ec40ab 878\r
879///\r
880/// The operation was aborted.\r
881///\r
959ccb23 882#define RETURN_ABORTED ENCODE_ERROR (21)\r
f4ec40ab 883\r
884///\r
727501bb 885/// An ICMP error occurred during the network operation.\r
f4ec40ab 886///\r
959ccb23 887#define RETURN_ICMP_ERROR ENCODE_ERROR (22)\r
f4ec40ab 888\r
889///\r
727501bb 890/// A TFTP error occurred during the network operation.\r
f4ec40ab 891///\r
959ccb23 892#define RETURN_TFTP_ERROR ENCODE_ERROR (23)\r
f4ec40ab 893\r
894///\r
727501bb 895/// A protocol error occurred during the network operation.\r
f4ec40ab 896///\r
959ccb23 897#define RETURN_PROTOCOL_ERROR ENCODE_ERROR (24)\r
f4ec40ab 898\r
899///\r
900/// A function encountered an internal version that was\r
727501bb 901/// incompatible with a version requested by the caller.\r
f4ec40ab 902///\r
959ccb23 903#define RETURN_INCOMPATIBLE_VERSION ENCODE_ERROR (25)\r
f4ec40ab 904\r
905///\r
906/// The function was not performed due to a security violation.\r
907///\r
959ccb23 908#define RETURN_SECURITY_VIOLATION ENCODE_ERROR (26)\r
f4ec40ab 909\r
910///\r
911/// A CRC error was detected.\r
912///\r
959ccb23 913#define RETURN_CRC_ERROR ENCODE_ERROR (27)\r
f4ec40ab 914\r
915///\r
af2dc6a7 916/// The beginning or end of media was reached.\r
f4ec40ab 917///\r
959ccb23 918#define RETURN_END_OF_MEDIA ENCODE_ERROR (28)\r
f4ec40ab 919\r
920///\r
921/// The end of the file was reached.\r
922///\r
959ccb23 923#define RETURN_END_OF_FILE ENCODE_ERROR (31)\r
f4ec40ab 924\r
925///\r
926/// The language specified was invalid.\r
927///\r
54cf8780 928#define RETURN_INVALID_LANGUAGE ENCODE_ERROR (32)\r
929\r
76336e4e
SZ
930///\r
931/// The security status of the data is unknown or compromised\r
932/// and the data must be updated or replaced to restore a valid\r
933/// security status.\r
934///\r
935#define RETURN_COMPROMISED_DATA ENCODE_ERROR (33)\r
959ccb23 936\r
f4ec40ab 937///\r
fbf926ad 938/// The string contained one or more characters that\r
f4ec40ab 939/// the device could not render and were skipped.\r
940///\r
959ccb23 941#define RETURN_WARN_UNKNOWN_GLYPH ENCODE_WARNING (1)\r
f4ec40ab 942\r
943///\r
944/// The handle was closed, but the file was not deleted.\r
945///\r
959ccb23 946#define RETURN_WARN_DELETE_FAILURE ENCODE_WARNING (2)\r
f4ec40ab 947\r
948///\r
949/// The handle was closed, but the data to the file was not\r
950/// flushed properly.\r
951///\r
959ccb23 952#define RETURN_WARN_WRITE_FAILURE ENCODE_WARNING (3)\r
f4ec40ab 953\r
954///\r
818ff8c2 955/// The resulting buffer was too small, and the data was\r
f4ec40ab 956/// truncated to the buffer size.\r
957///\r
959ccb23 958#define RETURN_WARN_BUFFER_TOO_SMALL ENCODE_WARNING (4)\r
959\r
76336e4e
SZ
960///\r
961/// The data has not been updated within the timeframe set by\r
962/// local policy for this type of data.\r
963///\r
964#define RETURN_WARN_STALE_DATA ENCODE_WARNING (5)\r
965\r
a7cc3d26 966/**\r
967 Returns a 16-bit signature built from 2 ASCII characters.\r
818ff8c2 968\r
969 This macro returns a 16-bit value built from the two ASCII characters specified\r
3963c4bf 970 by A and B.\r
818ff8c2 971\r
ee6c452c 972 @param A The first ASCII character.\r
973 @param B The second ASCII character.\r
a7cc3d26 974\r
975 @return A 16-bit value built from the two ASCII characters specified by A and B.\r
976\r
977**/\r
13c31065 978#define SIGNATURE_16(A, B) ((A) | (B << 8))\r
a7cc3d26 979\r
980/**\r
981 Returns a 32-bit signature built from 4 ASCII characters.\r
818ff8c2 982\r
983 This macro returns a 32-bit value built from the four ASCII characters specified\r
3963c4bf 984 by A, B, C, and D.\r
818ff8c2 985\r
ee6c452c 986 @param A The first ASCII character.\r
987 @param B The second ASCII character.\r
988 @param C The third ASCII character.\r
989 @param D The fourth ASCII character.\r
a7cc3d26 990\r
991 @return A 32-bit value built from the two ASCII characters specified by A, B,\r
992 C and D.\r
993\r
994**/\r
13c31065 995#define SIGNATURE_32(A, B, C, D) (SIGNATURE_16 (A, B) | (SIGNATURE_16 (C, D) << 16))\r
a7cc3d26 996\r
997/**\r
998 Returns a 64-bit signature built from 8 ASCII characters.\r
818ff8c2 999\r
1000 This macro returns a 64-bit value built from the eight ASCII characters specified\r
3963c4bf 1001 by A, B, C, D, E, F, G,and H.\r
818ff8c2 1002\r
ee6c452c 1003 @param A The first ASCII character.\r
1004 @param B The second ASCII character.\r
1005 @param C The third ASCII character.\r
1006 @param D The fourth ASCII character.\r
1007 @param E The fifth ASCII character.\r
1008 @param F The sixth ASCII character.\r
1009 @param G The seventh ASCII character.\r
1010 @param H The eighth ASCII character.\r
a7cc3d26 1011\r
1012 @return A 64-bit value built from the two ASCII characters specified by A, B,\r
1013 C, D, E, F, G and H.\r
1014\r
1015**/\r
13c31065 1016#define SIGNATURE_64(A, B, C, D, E, F, G, H) \\r
1017 (SIGNATURE_32 (A, B, C, D) | ((UINT64) (SIGNATURE_32 (E, F, G, H)) << 32))\r
1018\r
dad83a8c
SZ
1019#if defined(_MSC_EXTENSIONS)\r
1020 //\r
1021 // Intrinsic function provides the address of the instruction in the calling\r
1022 // function that will be executed after control returns to the caller.\r
1023 //\r
1024 #pragma intrinsic(_ReturnAddress)\r
1025 #define RETURN_ADDRESS(L) ((L == 0) ? _ReturnAddress() : (VOID *) 0)\r
1026#elif defined(__GNUC__)\r
1027 //\r
1028 // Built-in Function returns the return address of the current function,\r
1029 // or of one of its callers.\r
1030 //\r
1031 void * __builtin_return_address (unsigned int level);\r
1032 #define RETURN_ADDRESS(L) __builtin_return_address (L)\r
1033#else\r
1034 //\r
1035 // Compilers don't support this feature.\r
1036 //\r
1037 #define RETURN_ADDRESS(L) ((VOID *) 0)\r
1038#endif\r
1039\r
959ccb23 1040#endif\r
1041\r