xref: /illumos-gate/usr/src/boot/efi/include/Base.h (revision f334afcfaebea1b7dc3430015651d8d748fa8a3e)
1 /** @file
2   Root include file for Mde Package Base type modules
3 
4   This is the include file for any module of type base. Base modules only use
5   types defined via this include file and can be ported easily to any
6   environment. There are a set of base libraries in the Mde Package that can
7   be used to implement base modules.
8 
9 Copyright (c) 2006 - 2021, Intel Corporation. All rights reserved.<BR>
10 Portions copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
11 SPDX-License-Identifier: BSD-2-Clause-Patent
12 
13 **/
14 
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)
36 ///
37 /// Remove global variable from the linked image if there are no references to
38 /// it after all compiler and linker optimizations have been performed.
39 ///
40 ///
41 #define GLOBAL_REMOVE_IF_UNREFERENCED  __declspec(selectany)
42 #else
43 ///
44 /// Remove the global variable from the linked image if there are no references
45 ///  to it after all compiler and linker optimizations have been performed.
46 ///
47 ///
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__
57 ///
58 /// Signal compilers and analyzers that this call is not reachable.  It is
59 /// up to the compiler to remove any code past that point.
60 ///
61 #define UNREACHABLE()  __builtin_unreachable ()
62   #elif defined (__has_feature)
63     #if __has_builtin (__builtin_unreachable)
64 ///
65 /// Signal compilers and analyzers that this call is not reachable.  It is
66 /// up to the compiler to remove any code past that point.
67 ///
68 #define UNREACHABLE()  __builtin_unreachable ()
69     #endif
70   #endif
71 
72   #ifndef UNREACHABLE
73 ///
74 /// Signal compilers and analyzers that this call is not reachable.  It is
75 /// up to the compiler to remove any code past that point.
76 ///
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__)
88 ///
89 /// Signal compilers and analyzers that the function cannot return.
90 /// It is up to the compiler to remove any code past a call to functions
91 /// flagged with this attribute.
92 ///
93 #define NORETURN  __attribute__((noreturn))
94   #elif defined (_MSC_EXTENSIONS) && !defined (MDE_CPU_EBC)
95 ///
96 /// Signal compilers and analyzers that the function cannot return.
97 /// It is up to the compiler to remove any code past a call to functions
98 /// flagged with this attribute.
99 ///
100 #define NORETURN  __declspec(noreturn)
101   #else
102 ///
103 /// Signal compilers and analyzers that the function cannot return.
104 /// It is up to the compiler to remove any code past a call to functions
105 /// flagged with this attribute.
106 ///
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)
118 ///
119 /// Signal the analyzer that this call is not reachable.
120 /// This excludes compilers.
121 ///
122 #define ANALYZER_UNREACHABLE()  __builtin_unreachable ()
123     #endif
124   #endif
125 
126   #ifndef ANALYZER_UNREACHABLE
127 ///
128 /// Signal the analyzer that this call is not reachable.
129 /// This excludes compilers.
130 ///
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)
144 ///
145 /// Signal analyzers that the function cannot return.
146 /// This excludes compilers.
147 ///
148 #define ANALYZER_NORETURN  __attribute__((analyzer_noreturn))
149     #endif
150   #endif
151 
152   #ifndef ANALYZER_NORETURN
153 ///
154 /// Signal the analyzer that the function cannot return.
155 /// This excludes compilers.
156 ///
157 #define ANALYZER_NORETURN
158   #endif
159 #endif
160 
161 ///
162 /// Tell the code optimizer that the function will return twice.
163 /// This prevents wrong optimizations which can cause bugs.
164 ///
165 #ifndef RETURNS_TWICE
166   #if defined (__GNUC__) || defined (__clang__)
167 ///
168 /// Tell the code optimizer that the function will return twice.
169 /// This prevents wrong optimizations which can cause bugs.
170 ///
171 #define RETURNS_TWICE  __attribute__((returns_twice))
172   #else
173 ///
174 /// Tell the code optimizer that the function will return twice.
175 /// This prevents wrong optimizations which can cause bugs.
176 ///
177 #define RETURNS_TWICE
178   #endif
179 #endif
180 
181 //
182 // For symbol name in assembly code, an extra "_" is sometimes necessary
183 //
184 
185 ///
186 /// Private worker functions for ASM_PFX()
187 ///
188 #define _CONCATENATE(a, b)   __CONCATENATE(a, b)
189 #define __CONCATENATE(a, b)  a ## b
190 
191 ///
192 /// The __USER_LABEL_PREFIX__ macro predefined by GNUC represents the prefix
193 /// on symbols in assembly language.
194 ///
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 #ifdef __CC_ARM
208 //
209 // Older RVCT ARM compilers don't fully support #pragma pack and require __packed
210 // as a prefix for the structure.
211 //
212 #define PACKED  __packed
213 #else
214 #define PACKED
215 #endif
216 
217 ///
218 /// 128 bit buffer containing a unique identifier value.
219 /// Unless otherwise specified, aligned on a 64 bit boundary.
220 ///
221 typedef struct {
222   UINT32    Data1;
223   UINT16    Data2;
224   UINT16    Data3;
225   UINT8     Data4[8];
226 } GUID;
227 
228 ///
229 /// 4-byte buffer. An IPv4 internet protocol address.
230 ///
231 typedef struct {
232   UINT8    Addr[4];
233 } IPv4_ADDRESS;
234 
235 ///
236 /// 16-byte buffer. An IPv6 internet protocol address.
237 ///
238 typedef struct {
239   UINT8    Addr[16];
240 } IPv6_ADDRESS;
241 
242 //
243 // 8-bytes unsigned value that represents a physical system address.
244 //
245 typedef UINT64 PHYSICAL_ADDRESS;
246 
247 ///
248 /// LIST_ENTRY structure definition.
249 ///
250 typedef struct _LIST_ENTRY LIST_ENTRY;
251 
252 ///
253 /// _LIST_ENTRY structure definition.
254 ///
255 struct _LIST_ENTRY {
256   LIST_ENTRY    *ForwardLink;
257   LIST_ENTRY    *BackLink;
258 };
259 
260 //
261 // Modifiers to abstract standard types to aid in debug of problems
262 //
263 
264 ///
265 /// Datum is read-only.
266 ///
267 #define CONST  const
268 
269 ///
270 /// Datum is scoped to the current file or function.
271 ///
272 #define STATIC  static
273 
274 ///
275 /// Undeclared type.
276 ///
277 #define VOID  void
278 
279 //
280 // Modifiers for Data Types used to self document code.
281 // This concept is borrowed for UEFI specification.
282 //
283 
284 ///
285 /// Datum is passed to the function.
286 ///
287 #define IN
288 
289 ///
290 /// Datum is returned from the function.
291 ///
292 #define OUT
293 
294 ///
295 /// Passing the datum to the function is optional, and a NULL
296 /// is passed if the value is not supplied.
297 ///
298 #define OPTIONAL
299 
300 //
301 //  UEFI specification claims 1 and 0. We are concerned about the
302 //  compiler portability so we did it this way.
303 //
304 
305 ///
306 /// Boolean true value.  UEFI Specification defines this value to be 1,
307 /// but this form is more portable.
308 ///
309 #define TRUE  ((BOOLEAN)(1==1))
310 
311 ///
312 /// Boolean false value.  UEFI Specification defines this value to be 0,
313 /// but this form is more portable.
314 ///
315 #define FALSE  ((BOOLEAN)(0==1))
316 
317 ///
318 /// NULL pointer (VOID *)
319 ///
320 #ifndef NULL
321 #define NULL  ((VOID *) 0)
322 #endif
323 
324 //
325 // Null character
326 //
327 #define CHAR_NULL  0x0000
328 
329 ///
330 /// Maximum values for common UEFI Data Types
331 ///
332 #define MAX_INT8    ((INT8)0x7F)
333 #define MAX_UINT8   ((UINT8)0xFF)
334 #define MAX_INT16   ((INT16)0x7FFF)
335 #define MAX_UINT16  ((UINT16)0xFFFF)
336 #define MAX_INT32   ((INT32)0x7FFFFFFF)
337 #define MAX_UINT32  ((UINT32)0xFFFFFFFF)
338 #define MAX_INT64   ((INT64)0x7FFFFFFFFFFFFFFFULL)
339 #define MAX_UINT64  ((UINT64)0xFFFFFFFFFFFFFFFFULL)
340 
341 ///
342 /// Minimum values for the signed UEFI Data Types
343 ///
344 #define MIN_INT8   (((INT8)  -127) - 1)
345 #define MIN_INT16  (((INT16) -32767) - 1)
346 #define MIN_INT32  (((INT32) -2147483647) - 1)
347 #define MIN_INT64  (((INT64) -9223372036854775807LL) - 1)
348 
349 #define  BIT0   0x00000001
350 #define  BIT1   0x00000002
351 #define  BIT2   0x00000004
352 #define  BIT3   0x00000008
353 #define  BIT4   0x00000010
354 #define  BIT5   0x00000020
355 #define  BIT6   0x00000040
356 #define  BIT7   0x00000080
357 #define  BIT8   0x00000100
358 #define  BIT9   0x00000200
359 #define  BIT10  0x00000400
360 #define  BIT11  0x00000800
361 #define  BIT12  0x00001000
362 #define  BIT13  0x00002000
363 #define  BIT14  0x00004000
364 #define  BIT15  0x00008000
365 #define  BIT16  0x00010000
366 #define  BIT17  0x00020000
367 #define  BIT18  0x00040000
368 #define  BIT19  0x00080000
369 #define  BIT20  0x00100000
370 #define  BIT21  0x00200000
371 #define  BIT22  0x00400000
372 #define  BIT23  0x00800000
373 #define  BIT24  0x01000000
374 #define  BIT25  0x02000000
375 #define  BIT26  0x04000000
376 #define  BIT27  0x08000000
377 #define  BIT28  0x10000000
378 #define  BIT29  0x20000000
379 #define  BIT30  0x40000000
380 #define  BIT31  0x80000000
381 #define  BIT32  0x0000000100000000ULL
382 #define  BIT33  0x0000000200000000ULL
383 #define  BIT34  0x0000000400000000ULL
384 #define  BIT35  0x0000000800000000ULL
385 #define  BIT36  0x0000001000000000ULL
386 #define  BIT37  0x0000002000000000ULL
387 #define  BIT38  0x0000004000000000ULL
388 #define  BIT39  0x0000008000000000ULL
389 #define  BIT40  0x0000010000000000ULL
390 #define  BIT41  0x0000020000000000ULL
391 #define  BIT42  0x0000040000000000ULL
392 #define  BIT43  0x0000080000000000ULL
393 #define  BIT44  0x0000100000000000ULL
394 #define  BIT45  0x0000200000000000ULL
395 #define  BIT46  0x0000400000000000ULL
396 #define  BIT47  0x0000800000000000ULL
397 #define  BIT48  0x0001000000000000ULL
398 #define  BIT49  0x0002000000000000ULL
399 #define  BIT50  0x0004000000000000ULL
400 #define  BIT51  0x0008000000000000ULL
401 #define  BIT52  0x0010000000000000ULL
402 #define  BIT53  0x0020000000000000ULL
403 #define  BIT54  0x0040000000000000ULL
404 #define  BIT55  0x0080000000000000ULL
405 #define  BIT56  0x0100000000000000ULL
406 #define  BIT57  0x0200000000000000ULL
407 #define  BIT58  0x0400000000000000ULL
408 #define  BIT59  0x0800000000000000ULL
409 #define  BIT60  0x1000000000000000ULL
410 #define  BIT61  0x2000000000000000ULL
411 #define  BIT62  0x4000000000000000ULL
412 #define  BIT63  0x8000000000000000ULL
413 
414 #define  SIZE_1KB    0x00000400
415 #define  SIZE_2KB    0x00000800
416 #define  SIZE_4KB    0x00001000
417 #define  SIZE_8KB    0x00002000
418 #define  SIZE_16KB   0x00004000
419 #define  SIZE_32KB   0x00008000
420 #define  SIZE_64KB   0x00010000
421 #define  SIZE_128KB  0x00020000
422 #define  SIZE_256KB  0x00040000
423 #define  SIZE_512KB  0x00080000
424 #define  SIZE_1MB    0x00100000
425 #define  SIZE_2MB    0x00200000
426 #define  SIZE_4MB    0x00400000
427 #define  SIZE_8MB    0x00800000
428 #define  SIZE_16MB   0x01000000
429 #define  SIZE_32MB   0x02000000
430 #define  SIZE_64MB   0x04000000
431 #define  SIZE_128MB  0x08000000
432 #define  SIZE_256MB  0x10000000
433 #define  SIZE_512MB  0x20000000
434 #define  SIZE_1GB    0x40000000
435 #define  SIZE_2GB    0x80000000
436 #define  SIZE_4GB    0x0000000100000000ULL
437 #define  SIZE_8GB    0x0000000200000000ULL
438 #define  SIZE_16GB   0x0000000400000000ULL
439 #define  SIZE_32GB   0x0000000800000000ULL
440 #define  SIZE_64GB   0x0000001000000000ULL
441 #define  SIZE_128GB  0x0000002000000000ULL
442 #define  SIZE_256GB  0x0000004000000000ULL
443 #define  SIZE_512GB  0x0000008000000000ULL
444 #define  SIZE_1TB    0x0000010000000000ULL
445 #define  SIZE_2TB    0x0000020000000000ULL
446 #define  SIZE_4TB    0x0000040000000000ULL
447 #define  SIZE_8TB    0x0000080000000000ULL
448 #define  SIZE_16TB   0x0000100000000000ULL
449 #define  SIZE_32TB   0x0000200000000000ULL
450 #define  SIZE_64TB   0x0000400000000000ULL
451 #define  SIZE_128TB  0x0000800000000000ULL
452 #define  SIZE_256TB  0x0001000000000000ULL
453 #define  SIZE_512TB  0x0002000000000000ULL
454 #define  SIZE_1PB    0x0004000000000000ULL
455 #define  SIZE_2PB    0x0008000000000000ULL
456 #define  SIZE_4PB    0x0010000000000000ULL
457 #define  SIZE_8PB    0x0020000000000000ULL
458 #define  SIZE_16PB   0x0040000000000000ULL
459 #define  SIZE_32PB   0x0080000000000000ULL
460 #define  SIZE_64PB   0x0100000000000000ULL
461 #define  SIZE_128PB  0x0200000000000000ULL
462 #define  SIZE_256PB  0x0400000000000000ULL
463 #define  SIZE_512PB  0x0800000000000000ULL
464 #define  SIZE_1EB    0x1000000000000000ULL
465 #define  SIZE_2EB    0x2000000000000000ULL
466 #define  SIZE_4EB    0x4000000000000000ULL
467 #define  SIZE_8EB    0x8000000000000000ULL
468 
469 #define  BASE_1KB    0x00000400
470 #define  BASE_2KB    0x00000800
471 #define  BASE_4KB    0x00001000
472 #define  BASE_8KB    0x00002000
473 #define  BASE_16KB   0x00004000
474 #define  BASE_32KB   0x00008000
475 #define  BASE_64KB   0x00010000
476 #define  BASE_128KB  0x00020000
477 #define  BASE_256KB  0x00040000
478 #define  BASE_512KB  0x00080000
479 #define  BASE_1MB    0x00100000
480 #define  BASE_2MB    0x00200000
481 #define  BASE_4MB    0x00400000
482 #define  BASE_8MB    0x00800000
483 #define  BASE_16MB   0x01000000
484 #define  BASE_32MB   0x02000000
485 #define  BASE_64MB   0x04000000
486 #define  BASE_128MB  0x08000000
487 #define  BASE_256MB  0x10000000
488 #define  BASE_512MB  0x20000000
489 #define  BASE_1GB    0x40000000
490 #define  BASE_2GB    0x80000000
491 #define  BASE_4GB    0x0000000100000000ULL
492 #define  BASE_8GB    0x0000000200000000ULL
493 #define  BASE_16GB   0x0000000400000000ULL
494 #define  BASE_32GB   0x0000000800000000ULL
495 #define  BASE_64GB   0x0000001000000000ULL
496 #define  BASE_128GB  0x0000002000000000ULL
497 #define  BASE_256GB  0x0000004000000000ULL
498 #define  BASE_512GB  0x0000008000000000ULL
499 #define  BASE_1TB    0x0000010000000000ULL
500 #define  BASE_2TB    0x0000020000000000ULL
501 #define  BASE_4TB    0x0000040000000000ULL
502 #define  BASE_8TB    0x0000080000000000ULL
503 #define  BASE_16TB   0x0000100000000000ULL
504 #define  BASE_32TB   0x0000200000000000ULL
505 #define  BASE_64TB   0x0000400000000000ULL
506 #define  BASE_128TB  0x0000800000000000ULL
507 #define  BASE_256TB  0x0001000000000000ULL
508 #define  BASE_512TB  0x0002000000000000ULL
509 #define  BASE_1PB    0x0004000000000000ULL
510 #define  BASE_2PB    0x0008000000000000ULL
511 #define  BASE_4PB    0x0010000000000000ULL
512 #define  BASE_8PB    0x0020000000000000ULL
513 #define  BASE_16PB   0x0040000000000000ULL
514 #define  BASE_32PB   0x0080000000000000ULL
515 #define  BASE_64PB   0x0100000000000000ULL
516 #define  BASE_128PB  0x0200000000000000ULL
517 #define  BASE_256PB  0x0400000000000000ULL
518 #define  BASE_512PB  0x0800000000000000ULL
519 #define  BASE_1EB    0x1000000000000000ULL
520 #define  BASE_2EB    0x2000000000000000ULL
521 #define  BASE_4EB    0x4000000000000000ULL
522 #define  BASE_8EB    0x8000000000000000ULL
523 
524 //
525 //  Support for variable argument lists in freestanding edk2 modules.
526 //
527 //  For modules that use the ISO C library interfaces for variable
528 //  argument lists, refer to "StdLib/Include/stdarg.h".
529 //
530 //  VA_LIST  - typedef for argument list.
531 //  VA_START (VA_LIST Marker, argument before the ...) - Init Marker for use.
532 //  VA_END (VA_LIST Marker) - Clear Marker
533 //  VA_ARG (VA_LIST Marker, var arg type) - Use Marker to get an argument from
534 //    the ... list. You must know the type and pass it in this macro.  Type
535 //    must be compatible with the type of the actual next argument (as promoted
536 //    according to the default argument promotions.)
537 //  VA_COPY (VA_LIST Dest, VA_LIST Start) - Initialize Dest as a copy of Start.
538 //
539 //  Example:
540 //
541 //  UINTN
542 //  EFIAPI
543 //  ExampleVarArg (
544 //    IN UINTN  NumberOfArgs,
545 //    ...
546 //    )
547 //  {
548 //    VA_LIST Marker;
549 //    UINTN   Index;
550 //    UINTN   Result;
551 //
552 //    //
553 //    // Initialize the Marker
554 //    //
555 //    VA_START (Marker, NumberOfArgs);
556 //    for (Index = 0, Result = 0; Index < NumberOfArgs; Index++) {
557 //      //
558 //      // The ... list is a series of UINTN values, so sum them up.
559 //      //
560 //      Result += VA_ARG (Marker, UINTN);
561 //    }
562 //
563 //    VA_END (Marker);
564 //    return Result;
565 //  }
566 //
567 //  Notes:
568 //  - Functions that call VA_START() / VA_END() must have a variable
569 //    argument list and must be declared EFIAPI.
570 //  - Functions that call VA_COPY() / VA_END() must be declared EFIAPI.
571 //  - Functions that only use VA_LIST and VA_ARG() need not be EFIAPI.
572 //
573 
574 /**
575   Return the size of argument that has been aligned to sizeof (UINTN).
576 
577   @param  n    The parameter size to be aligned.
578 
579   @return The aligned size.
580 **/
581 #define _INT_SIZE_OF(n)  ((sizeof (n) + sizeof (UINTN) - 1) &~(sizeof (UINTN) - 1))
582 
583 #if defined (__CC_ARM)
584 //
585 // RVCT ARM variable argument list support.
586 //
587 
588 ///
589 /// Variable used to traverse the list of arguments. This type can vary by
590 /// implementation and could be an array or structure.
591 ///
592   #ifdef __APCS_ADSABI
593 typedef int *va_list[1];
594 #define VA_LIST  va_list
595   #else
596 typedef struct __va_list {
597   void    *__ap;
598 } va_list;
599 #define VA_LIST  va_list
600   #endif
601 
602 #define VA_START(Marker, Parameter)  __va_start(Marker, Parameter)
603 
604 #define VA_ARG(Marker, TYPE)  __va_arg(Marker, TYPE)
605 
606 #define VA_END(Marker)  ((void)0)
607 
608 // For some ARM RVCT compilers, __va_copy is not defined
609   #ifndef __va_copy
610 #define __va_copy(dest, src)  ((void)((dest) = (src)))
611   #endif
612 
613 #define VA_COPY(Dest, Start)  __va_copy (Dest, Start)
614 
615 #elif defined (_M_ARM) || defined (_M_ARM64)
616 //
617 // MSFT ARM variable argument list support.
618 //
619 
620 typedef char *VA_LIST;
621 
622 #define VA_START(Marker, Parameter)  __va_start (&Marker, &Parameter, _INT_SIZE_OF (Parameter), __alignof(Parameter), &Parameter)
623 #define VA_ARG(Marker, TYPE)         (*(TYPE *) ((Marker += _INT_SIZE_OF (TYPE) + ((-(INTN)Marker) & (sizeof(TYPE) - 1))) - _INT_SIZE_OF (TYPE)))
624 #define VA_END(Marker)               (Marker = (VA_LIST) 0)
625 #define VA_COPY(Dest, Start)         ((void)((Dest) = (Start)))
626 
627 #elif defined (__GNUC__) || defined (__clang__)
628 
629   #if defined (MDE_CPU_X64) && !defined (NO_MSABI_VA_FUNCS)
630 //
631 // X64 only. Use MS ABI version of GCC built-in macros for variable argument lists.
632 //
633 ///
634 /// Both GCC and LLVM 3.8 for X64 support new variable argument intrinsics for Microsoft ABI
635 ///
636 
637 ///
638 /// Variable used to traverse the list of arguments. This type can vary by
639 /// implementation and could be an array or structure.
640 ///
641 typedef __builtin_ms_va_list VA_LIST;
642 
643 #define VA_START(Marker, Parameter)  __builtin_ms_va_start (Marker, Parameter)
644 
645 #define VA_ARG(Marker, TYPE)  ((sizeof (TYPE) < sizeof (UINTN)) ? (TYPE)(__builtin_va_arg (Marker, UINTN)) : (TYPE)(__builtin_va_arg (Marker, TYPE)))
646 
647 #define VA_END(Marker)  __builtin_ms_va_end (Marker)
648 
649 #define VA_COPY(Dest, Start)  __builtin_ms_va_copy (Dest, Start)
650 
651   #else
652 //
653 // Use GCC built-in macros for variable argument lists.
654 //
655 
656 ///
657 /// Variable used to traverse the list of arguments. This type can vary by
658 /// implementation and could be an array or structure.
659 ///
660 typedef __builtin_va_list VA_LIST;
661 
662 #define VA_START(Marker, Parameter)  __builtin_va_start (Marker, Parameter)
663 
664 #define VA_ARG(Marker, TYPE)  ((sizeof (TYPE) < sizeof (UINTN)) ? (TYPE)(__builtin_va_arg (Marker, UINTN)) : (TYPE)(__builtin_va_arg (Marker, TYPE)))
665 
666 #define VA_END(Marker)  __builtin_va_end (Marker)
667 
668 #define VA_COPY(Dest, Start)  __builtin_va_copy (Dest, Start)
669 
670   #endif
671 
672 #else
673 ///
674 /// Variable used to traverse the list of arguments. This type can vary by
675 /// implementation and could be an array or structure.
676 ///
677 typedef CHAR8 *VA_LIST;
678 
679 /**
680   Retrieves a pointer to the beginning of a variable argument list, based on
681   the name of the parameter that immediately precedes the variable argument list.
682 
683   This function initializes Marker to point to the beginning of the variable
684   argument list that immediately follows Parameter.  The method for computing the
685   pointer to the next argument in the argument list is CPU-specific following the
686   EFIAPI ABI.
687 
688   @param   Marker       The VA_LIST used to traverse the list of arguments.
689   @param   Parameter    The name of the parameter that immediately precedes
690                         the variable argument list.
691 
692   @return  A pointer to the beginning of a variable argument list.
693 
694 **/
695 #define VA_START(Marker, Parameter)  (Marker = (VA_LIST) ((UINTN) & (Parameter) + _INT_SIZE_OF (Parameter)))
696 
697 /**
698   Returns an argument of a specified type from a variable argument list and updates
699   the pointer to the variable argument list to point to the next argument.
700 
701   This function returns an argument of the type specified by TYPE from the beginning
702   of the variable argument list specified by Marker.  Marker is then updated to point
703   to the next argument in the variable argument list.  The method for computing the
704   pointer to the next argument in the argument list is CPU-specific following the EFIAPI ABI.
705 
706   @param   Marker   VA_LIST used to traverse the list of arguments.
707   @param   TYPE     The type of argument to retrieve from the beginning
708                     of the variable argument list.
709 
710   @return  An argument of the type specified by TYPE.
711 
712 **/
713 #define VA_ARG(Marker, TYPE)  (*(TYPE *) ((Marker += _INT_SIZE_OF (TYPE)) - _INT_SIZE_OF (TYPE)))
714 
715 /**
716   Terminates the use of a variable argument list.
717 
718   This function initializes Marker so it can no longer be used with VA_ARG().
719   After this macro is used, the only way to access the variable argument list is
720   by using VA_START() again.
721 
722   @param   Marker   VA_LIST used to traverse the list of arguments.
723 
724 **/
725 #define VA_END(Marker)  (Marker = (VA_LIST) 0)
726 
727 /**
728   Initializes a VA_LIST as a copy of an existing VA_LIST.
729 
730   This macro initializes Dest as a copy of Start, as if the VA_START macro had been applied to Dest
731   followed by the same sequence of uses of the VA_ARG macro as had previously been used to reach
732   the present state of Start.
733 
734   @param   Dest   VA_LIST used to traverse the list of arguments.
735   @param   Start  VA_LIST used to traverse the list of arguments.
736 
737 **/
738 #define VA_COPY(Dest, Start)  ((void)((Dest) = (Start)))
739 
740 #endif
741 
742 ///
743 /// Pointer to the start of a variable argument list stored in a memory buffer. Same as UINT8 *.
744 ///
745 typedef UINTN *BASE_LIST;
746 
747 /**
748   Returns the size of a data type in sizeof(UINTN) units rounded up to the nearest UINTN boundary.
749 
750   @param  TYPE  The date type to determine the size of.
751 
752   @return The size of TYPE in sizeof (UINTN) units rounded up to the nearest UINTN boundary.
753 **/
754 #define _BASE_INT_SIZE_OF(TYPE)  ((sizeof (TYPE) + sizeof (UINTN) - 1) / sizeof (UINTN))
755 
756 /**
757   Returns an argument of a specified type from a variable argument list and updates
758   the pointer to the variable argument list to point to the next argument.
759 
760   This function returns an argument of the type specified by TYPE from the beginning
761   of the variable argument list specified by Marker.  Marker is then updated to point
762   to the next argument in the variable argument list.  The method for computing the
763   pointer to the next argument in the argument list is CPU specific following the EFIAPI ABI.
764 
765   @param   Marker   The pointer to the beginning of a variable argument list.
766   @param   TYPE     The type of argument to retrieve from the beginning
767                     of the variable argument list.
768 
769   @return  An argument of the type specified by TYPE.
770 
771 **/
772 #define BASE_ARG(Marker, TYPE)  (*(TYPE *) ((Marker += _BASE_INT_SIZE_OF (TYPE)) - _BASE_INT_SIZE_OF (TYPE)))
773 
774 /**
775   The macro that returns the byte offset of a field in a data structure.
776 
777   This function returns the offset, in bytes, of field specified by Field from the
778   beginning of the  data structure specified by TYPE. If TYPE does not contain Field,
779   the module will not compile.
780 
781   @param   TYPE     The name of the data structure that contains the field specified by Field.
782   @param   Field    The name of the field in the data structure.
783 
784   @return  Offset, in bytes, of field.
785 
786 **/
787 #if (defined (__GNUC__) && __GNUC__ >= 4) || defined (__clang__)
788 #define OFFSET_OF(TYPE, Field)  ((UINTN) __builtin_offsetof(TYPE, Field))
789 #endif
790 
791 #ifndef OFFSET_OF
792 #define OFFSET_OF(TYPE, Field)  ((UINTN) &(((TYPE *)0)->Field))
793 #endif
794 
795 /**
796   Portable definition for compile time assertions.
797   Equivalent to C11 static_assert macro from assert.h.
798 
799   @param  Expression  Boolean expression.
800   @param  Message     Raised compiler diagnostic message when expression is false.
801 
802 **/
803 #ifdef MDE_CPU_EBC
804 #define STATIC_ASSERT(Expression, Message)
805 #elif defined (_MSC_EXTENSIONS)
806 #define STATIC_ASSERT  static_assert
807 #else
808 #define STATIC_ASSERT  _Static_assert
809 #endif
810 
811 //
812 // Verify that ProcessorBind.h produced UEFI Data Types that are compliant with
813 // Section 2.3.1 of the UEFI 2.3 Specification.
814 //
815 
816 STATIC_ASSERT (sizeof (BOOLEAN) == 1, "sizeof (BOOLEAN) does not meet UEFI Specification Data Type requirements");
817 STATIC_ASSERT (sizeof (INT8)    == 1, "sizeof (INT8) does not meet UEFI Specification Data Type requirements");
818 STATIC_ASSERT (sizeof (UINT8)   == 1, "sizeof (UINT8) does not meet UEFI Specification Data Type requirements");
819 STATIC_ASSERT (sizeof (INT16)   == 2, "sizeof (INT16) does not meet UEFI Specification Data Type requirements");
820 STATIC_ASSERT (sizeof (UINT16)  == 2, "sizeof (UINT16) does not meet UEFI Specification Data Type requirements");
821 STATIC_ASSERT (sizeof (INT32)   == 4, "sizeof (INT32) does not meet UEFI Specification Data Type requirements");
822 STATIC_ASSERT (sizeof (UINT32)  == 4, "sizeof (UINT32) does not meet UEFI Specification Data Type requirements");
823 STATIC_ASSERT (sizeof (INT64)   == 8, "sizeof (INT64) does not meet UEFI Specification Data Type requirements");
824 STATIC_ASSERT (sizeof (UINT64)  == 8, "sizeof (UINT64) does not meet UEFI Specification Data Type requirements");
825 STATIC_ASSERT (sizeof (CHAR8)   == 1, "sizeof (CHAR8) does not meet UEFI Specification Data Type requirements");
826 STATIC_ASSERT (sizeof (CHAR16)  == 2, "sizeof (CHAR16) does not meet UEFI Specification Data Type requirements");
827 // Apparently, gcc 7 and gcc 10 fail with those, gcc 12 seems to be ok.
828 // STATIC_ASSERT (sizeof (L'A')    == 2, "sizeof (L'A') does not meet UEFI Specification Data Type requirements");
829 // STATIC_ASSERT (sizeof (L"A")    == 4, "sizeof (L\"A\") does not meet UEFI Specification Data Type requirements");
830 
831 //
832 // The following three enum types are used to verify that the compiler
833 // configuration for enum types is compliant with Section 2.3.1 of the
834 // UEFI 2.3 Specification. These enum types and enum values are not
835 // intended to be used. A prefix of '__' is used avoid conflicts with
836 // other types.
837 //
838 typedef enum {
839   __VerifyUint8EnumValue = 0xff
840 } __VERIFY_UINT8_ENUM_SIZE;
841 
842 typedef enum {
843   __VerifyUint16EnumValue = 0xffff
844 } __VERIFY_UINT16_ENUM_SIZE;
845 
846 typedef enum {
847   __VerifyUint32EnumValue = 0xffffffff
848 } __VERIFY_UINT32_ENUM_SIZE;
849 
850 STATIC_ASSERT (sizeof (__VERIFY_UINT8_ENUM_SIZE) == 4, "Size of enum does not meet UEFI Specification Data Type requirements");
851 STATIC_ASSERT (sizeof (__VERIFY_UINT16_ENUM_SIZE) == 4, "Size of enum does not meet UEFI Specification Data Type requirements");
852 STATIC_ASSERT (sizeof (__VERIFY_UINT32_ENUM_SIZE) == 4, "Size of enum does not meet UEFI Specification Data Type requirements");
853 
854 /**
855   Macro that returns a pointer to the data structure that contains a specified field of
856   that data structure.  This is a lightweight method to hide information by placing a
857   public data structure inside a larger private data structure and using a pointer to
858   the public data structure to retrieve a pointer to the private data structure.
859 
860   This function computes the offset, in bytes, of field specified by Field from the beginning
861   of the  data structure specified by TYPE.  This offset is subtracted from Record, and is
862   used to return a pointer to a data structure of the type specified by TYPE. If the data type
863   specified by TYPE does not contain the field specified by Field, then the module will not compile.
864 
865   @param   Record   Pointer to the field specified by Field within a data structure of type TYPE.
866   @param   TYPE     The name of the data structure type to return.  This data structure must
867                     contain the field specified by Field.
868   @param   Field    The name of the field in the data structure specified by TYPE to which Record points.
869 
870   @return  A pointer to the structure from one of it's elements.
871 
872 **/
873 #define BASE_CR(Record, TYPE, Field)  ((TYPE *) ((CHAR8 *) (Record) - OFFSET_OF (TYPE, Field)))
874 
875 /**
876   Rounds a value up to the next boundary using a specified alignment.
877 
878   This function rounds Value up to the next boundary using the specified Alignment.
879   This aligned value is returned.
880 
881   @param   Value      The value to round up.
882   @param   Alignment  The alignment boundary used to return the aligned value.
883 
884   @return  A value up to the next boundary.
885 
886 **/
887 #define ALIGN_VALUE(Value, Alignment)  ((Value) + (((Alignment) - (Value)) & ((Alignment) - 1)))
888 
889 /**
890   Adjust a pointer by adding the minimum offset required for it to be aligned on
891   a specified alignment boundary.
892 
893   This function rounds the pointer specified by Pointer to the next alignment boundary
894   specified by Alignment. The pointer to the aligned address is returned.
895 
896   @param   Pointer    The pointer to round up.
897   @param   Alignment  The alignment boundary to use to return an aligned pointer.
898 
899   @return  Pointer to the aligned address.
900 
901 **/
902 #define ALIGN_POINTER(Pointer, Alignment)  ((VOID *) (ALIGN_VALUE ((UINTN)(Pointer), (Alignment))))
903 
904 /**
905   Rounds a value up to the next natural boundary for the current CPU.
906   This is 4-bytes for 32-bit CPUs and 8-bytes for 64-bit CPUs.
907 
908   This function rounds the value specified by Value up to the next natural boundary for the
909   current CPU. This rounded value is returned.
910 
911   @param   Value      The value to round up.
912 
913   @return  Rounded value specified by Value.
914 
915 **/
916 #define ALIGN_VARIABLE(Value)  ALIGN_VALUE ((Value), sizeof (UINTN))
917 
918 /**
919   Return the absolute value of a signed operand.
920 
921   This macro returns the absolute value of the signed operand specified by a.
922 
923   @param   a        The signed operand.
924 
925   @return  The absolute value of the signed operand.
926 
927 **/
928 #define ABS(a)                          \
929   (((a) < 0) ? (-(a)) : (a))
930 
931 //
932 // Status codes common to all execution phases
933 //
934 typedef UINTN RETURN_STATUS;
935 
936 /**
937   Produces a RETURN_STATUS code with the highest bit set.
938 
939   @param  StatusCode    The status code value to convert into a warning code.
940                         StatusCode must be in the range 0x00000000..0x7FFFFFFF.
941 
942   @return The value specified by StatusCode with the highest bit set.
943 
944 **/
945 #define ENCODE_ERROR(StatusCode)  ((RETURN_STATUS)(MAX_BIT | (StatusCode)))
946 
947 /**
948   Produces a RETURN_STATUS code with the highest bit clear.
949 
950   @param  StatusCode    The status code value to convert into a warning code.
951                         StatusCode must be in the range 0x00000000..0x7FFFFFFF.
952 
953   @return The value specified by StatusCode with the highest bit clear.
954 
955 **/
956 #define ENCODE_WARNING(StatusCode)  ((RETURN_STATUS)(StatusCode))
957 
958 /**
959   Returns TRUE if a specified RETURN_STATUS code is an error code.
960 
961   This function returns TRUE if StatusCode has the high bit set.  Otherwise, FALSE is returned.
962 
963   @param  StatusCode    The status code value to evaluate.
964 
965   @retval TRUE          The high bit of StatusCode is set.
966   @retval FALSE         The high bit of StatusCode is clear.
967 
968 **/
969 #define RETURN_ERROR(StatusCode)  (((INTN)(RETURN_STATUS)(StatusCode)) < 0)
970 
971 ///
972 /// The operation completed successfully.
973 ///
974 #define RETURN_SUCCESS  0
975 
976 ///
977 /// The image failed to load.
978 ///
979 #define RETURN_LOAD_ERROR  ENCODE_ERROR (1)
980 
981 ///
982 /// The parameter was incorrect.
983 ///
984 #define RETURN_INVALID_PARAMETER  ENCODE_ERROR (2)
985 
986 ///
987 /// The operation is not supported.
988 ///
989 #define RETURN_UNSUPPORTED  ENCODE_ERROR (3)
990 
991 ///
992 /// The buffer was not the proper size for the request.
993 ///
994 #define RETURN_BAD_BUFFER_SIZE  ENCODE_ERROR (4)
995 
996 ///
997 /// The buffer was not large enough to hold the requested data.
998 /// The required buffer size is returned in the appropriate
999 /// parameter when this error occurs.
1000 ///
1001 #define RETURN_BUFFER_TOO_SMALL  ENCODE_ERROR (5)
1002 
1003 ///
1004 /// There is no data pending upon return.
1005 ///
1006 #define RETURN_NOT_READY  ENCODE_ERROR (6)
1007 
1008 ///
1009 /// The physical device reported an error while attempting the
1010 /// operation.
1011 ///
1012 #define RETURN_DEVICE_ERROR  ENCODE_ERROR (7)
1013 
1014 ///
1015 /// The device can not be written to.
1016 ///
1017 #define RETURN_WRITE_PROTECTED  ENCODE_ERROR (8)
1018 
1019 ///
1020 /// The resource has run out.
1021 ///
1022 #define RETURN_OUT_OF_RESOURCES  ENCODE_ERROR (9)
1023 
1024 ///
1025 /// An inconsistency was detected on the file system causing the
1026 /// operation to fail.
1027 ///
1028 #define RETURN_VOLUME_CORRUPTED  ENCODE_ERROR (10)
1029 
1030 ///
1031 /// There is no more space on the file system.
1032 ///
1033 #define RETURN_VOLUME_FULL  ENCODE_ERROR (11)
1034 
1035 ///
1036 /// The device does not contain any medium to perform the
1037 /// operation.
1038 ///
1039 #define RETURN_NO_MEDIA  ENCODE_ERROR (12)
1040 
1041 ///
1042 /// The medium in the device has changed since the last
1043 /// access.
1044 ///
1045 #define RETURN_MEDIA_CHANGED  ENCODE_ERROR (13)
1046 
1047 ///
1048 /// The item was not found.
1049 ///
1050 #define RETURN_NOT_FOUND  ENCODE_ERROR (14)
1051 
1052 ///
1053 /// Access was denied.
1054 ///
1055 #define RETURN_ACCESS_DENIED  ENCODE_ERROR (15)
1056 
1057 ///
1058 /// The server was not found or did not respond to the request.
1059 ///
1060 #define RETURN_NO_RESPONSE  ENCODE_ERROR (16)
1061 
1062 ///
1063 /// A mapping to the device does not exist.
1064 ///
1065 #define RETURN_NO_MAPPING  ENCODE_ERROR (17)
1066 
1067 ///
1068 /// A timeout time expired.
1069 ///
1070 #define RETURN_TIMEOUT  ENCODE_ERROR (18)
1071 
1072 ///
1073 /// The protocol has not been started.
1074 ///
1075 #define RETURN_NOT_STARTED  ENCODE_ERROR (19)
1076 
1077 ///
1078 /// The protocol has already been started.
1079 ///
1080 #define RETURN_ALREADY_STARTED  ENCODE_ERROR (20)
1081 
1082 ///
1083 /// The operation was aborted.
1084 ///
1085 #define RETURN_ABORTED  ENCODE_ERROR (21)
1086 
1087 ///
1088 /// An ICMP error occurred during the network operation.
1089 ///
1090 #define RETURN_ICMP_ERROR  ENCODE_ERROR (22)
1091 
1092 ///
1093 /// A TFTP error occurred during the network operation.
1094 ///
1095 #define RETURN_TFTP_ERROR  ENCODE_ERROR (23)
1096 
1097 ///
1098 /// A protocol error occurred during the network operation.
1099 ///
1100 #define RETURN_PROTOCOL_ERROR  ENCODE_ERROR (24)
1101 
1102 ///
1103 /// A function encountered an internal version that was
1104 /// incompatible with a version requested by the caller.
1105 ///
1106 #define RETURN_INCOMPATIBLE_VERSION  ENCODE_ERROR (25)
1107 
1108 ///
1109 /// The function was not performed due to a security violation.
1110 ///
1111 #define RETURN_SECURITY_VIOLATION  ENCODE_ERROR (26)
1112 
1113 ///
1114 /// A CRC error was detected.
1115 ///
1116 #define RETURN_CRC_ERROR  ENCODE_ERROR (27)
1117 
1118 ///
1119 /// The beginning or end of media was reached.
1120 ///
1121 #define RETURN_END_OF_MEDIA  ENCODE_ERROR (28)
1122 
1123 ///
1124 /// The end of the file was reached.
1125 ///
1126 #define RETURN_END_OF_FILE  ENCODE_ERROR (31)
1127 
1128 ///
1129 /// The language specified was invalid.
1130 ///
1131 #define RETURN_INVALID_LANGUAGE  ENCODE_ERROR (32)
1132 
1133 ///
1134 /// The security status of the data is unknown or compromised
1135 /// and the data must be updated or replaced to restore a valid
1136 /// security status.
1137 ///
1138 #define RETURN_COMPROMISED_DATA  ENCODE_ERROR (33)
1139 
1140 ///
1141 /// A HTTP error occurred during the network operation.
1142 ///
1143 #define RETURN_HTTP_ERROR  ENCODE_ERROR (35)
1144 
1145 ///
1146 /// The string contained one or more characters that
1147 /// the device could not render and were skipped.
1148 ///
1149 #define RETURN_WARN_UNKNOWN_GLYPH  ENCODE_WARNING (1)
1150 
1151 ///
1152 /// The handle was closed, but the file was not deleted.
1153 ///
1154 #define RETURN_WARN_DELETE_FAILURE  ENCODE_WARNING (2)
1155 
1156 ///
1157 /// The handle was closed, but the data to the file was not
1158 /// flushed properly.
1159 ///
1160 #define RETURN_WARN_WRITE_FAILURE  ENCODE_WARNING (3)
1161 
1162 ///
1163 /// The resulting buffer was too small, and the data was
1164 /// truncated to the buffer size.
1165 ///
1166 #define RETURN_WARN_BUFFER_TOO_SMALL  ENCODE_WARNING (4)
1167 
1168 ///
1169 /// The data has not been updated within the timeframe set by
1170 /// local policy for this type of data.
1171 ///
1172 #define RETURN_WARN_STALE_DATA  ENCODE_WARNING (5)
1173 
1174 ///
1175 /// The resulting buffer contains UEFI-compliant file system.
1176 ///
1177 #define RETURN_WARN_FILE_SYSTEM  ENCODE_WARNING (6)
1178 
1179 /**
1180   Returns a 16-bit signature built from 2 ASCII characters.
1181 
1182   This macro returns a 16-bit value built from the two ASCII characters specified
1183   by A and B.
1184 
1185   @param  A    The first ASCII character.
1186   @param  B    The second ASCII character.
1187 
1188   @return A 16-bit value built from the two ASCII characters specified by A and B.
1189 
1190 **/
1191 #define SIGNATURE_16(A, B)  ((A) | (B << 8))
1192 
1193 /**
1194   Returns a 32-bit signature built from 4 ASCII characters.
1195 
1196   This macro returns a 32-bit value built from the four ASCII characters specified
1197   by A, B, C, and D.
1198 
1199   @param  A    The first ASCII character.
1200   @param  B    The second ASCII character.
1201   @param  C    The third ASCII character.
1202   @param  D    The fourth ASCII character.
1203 
1204   @return A 32-bit value built from the two ASCII characters specified by A, B,
1205           C and D.
1206 
1207 **/
1208 #define SIGNATURE_32(A, B, C, D)  (SIGNATURE_16 (A, B) | (SIGNATURE_16 (C, D) << 16))
1209 
1210 /**
1211   Returns a 64-bit signature built from 8 ASCII characters.
1212 
1213   This macro returns a 64-bit value built from the eight ASCII characters specified
1214   by A, B, C, D, E, F, G,and H.
1215 
1216   @param  A    The first ASCII character.
1217   @param  B    The second ASCII character.
1218   @param  C    The third ASCII character.
1219   @param  D    The fourth ASCII character.
1220   @param  E    The fifth ASCII character.
1221   @param  F    The sixth ASCII character.
1222   @param  G    The seventh ASCII character.
1223   @param  H    The eighth ASCII character.
1224 
1225   @return A 64-bit value built from the two ASCII characters specified by A, B,
1226           C, D, E, F, G and H.
1227 
1228 **/
1229 #define SIGNATURE_64(A, B, C, D, E, F, G, H) \
1230     (SIGNATURE_32 (A, B, C, D) | ((UINT64) (SIGNATURE_32 (E, F, G, H)) << 32))
1231 
1232 #if defined (_MSC_EXTENSIONS) && !defined (__INTEL_COMPILER) && !defined (MDE_CPU_EBC)
1233 void *
1234 _ReturnAddress (
1235   void
1236   );
1237 
1238   #pragma intrinsic(_ReturnAddress)
1239 
1240 /**
1241   Get the return address of the calling function.
1242 
1243   Based on intrinsic function _ReturnAddress that provides the address of
1244   the instruction in the calling function that will be executed after
1245   control returns to the caller.
1246 
1247   @param L    Return Level.
1248 
1249   @return The return address of the calling function or 0 if L != 0.
1250 
1251 **/
1252 #define RETURN_ADDRESS(L)  ((L == 0) ? _ReturnAddress() : (VOID *) 0)
1253 #elif defined (__GNUC__) || defined (__clang__)
1254 
1255 /**
1256   Get the return address of the calling function.
1257 
1258   Based on built-in Function __builtin_return_address that returns
1259   the return address of the current function, or of one of its callers.
1260 
1261   @param L    Return Level.
1262 
1263   @return The return address of the calling function.
1264 
1265 **/
1266 #define RETURN_ADDRESS(L)  __builtin_return_address (L)
1267 #else
1268 
1269 /**
1270   Get the return address of the calling function.
1271 
1272   @param L    Return Level.
1273 
1274   @return 0 as compilers don't support this feature.
1275 
1276 **/
1277 #define RETURN_ADDRESS(L)  ((VOID *) 0)
1278 #endif
1279 
1280 /**
1281   Return the number of elements in an array.
1282 
1283   @param  Array  An object of array type. Array is only used as an argument to
1284                  the sizeof operator, therefore Array is never evaluated. The
1285                  caller is responsible for ensuring that Array's type is not
1286                  incomplete; that is, Array must have known constant size.
1287 
1288   @return The number of elements in Array. The result has type UINTN.
1289 
1290 **/
1291 #define ARRAY_SIZE(Array)  (sizeof (Array) / sizeof ((Array)[0]))
1292 
1293 #endif /* __BASE_H__ */
1294