[mirror_edk2.git] / BaseTools / Source / C / FCE / Common.h

/** @file\r
\r
 Common library.\r
\r
 Copyright (c) 2011-2019, Intel Corporation. All rights reserved.<BR>\r
 SPDX-License-Identifier: BSD-2-Clause-Patent\r
\r
**/\r
#ifndef _COMMON_LIB_H_\r
#define _COMMON_LIB_H_\r
\r
#include <stdio.h>\r
#include <stdlib.h>\r
#include <string.h>\r
#ifdef __GNUC__\r
#include <unistd.h>\r
#else\r
#include <io.h>\r
#include <direct.h>\r
#endif\r
#include <ctype.h>\r
#include <assert.h>\r
#include <math.h>\r
#include "CommonLib.h"\r
#include <Common/UefiBaseTypes.h>\r
\r
#define MAX_QUI_PARAM_LEN              2000\r
#define ERROR_INFO_LENGTH              400\r
#define MAX_STR_LEN_FOR_PICK_UQI       200\r
#define MAX_PLATFORM_DEFAULT_ID_NUM    1000\r
#define _MAX_BUILD_VERSION             100\r
#define _MAXIMUM_SECTION_FILE_NUM      1000\r
\r
#ifndef _MAX_PATH\r
#define _MAX_PATH 500\r
#endif\r
\r
///\r
/// Variable attributes.\r
///\r
#define EFI_VARIABLE_NON_VOLATILE       0x00000001\r
#define EFI_VARIABLE_BOOTSERVICE_ACCESS 0x00000002\r
#define EFI_VARIABLE_RUNTIME_ACCESS     0x00000004\r
\r
///\r
/// This attribute is identified by the mnemonic 'HR'\r
/// elsewhere in this specification.\r
///\r
#define EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS   0x00000010\r
\r
#define VARSTORE_LIST_TYPE         0x0000000000000001ULL\r
#define EFI_VARSTORE_LIST_TYPE     0x0000000000000002ULL\r
#define PLATFORM_DEFAULT_ID_TYPE   0x0000000000000004ULL\r
#define UQI_LIST_TYPE              0x0000000000000008ULL\r
#define HII_OBJ_LIST_TYPE          0x0000000000000010ULL\r
\r
///\r
/// LIST_ENTRY structure definition.\r
///\r
typedef struct _LIST_ENTRY {\r
  struct _LIST_ENTRY  *ForwardLink;\r
  struct _LIST_ENTRY  *BackLink;\r
} LIST_ENTRY;\r
\r
#define CR(Record, TYPE, Field, TestSignature)  ((TYPE *) ((CHAR8 *) (Record) - (CHAR8 *) &(((TYPE *) 0)->Field)))\r
#define AllocateZeroPool(a)  calloc(a, sizeof (CHAR8))\r
#define FreePool(a) free(a)\r
#define CopyMem(a, b, c)  memcpy(a, b, c)\r
#define ZeroMem(a, b) memset(a, 0, b)\r
#define CompareMem(a, b, c)  memcmp(a, b, c)\r
#define AllocatePool(a)  malloc(a)\r
\r
/**\r
  Returns a 16-bit signature built from 2 ASCII characters.\r
\r
  This macro returns a 16-bit value built from the two ASCII characters specified\r
  by A and B.\r
\r
  @param  A    The first ASCII character.\r
  @param  B    The second ASCII character.\r
\r
  @return A 16-bit value built from the two ASCII characters specified by A and B.\r
\r
**/\r
#define SIGNATURE_16(A, B)        ((A) | (B << 8))\r
\r
/**\r
  Returns a 32-bit signature built from 4 ASCII characters.\r
\r
  This macro returns a 32-bit value built from the four ASCII characters specified\r
  by A, B, C, and D.\r
\r
  @param  A    The first ASCII character.\r
  @param  B    The second ASCII character.\r
  @param  C    The third ASCII character.\r
  @param  D    The fourth ASCII character.\r
\r
  @return A 32-bit value built from the two ASCII characters specified by A, B,\r
          C and D.\r
\r
**/\r
#define SIGNATURE_32(A, B, C, D)  (SIGNATURE_16 (A, B) | (SIGNATURE_16 (C, D) << 16))\r
\r
#define ASSERT_UNICODE_BUFFER(Buffer) ASSERT ((((UINTN) (Buffer)) & 0x01) == 0)\r
\r
/**\r
  Returns an argument of a specified type from a variable argument list and updates\r
  the pointer to the variable argument list to point to the next argument.\r
\r
  This function returns an argument of the type specified by TYPE from the beginning\r
  of the variable argument list specified by Marker.  Marker is then updated to point\r
  to the next argument in the variable argument list.  The method for computing the\r
  pointer to the next argument in the argument list is CPU specific following the EFIAPI ABI.\r
\r
  @param   Marker   The pointer to the beginning of a variable argument list.\r
  @param   TYPE     The type of argument to retrieve from the beginning\r
                    of the variable argument list.\r
\r
  @return  An argument of the type specified by TYPE.\r
\r
**/\r
#define BASE_ARG(Marker, TYPE)   (*(TYPE *) ((Marker += _BASE_INT_SIZE_OF (TYPE)) - _BASE_INT_SIZE_OF (TYPE)))\r
\r
///\r
/// Define the maximum number of characters that are required to\r
/// encode with a NULL terminator a decimal, hexadecimal, GUID,\r
/// or TIME value.\r
///\r
///  Maximum Length Decimal String     = 28\r
///    "-9,223,372,036,854,775,808"\r
///  Maximum Length Hexadecimal String = 17\r
///    "FFFFFFFFFFFFFFFF"\r
///  Maximum Length GUID               = 37\r
///    "00000000-0000-0000-0000-000000000000"\r
///  Maximum Length TIME               = 18\r
///    "12/12/2006  12:12"\r
///\r
#define MAXIMUM_VALUE_CHARACTERS  38\r
\r
///\r
/// Pointer to the start of a variable argument list stored in a memory buffer. Same as UINT8 *.\r
///\r
typedef UINTN  *BASE_LIST;\r
\r
/**\r
  Returns the size of a data type in sizeof(UINTN) units rounded up to the nearest UINTN boundary.\r
\r
  @param  TYPE  The date type to determine the size of.\r
\r
  @return The size of TYPE in sizeof (UINTN) units rounded up to the nearest UINTN boundary.\r
**/\r
#define _BASE_INT_SIZE_OF(TYPE) ((sizeof (TYPE) + sizeof (UINTN) - 1) / sizeof (UINTN))\r
\r
//\r
// Print primitives\r
//\r
#define PREFIX_SIGN           BIT1\r
#define PREFIX_BLANK          BIT2\r
#define LONG_TYPE             BIT4\r
#define OUTPUT_UNICODE        BIT6\r
#define FORMAT_UNICODE        BIT8\r
#define PAD_TO_WIDTH          BIT9\r
#define ARGUMENT_UNICODE      BIT10\r
#define PRECISION             BIT11\r
#define ARGUMENT_REVERSED     BIT12\r
#define COUNT_ONLY_NO_PRINT   BIT13\r
\r
///\r
/// Flags bitmask values use in UnicodeValueToString() and\r
/// AsciiValueToString()\r
///\r
#define LEFT_JUSTIFY      0x01\r
#define COMMA_TYPE        0x08\r
#define PREFIX_ZERO       0x20\r
#define RADIX_HEX         0x80\r
\r
//\r
// Record date and time information\r
//\r
typedef struct {\r
  UINT16  Year;\r
  UINT8   Month;\r
  UINT8   Day;\r
  UINT8   Hour;\r
  UINT8   Minute;\r
  UINT8   Second;\r
  UINT8   Pad1;\r
  UINT32  Nanosecond;\r
  INT16   TimeZone;\r
  UINT8   Daylight;\r
  UINT8   Pad2;\r
} TIME;\r
\r
\r
/**\r
  Copies one Null-terminated Unicode string to another Null-terminated Unicode\r
  string and returns the new Unicode string.\r
\r
  This function copies the contents of the Unicode string Source to the Unicode\r
  string Destination, and returns Destination. If Source and Destination\r
  overlap, then the results are undefined.\r
\r
  If Destination is NULL, then return NULL.\r
  If Destination is not aligned on a 16-bit boundary, then return NULL.\r
\r
  @param  Destination A pointer to a Null-terminated Unicode string.\r
  @param  Source      A pointer to a Null-terminated Unicode string.\r
\r
  @return Destination.\r
\r
**/\r
CHAR16 *\r
StrCpy (\r
  OUT     CHAR16                    *Destination,\r
  IN      CONST CHAR16              *Source\r
  );\r
\r
/**\r
  Returns the length of a Null-terminated Unicode string.\r
\r
  This function returns the number of Unicode characters in the Null-terminated\r
  Unicode string specified by String.\r
\r
  If String is NULL, then return 0.\r
\r
  @param  String  A pointer to a Null-terminated Unicode string.\r
\r
  @return The length of String.\r
\r
**/\r
UINTN\r
FceStrLen (\r
  IN      CONST CHAR16              *String\r
  );\r
\r
/**\r
  Returns the size of a Null-terminated Unicode string in bytes, including the\r
  Null terminator.\r
\r
  This function returns the size, in bytes, of the Null-terminated Unicode string\r
  specified by String.\r
\r
  If String is NULL, then ASSERT().\r
  If String is not aligned on a 16-bit boundary, then ASSERT().\r
  If PcdMaximumUnicodeStringLength is not zero, and String contains more than\r
  PcdMaximumUnicodeStringLength Unicode characters, not including the\r
  Null-terminator, then ASSERT().\r
\r
  @param  String  A pointer to a Null-terminated Unicode string.\r
\r
  @return The size of String.\r
\r
**/\r
UINTN\r
FceStrSize (\r
  IN      CONST CHAR16              *String\r
  );\r
\r
/**\r
  Compares two Null-terminated Unicode strings, and returns the difference\r
  between the first mismatched Unicode characters.\r
\r
  This function compares the Null-terminated Unicode string FirstString to the\r
  Null-terminated Unicode string SecondString. If FirstString is identical to\r
  SecondString, then 0 is returned. Otherwise, the value returned is the first\r
  mismatched Unicode character in SecondString subtracted from the first\r
  mismatched Unicode character in FirstString.\r
\r
  @param  FirstString   A pointer to a Null-terminated Unicode string.\r
  @param  SecondString  A pointer to a Null-terminated Unicode string.\r
\r
  @retval 0      FirstString is identical to SecondString.\r
  @return others FirstString is not identical to SecondString.\r
\r
**/\r
INTN\r
FceStrCmp (\r
  IN      CONST CHAR16              *FirstString,\r
  IN      CONST CHAR16              *SecondString\r
  );\r
\r
/**\r
  Concatenates one Null-terminated Unicode string to another Null-terminated\r
  Unicode string, and returns the concatenated Unicode string.\r
\r
  This function concatenates two Null-terminated Unicode strings. The contents\r
  of Null-terminated Unicode string Source are concatenated to the end of\r
  Null-terminated Unicode string Destination. The Null-terminated concatenated\r
  Unicode String is returned. If Source and Destination overlap, then the\r
  results are undefined.\r
\r
  If Destination is NULL, then ASSERT().\r
  If Destination is not aligned on a 16-bit boundary, then ASSERT().\r
  If Source is NULL, then ASSERT().\r
  If Source is not aligned on a 16-bit boundary, then ASSERT().\r
  If Source and Destination overlap, then ASSERT().\r
  If PcdMaximumUnicodeStringLength is not zero, and Destination contains more\r
  than PcdMaximumUnicodeStringLength Unicode characters, not including the\r
  Null-terminator, then ASSERT().\r
  If PcdMaximumUnicodeStringLength is not zero, and Source contains more than\r
  PcdMaximumUnicodeStringLength Unicode characters, not including the\r
  Null-terminator, then ASSERT().\r
  If PcdMaximumUnicodeStringLength is not zero, and concatenating Destination\r
  and Source results in a Unicode string with more than\r
  PcdMaximumUnicodeStringLength Unicode characters, not including the\r
  Null-terminator, then ASSERT().\r
\r
  @param  Destination A pointer to a Null-terminated Unicode string.\r
  @param  Source      A pointer to a Null-terminated Unicode string.\r
\r
  @return Destination.\r
\r
**/\r
CHAR16 *\r
StrCat (\r
  IN OUT  CHAR16                    *Destination,\r
  IN      CONST CHAR16              *Source\r
  );\r
\r
/**\r
  Returns the first occurrence of a Null-terminated Unicode sub-string\r
  in a Null-terminated Unicode string.\r
\r
  This function scans the contents of the Null-terminated Unicode string\r
  specified by String and returns the first occurrence of SearchString.\r
  If SearchString is not found in String, then NULL is returned.  If\r
  the length of SearchString is zero, then String is\r
  returned.\r
\r
  If String is NULL, then ASSERT().\r
  If String is not aligned on a 16-bit boundary, then ASSERT().\r
  If SearchString is NULL, then ASSERT().\r
  If SearchString is not aligned on a 16-bit boundary, then ASSERT().\r
\r
  If PcdMaximumUnicodeStringLength is not zero, and SearchString\r
  or String contains more than PcdMaximumUnicodeStringLength Unicode\r
  characters, not including the Null-terminator, then ASSERT().\r
\r
  @param  String          A pointer to a Null-terminated Unicode string.\r
  @param  SearchString    A pointer to a Null-terminated Unicode string to search for.\r
\r
  @retval NULL            If the SearchString does not appear in String.\r
  @return others          If there is a match.\r
\r
**/\r
CHAR16 *\r
StrStr (\r
  IN      CONST CHAR16              *String,\r
  IN      CONST CHAR16              *SearchString\r
  );\r
\r
/**\r
  Convert a Null-terminated Unicode decimal string to a value of\r
  type UINT64.\r
\r
  This function returns a value of type UINT64 by interpreting the contents\r
  of the Unicode string specified by String as a decimal number. The format\r
  of the input Unicode string String is:\r
\r
                  [spaces] [decimal digits].\r
\r
  The valid decimal digit character is in the range [0-9]. The\r
  function will ignore the pad space, which includes spaces or\r
  tab characters, before [decimal digits]. The running zero in the\r
  beginning of [decimal digits] will be ignored. Then, the function\r
  stops at the first character that is a not a valid decimal character\r
  or a Null-terminator, whichever one comes first.\r
\r
  If String is NULL, then ASSERT().\r
  If String is not aligned in a 16-bit boundary, then ASSERT().\r
  If String has only pad spaces, then 0 is returned.\r
  If String has no pad spaces or valid decimal digits,\r
  then 0 is returned.\r
  If the number represented by String overflows according\r
  to the range defined by UINT64, then ASSERT().\r
\r
  If PcdMaximumUnicodeStringLength is not zero, and String contains\r
  more than PcdMaximumUnicodeStringLength Unicode characters, not including\r
  the Null-terminator, then ASSERT().\r
\r
  @param  String          A pointer to a Null-terminated Unicode string.\r
\r
  @retval Value translated from String.\r
\r
**/\r
UINT64\r
FceStrDecimalToUint64 (\r
  IN      CONST CHAR16              *String\r
  );\r
\r
\r
/**\r
  Convert one Null-terminated ASCII string to a Null-terminated\r
  Unicode string and returns the Unicode string.\r
\r
  This function converts the contents of the ASCII string Source to the Unicode\r
  string Destination, and returns Destination.  The function terminates the\r
  Unicode string Destination by appending a Null-terminator character at the end.\r
  The caller is responsible to make sure Destination points to a buffer with size\r
  equal or greater than ((AsciiStrLen (Source) + 1) * sizeof (CHAR16)) in bytes.\r
\r
  @param  Source        A pointer to a Null-terminated ASCII string.\r
  @param  Destination   A pointer to a Null-terminated Unicode string.\r
\r
  @return Destination.\r
  @return NULL          If Destination or Source is NULL, return NULL.\r
\r
**/\r
CHAR16 *\r
AsciiStrToUnicodeStr (\r
  IN      CONST CHAR8               *Source,\r
  OUT     CHAR16                    *Destination\r
  );\r
\r
/**\r
  Worker function that produces a Null-terminated string in an output buffer\r
  based on a Null-terminated format string and variable argument list.\r
\r
  VSPrint function to process format and place the results in Buffer. Since a\r
  VA_LIST is used this routine allows the nesting of Vararg routines. Thus\r
  this is the main print working routine\r
\r
  @param  StartOfBuffer The character buffer to print the results of the parsing\r
                        of Format into.\r
  @param  BufferSize    The maximum number of characters to put into buffer.\r
                        Zero means no limit.\r
  @param  Flags         Initial flags value.\r
                        Can only have FORMAT_UNICODE and OUTPUT_UNICODE set\r
  @param  FormatString  A Null-terminated format string.\r
  @param  ...           The variable argument list.\r
\r
  @return The number of characters printed.\r
\r
**/\r
UINTN\r
BasePrintLibSPrint (\r
  OUT CHAR8        *StartOfBuffer,\r
  IN  UINTN        BufferSize,\r
  IN  UINTN        Flags,\r
  IN  CONST CHAR8  *FormatString,\r
  ...\r
  );\r
\r
/**\r
  Produces a Null-terminated Unicode string in an output buffer based on a Null-terminated\r
  Unicode format string and variable argument list.\r
\r
  Produces a Null-terminated Unicode string in the output buffer specified by StartOfBuffer\r
  and BufferSize.\r
  The Unicode string is produced by parsing the format string specified by FormatString.\r
  Arguments are pulled from the variable argument list based on the contents of the format string.\r
  The number of Unicode characters in the produced output buffer is returned not including\r
  the Null-terminator.\r
  If BufferSize is 0 or 1, then no output buffer is produced and 0 is returned.\r
\r
  If BufferSize > 1 and StartOfBuffer is NULL, then ASSERT().\r
  If BufferSize > 1 and StartOfBuffer is not aligned on a 16-bit boundary, then ASSERT().\r
  If BufferSize > 1 and FormatString is NULL, then ASSERT().\r
  If BufferSize > 1 and FormatString is not aligned on a 16-bit boundary, then ASSERT().\r
  If PcdMaximumUnicodeStringLength is not zero, and FormatString contains more than\r
  PcdMaximumUnicodeStringLength Unicode characters not including the Null-terminator, then\r
  ASSERT().\r
  If PcdMaximumUnicodeStringLength is not zero, and produced Null-terminated Unicode string\r
  contains more than PcdMaximumUnicodeStringLength Unicode characters not including the\r
  Null-terminator, then ASSERT().\r
\r
  @param  StartOfBuffer   A pointer to the output buffer for the produced Null-terminated\r
                          Unicode string.\r
  @param  BufferSize      The size, in bytes, of the output buffer specified by StartOfBuffer.\r
  @param  FormatString    A Null-terminated Unicode format string.\r
  @param  ...             Variable argument list whose contents are accessed based on the\r
                          format string specified by FormatString.\r
\r
  @return The number of Unicode characters in the produced output buffer not including the\r
          Null-terminator.\r
\r
**/\r
UINTN\r
UnicodeSPrint (\r
  OUT CHAR16        *StartOfBuffer,\r
  IN  UINTN         BufferSize,\r
  IN  CONST CHAR16  *FormatString,\r
  ...\r
  );\r
\r
/**\r
  Convert a Null-terminated Unicode string to a Null-terminated\r
  ASCII string and returns the ASCII string.\r
\r
  This function converts the content of the Unicode string Source\r
  to the ASCII string Destination by copying the lower 8 bits of\r
  each Unicode character. It returns Destination. The function terminates\r
  the ASCII string Destination  by appending a Null-terminator character\r
  at the end. The caller is responsible to make sure Destination points\r
  to a buffer with size equal or greater than (FceStrLen (Source) + 1) in bytes.\r
\r
  If Destination is NULL, then ASSERT().\r
  If Source is NULL, then ASSERT().\r
  If Source is not aligned on a 16-bit boundary, then ASSERT().\r
  If Source and Destination overlap, then ASSERT().\r
\r
  If any Unicode characters in Source contain non-zero value in\r
  the upper 8 bits, then ASSERT().\r
\r
  @param  Source        Pointer to a Null-terminated Unicode string.\r
  @param  Destination   Pointer to a Null-terminated ASCII string.\r
\r
  @reture Destination\r
\r
**/\r
CHAR8 *\r
UnicodeStrToAsciiStr (\r
  IN      CONST CHAR16             *Source,\r
  OUT           CHAR8              *Destination\r
  );\r
\r
/**\r
  Allocate new memory and then copy the Unicode string Source to Destination.\r
\r
  @param  Dest                   Location to copy string\r
  @param  Src                    String to copy\r
\r
**/\r
VOID\r
NewStringCpy (\r
  IN OUT CHAR16       **Dest,\r
  IN CHAR16           *Src\r
  );\r
\r
/**\r
  Convert a Null-terminated Unicode hexadecimal string to a value of type UINT64.\r
\r
  This function returns a value of type UINT64 by interpreting the contents\r
  of the Unicode string specified by String as a hexadecimal number.\r
  The format of the input Unicode string String is\r
\r
                  [spaces][zeros][x][hexadecimal digits].\r
\r
  The valid hexadecimal digit character is in the range [0-9], [a-f] and [A-F].\r
  The prefix "0x" is optional. Both "x" and "X" is allowed in "0x" prefix.\r
  If "x" appears in the input string, it must be prefixed with at least one 0.\r
  The function will ignore the pad space, which includes spaces or tab characters,\r
  before [zeros], [x] or [hexadecimal digit]. The running zero before [x] or\r
  [hexadecimal digit] will be ignored. Then, the decoding starts after [x] or the\r
  first valid hexadecimal digit. Then, the function stops at the first character that is\r
  a not a valid hexadecimal character or NULL, whichever one comes first.\r
\r
  If String is NULL, then ASSERT().\r
  If String is not aligned in a 16-bit boundary, then ASSERT().\r
  If String has only pad spaces, then zero is returned.\r
  If String has no leading pad spaces, leading zeros or valid hexadecimal digits,\r
  then zero is returned.\r
  If the number represented by String overflows according to the range defined by\r
  UINT64, then ASSERT().\r
\r
  If PcdMaximumUnicodeStringLength is not zero, and String contains more than\r
  PcdMaximumUnicodeStringLength Unicode characters, not including the Null-terminator,\r
  then ASSERT().\r
\r
  @param  String          A pointer to a Null-terminated Unicode string.\r
\r
  @retval Value translated from String.\r
\r
**/\r
UINT64\r
FceStrHexToUint64 (\r
  IN      CONST CHAR16             *String\r
  );\r
\r
\r
CHAR16\r
ToUpper (\r
  CHAR16  a\r
  );\r
\r
CHAR16\r
ToLower (\r
  CHAR16  a\r
  );\r
\r
/**\r
  Performs a case-insensitive comparison between a Null-terminated\r
  Unicode pattern string and a Null-terminated Unicode string.\r
\r
  @param  String   - A pointer to a Null-terminated Unicode string.\r
  @param  Pattern  - A pointer to a Null-terminated Unicode pattern string.\r
\r
\r
  @retval TRUE     - Pattern was found in String.\r
  @retval FALSE    - Pattern was not found in String.\r
\r
**/\r
BOOLEAN\r
MetaiMatch (\r
  IN CHAR16                           *String,\r
  IN CHAR16                           *Pattern\r
  );\r
\r
/**\r
  Multiplies a 64-bit unsigned integer by a 32-bit unsigned integer and\r
  generates a 64-bit unsigned result.\r
\r
  This function multiplies the 64-bit unsigned value Multiplicand by the 32-bit\r
  unsigned value Multiplier and generates a 64-bit unsigned result. This 64-\r
  bit unsigned result is returned.\r
\r
  @param  Multiplicand  A 64-bit unsigned value.\r
  @param  Multiplier    A 32-bit unsigned value.\r
\r
  @return Multiplicand * Multiplier.\r
\r
**/\r
UINT64\r
MultU64x32 (\r
  IN      UINT64                    Multiplicand,\r
  IN      UINT32                    Multiplier\r
  );\r
\r
/**\r
  Divides a 64-bit unsigned integer by a 32-bit unsigned integer and generates\r
  a 64-bit unsigned result.\r
\r
  This function divides the 64-bit unsigned value Dividend by the 32-bit\r
  unsigned value Divisor and generates a 64-bit unsigned quotient. This\r
  function returns the 64-bit unsigned quotient.\r
\r
  If Divisor is 0, then ASSERT().\r
\r
  @param  Dividend  A 64-bit unsigned value.\r
  @param  Divisor   A 32-bit unsigned value.\r
\r
  @return Dividend / Divisor\r
\r
**/\r
UINT64\r
DivU64x32 (\r
  IN      UINT64                    Dividend,\r
  IN      UINT32                    Divisor\r
  );\r
\r
/**\r
  Shifts a 64-bit integer left between 0 and 63 bits. The low bits are filled\r
  with zeros. The shifted value is returned.\r
\r
  This function shifts the 64-bit value Operand to the left by Count bits. The\r
  low Count bits are set to zero. The shifted value is returned.\r
\r
  If Count is greater than 63, then ASSERT().\r
\r
  @param  Operand The 64-bit operand to shift left.\r
  @param  Count   The number of bits to shift left.\r
\r
  @return Operand << Count.\r
\r
**/\r
UINT64\r
LShiftU64 (\r
  IN      UINT64                    Operand,\r
  IN      UINTN                     Count\r
  );\r
\r
/**\r
  Shifts a 64-bit integer right between 0 and 63 bits. This high bits are\r
  filled with zeros. The shifted value is returned.\r
\r
  This function shifts the 64-bit value Operand to the right by Count bits. The\r
  high Count bits are set to zero. The shifted value is returned.\r
\r
  If Count is greater than 63, then ASSERT().\r
\r
  @param  Operand The 64-bit operand to shift right.\r
  @param  Count   The number of bits to shift right.\r
\r
  @return Operand >> Count.\r
\r
**/\r
UINT64\r
RShiftU64 (\r
  IN      UINT64                    Operand,\r
  IN      UINTN                     Count\r
  );\r
\r
\r
/**\r
  Divides a 64-bit unsigned integer by a 32-bit unsigned integer and generates\r
  a 64-bit unsigned result and an optional 32-bit unsigned remainder.\r
\r
  This function divides the 64-bit unsigned value Dividend by the 32-bit\r
  unsigned value Divisor and generates a 64-bit unsigned quotient. If Remainder\r
  is not NULL, then the 32-bit unsigned remainder is returned in Remainder.\r
  This function returns the 64-bit unsigned quotient.\r
\r
  If Divisor is 0, then ASSERT().\r
\r
  @param  Dividend  A 64-bit unsigned value.\r
  @param  Divisor   A 32-bit unsigned value.\r
  @param  Remainder A pointer to a 32-bit unsigned value. This parameter is\r
                    optional and may be NULL.\r
\r
  @return Dividend / Divisor\r
\r
**/\r
UINT64\r
DivU64x32Remainder (\r
  IN      UINT64                    Dividend,\r
  IN      UINT32                    Divisor,\r
  OUT     UINT32                    *Remainder\r
  );\r
\r
/**\r
  Copies a buffer to an allocated buffer.\r
\r
  Allocates the number bytes specified by AllocationSize, copies allocationSize bytes\r
  from Buffer to the newly allocated buffer, and returns a pointer to the allocated\r
  buffer.  If AllocationSize is 0, then a valid buffer of 0 size is returned.  If there\r
  is not enough memory remaining to satisfy the request, then NULL is returned.\r
\r
  If Buffer is NULL, then ASSERT().\r
\r
  @param  AllocationSize        The number of bytes to allocate and zero.\r
  @param  Buffer                The buffer to copy to the allocated buffer.\r
\r
  @return A pointer to the allocated buffer or NULL if allocation fails.\r
\r
**/\r
VOID *\r
FceAllocateCopyPool (\r
  IN UINTN       AllocationSize,\r
  IN CONST VOID  *Buffer\r
  );\r
\r
/**\r
  Initializes the head node of a doubly-linked list, and returns the pointer to\r
  the head node of the doubly-linked list.\r
\r
  Initializes the forward and backward links of a new linked list. After\r
  initializing a linked list with this function, the other linked list\r
  functions may be used to add and remove nodes from the linked list. It is up\r
  to the caller of this function to allocate the memory for ListHead.\r
\r
  If ListHead is NULL, then ASSERT().\r
\r
  @param  ListHead  A pointer to the head node of a new doubly-linked list.\r
\r
  @return ListHead\r
\r
**/\r
LIST_ENTRY *\r
InitializeListHead (\r
  IN OUT  LIST_ENTRY                *ListHead\r
  );\r
\r
/**\r
  Adds a node to the beginning of a doubly-linked list, and returns the pointer\r
  to the head node of the doubly-linked list.\r
\r
  Adds the node Entry at the beginning of the doubly-linked list denoted by\r
  ListHead, and returns ListHead.\r
\r
  If ListHead is NULL, then ASSERT().\r
  If Entry is NULL, then ASSERT().\r
  If ListHead was not initialized with INTIALIZE_LIST_HEAD_VARIABLE() or\r
  InitializeListHead(), then ASSERT().\r
  If PcdMaximumLinkedListLenth is not zero, and prior to insertion the number\r
  of nodes in ListHead, including the ListHead node, is greater than or\r
  equal to PcdMaximumLinkedListLength, then ASSERT().\r
\r
  @param  ListHead  A pointer to the head node of a doubly-linked list.\r
  @param  Entry     A pointer to a node that is to be inserted at the beginning\r
                    of a doubly-linked list.\r
\r
  @return ListHead\r
\r
**/\r
LIST_ENTRY *\r
InsertHeadList (\r
  IN OUT  LIST_ENTRY                *ListHead,\r
  IN OUT  LIST_ENTRY                *Entry\r
  );\r
\r
/**\r
  Adds a node to the end of a doubly-linked list, and returns the pointer to\r
  the head node of the doubly-linked list.\r
\r
  Adds the node Entry to the end of the doubly-linked list denoted by ListHead,\r
  and returns ListHead.\r
\r
  If ListHead is NULL, then ASSERT().\r
  If Entry is NULL, then ASSERT().\r
  If ListHead was not initialized with INTIALIZE_LIST_HEAD_VARIABLE() or\r
  InitializeListHead(), then ASSERT().\r
  If PcdMaximumLinkedListLenth is not zero, and prior to insertion the number\r
  of nodes in ListHead, including the ListHead node, is greater than or\r
  equal to PcdMaximumLinkedListLength, then ASSERT().\r
\r
  @param  ListHead  A pointer to the head node of a doubly-linked list.\r
  @param  Entry     A pointer to a node that is to be added at the end of the\r
                    doubly-linked list.\r
\r
  @return ListHead\r
\r
**/\r
LIST_ENTRY *\r
InsertTailList (\r
  IN OUT  LIST_ENTRY                *ListHead,\r
  IN OUT  LIST_ENTRY                *Entry\r
  );\r
\r
/**\r
  Retrieves the first node of a doubly-linked list.\r
\r
  Returns the first node of a doubly-linked list.  List must have been\r
  initialized with INTIALIZE_LIST_HEAD_VARIABLE() or InitializeListHead().\r
  If List is empty, then List is returned.\r
\r
  If List is NULL, then ASSERT().\r
  If List was not initialized with INTIALIZE_LIST_HEAD_VARIABLE() or\r
  InitializeListHead(), then ASSERT().\r
  If PcdMaximumLinkedListLenth is not zero, and the number of nodes\r
  in List, including the List node, is greater than or equal to\r
  PcdMaximumLinkedListLength, then ASSERT().\r
\r
  @param  List  A pointer to the head node of a doubly-linked list.\r
\r
  @return The first node of a doubly-linked list.\r
  @retval NULL  The list is empty.\r
\r
**/\r
LIST_ENTRY *\r
GetFirstNode (\r
  IN      CONST LIST_ENTRY          *List\r
  );\r
\r
/**\r
  Retrieves the next node of a doubly-linked list.\r
\r
  Returns the node of a doubly-linked list that follows Node.\r
  List must have been initialized with INTIALIZE_LIST_HEAD_VARIABLE()\r
  or InitializeListHead().  If List is empty, then List is returned.\r
\r
  If List is NULL, then ASSERT().\r
  If Node is NULL, then ASSERT().\r
  If List was not initialized with INTIALIZE_LIST_HEAD_VARIABLE() or\r
  InitializeListHead(), then ASSERT().\r
  If PcdMaximumLinkedListLenth is not zero, and List contains more than\r
  PcdMaximumLinkedListLenth nodes, then ASSERT().\r
  If PcdVerifyNodeInList is TRUE and Node is not a node in List, then ASSERT().\r
\r
  @param  List  A pointer to the head node of a doubly-linked list.\r
  @param  Node  A pointer to a node in the doubly-linked list.\r
\r
  @return A pointer to the next node if one exists. Otherwise List is returned.\r
\r
**/\r
LIST_ENTRY *\r
GetNextNode (\r
  IN      CONST LIST_ENTRY          *List,\r
  IN      CONST LIST_ENTRY          *Node\r
  );\r
\r
/**\r
  Retrieves the previous node of a doubly-linked list.\r
\r
  Returns the node of a doubly-linked list that precedes Node.\r
  List must have been initialized with INTIALIZE_LIST_HEAD_VARIABLE()\r
  or InitializeListHead().  If List is empty, then List is returned.\r
\r
  If List is NULL, then ASSERT().\r
  If Node is NULL, then ASSERT().\r
  If List was not initialized with INTIALIZE_LIST_HEAD_VARIABLE() or\r
  InitializeListHead(), then ASSERT().\r
  If PcdMaximumLinkedListLenth is not zero, and List contains more than\r
  PcdMaximumLinkedListLenth nodes, then ASSERT().\r
  If PcdVerifyNodeInList is TRUE and Node is not a node in List, then ASSERT().\r
\r
  @param  List  A pointer to the head node of a doubly-linked list.\r
  @param  Node  A pointer to a node in the doubly-linked list.\r
\r
  @return A pointer to the previous node if one exists. Otherwise List is returned.\r
\r
**/\r
LIST_ENTRY *\r
GetPreviousNode (\r
  IN      CONST LIST_ENTRY          *List,\r
  IN      CONST LIST_ENTRY          *Node\r
  );\r
\r
/**\r
  Checks to see if a doubly-linked list is empty or not.\r
\r
  Checks to see if the doubly-linked list is empty. If the linked list contains\r
  zero nodes, this function returns TRUE. Otherwise, it returns FALSE.\r
\r
  If ListHead is NULL, then ASSERT().\r
  If ListHead was not initialized with INTIALIZE_LIST_HEAD_VARIABLE() or\r
  InitializeListHead(), then ASSERT().\r
  If PcdMaximumLinkedListLenth is not zero, and the number of nodes\r
  in List, including the List node, is greater than or equal to\r
  PcdMaximumLinkedListLength, then ASSERT().\r
\r
  @param  ListHead  A pointer to the head node of a doubly-linked list.\r
\r
  @retval TRUE  The linked list is empty.\r
  @retval FALSE The linked list is not empty.\r
\r
**/\r
BOOLEAN\r
IsListEmpty (\r
  IN      CONST LIST_ENTRY          *ListHead\r
  );\r
\r
/**\r
  Determines if a node in a doubly-linked list is the head node of a the same\r
  doubly-linked list.  This function is typically used to terminate a loop that\r
  traverses all the nodes in a doubly-linked list starting with the head node.\r
\r
  Returns TRUE if Node is equal to List.  Returns FALSE if Node is one of the\r
  nodes in the doubly-linked list specified by List.  List must have been\r
  initialized with INTIALIZE_LIST_HEAD_VARIABLE() or InitializeListHead().\r
\r
  If List is NULL, then ASSERT().\r
  If Node is NULL, then ASSERT().\r
  If List was not initialized with INTIALIZE_LIST_HEAD_VARIABLE() or InitializeListHead(),\r
  then ASSERT().\r
  If PcdMaximumLinkedListLenth is not zero, and the number of nodes\r
  in List, including the List node, is greater than or equal to\r
  PcdMaximumLinkedListLength, then ASSERT().\r
  If PcdVerifyNodeInList is TRUE and Node is not a node in List and Node is not\r
  equal to List, then ASSERT().\r
\r
  @param  List  A pointer to the head node of a doubly-linked list.\r
  @param  Node  A pointer to a node in the doubly-linked list.\r
\r
  @retval TRUE  Node is the head of the doubly-linked list pointed by List.\r
  @retval FALSE Node is not the head of the doubly-linked list pointed by List.\r
\r
**/\r
BOOLEAN\r
IsNull (\r
  IN      CONST LIST_ENTRY          *List,\r
  IN      CONST LIST_ENTRY          *Node\r
  );\r
\r
/**\r
  Determines if a node the last node in a doubly-linked list.\r
\r
  Returns TRUE if Node is the last node in the doubly-linked list specified by\r
  List. Otherwise, FALSE is returned. List must have been initialized with\r
  INTIALIZE_LIST_HEAD_VARIABLE() or InitializeListHead().\r
\r
  If List is NULL, then ASSERT().\r
  If Node is NULL, then ASSERT().\r
  If List was not initialized with INTIALIZE_LIST_HEAD_VARIABLE() or\r
  InitializeListHead(), then ASSERT().\r
  If PcdMaximumLinkedListLenth is not zero, and the number of nodes\r
  in List, including the List node, is greater than or equal to\r
  PcdMaximumLinkedListLength, then ASSERT().\r
  If PcdVerifyNodeInList is TRUE and Node is not a node in List, then ASSERT().\r
\r
  @param  List  A pointer to the head node of a doubly-linked list.\r
  @param  Node  A pointer to a node in the doubly-linked list.\r
\r
  @retval TRUE  Node is the last node in the linked list.\r
  @retval FALSE Node is not the last node in the linked list.\r
\r
**/\r
BOOLEAN\r
IsNodeAtEnd (\r
  IN      CONST LIST_ENTRY          *List,\r
  IN      CONST LIST_ENTRY          *Node\r
  );\r
\r
/**\r
  Removes a node from a doubly-linked list, and returns the node that follows\r
  the removed node.\r
\r
  Removes the node Entry from a doubly-linked list. It is up to the caller of\r
  this function to release the memory used by this node if that is required. On\r
  exit, the node following Entry in the doubly-linked list is returned. If\r
  Entry is the only node in the linked list, then the head node of the linked\r
  list is returned.\r
\r
  If Entry is NULL, then ASSERT().\r
  If Entry is the head node of an empty list, then ASSERT().\r
  If PcdMaximumLinkedListLength is not zero, and the number of nodes in the\r
  linked list containing Entry, including the Entry node, is greater than\r
  or equal to PcdMaximumLinkedListLength, then ASSERT().\r
\r
  @param  Entry A pointer to a node in a linked list.\r
\r
  @return Entry.\r
\r
**/\r
LIST_ENTRY *\r
RemoveEntryList (\r
  IN      CONST LIST_ENTRY          *Entry\r
  );\r
\r
#endif\r