| /** @file |
| This library provides helper functions to prevent integer overflow during |
| type conversion, addition, subtraction, and multiplication. |
| |
| Copyright (c) 2017, Microsoft Corporation |
| |
| All rights reserved. |
| SPDX-License-Identifier: BSD-2-Clause-Patent |
| |
| **/ |
| |
| #ifndef __INT_SAFE_LIB_H__ |
| #define __INT_SAFE_LIB_H__ |
| |
| // |
| // It is common for -1 to be used as an error value |
| // |
| #define INT8_ERROR ((INT8) -1) |
| #define UINT8_ERROR MAX_UINT8 |
| #define CHAR8_ERROR ((CHAR8)(MAX_INT8)) |
| #define INT16_ERROR ((INT16) -1) |
| #define UINT16_ERROR MAX_UINT16 |
| #define CHAR16_ERROR MAX_UINT16 |
| #define INT32_ERROR ((INT32) -1) |
| #define UINT32_ERROR MAX_UINT32 |
| #define INT64_ERROR ((INT64) -1) |
| #define UINT64_ERROR MAX_UINT64 |
| #define INTN_ERROR ((INTN) -1) |
| #define UINTN_ERROR MAX_UINTN |
| |
| // |
| // CHAR16 is defined to be the same as UINT16, so for CHAR16 |
| // operations redirect to the UINT16 ones: |
| // |
| #define SafeInt8ToChar16 SafeInt8ToUint16 |
| #define SafeInt16ToChar16 SafeInt16ToUint16 |
| #define SafeInt32ToChar16 SafeInt32ToUint16 |
| #define SafeUint32ToChar16 SafeUint32ToUint16 |
| #define SafeInt64ToChar16 SafeInt64ToUint16 |
| #define SafeUint64ToChar16 SafeUint64ToUint16 |
| #define SafeIntnToChar16 SafeIntnToUint16 |
| #define SafeUintnToChar16 SafeUintnToUint16 |
| |
| #define SafeChar16ToInt8 SafeUint16ToInt8 |
| #define SafeChar16ToUint8 SafeUint16ToUint8 |
| #define SafeChar16ToChar8 SafeUint16ToChar8 |
| #define SafeChar16ToInt16 SafeUint16ToInt16 |
| |
| #define SafeChar16Mult SafeUint16Mult |
| #define SafeChar16Sub SafeUint16Sub |
| #define SafeChar16Add SafeUint16Add |
| |
| // |
| // Conversion functions |
| // |
| // There are three reasons for having conversion functions: |
| // |
| // 1. We are converting from a signed type to an unsigned type of the same |
| // size, or vice-versa. |
| // |
| // 2. We are converting to a smaller type, and we could therefore possibly |
| // overflow. |
| // |
| // 3. We are converting to a bigger type, and we are signed and the type we are |
| // converting to is unsigned. |
| // |
| |
| /** |
| INT8 -> UINT8 conversion |
| |
| Converts the value specified by Operand to a value specified by Result type |
| and stores the converted value into the caller allocated output buffer |
| specified by Result. The caller must pass in a Result buffer that is at |
| least as large as the Result type. |
| |
| If Result is NULL, RETURN_INVALID_PARAMETER is returned. |
| |
| If the conversion results in an overflow or an underflow condition, then |
| Result is set to UINT8_ERROR and RETURN_BUFFER_TOO_SMALL is returned. |
| |
| @param[in] Operand Operand to be converted to new type |
| @param[out] Result Pointer to the result of conversion |
| |
| @retval RETURN_SUCCESS Successful conversion |
| @retval RETURN_BUFFER_TOO_SMALL Overflow |
| @retval RETURN_INVALID_PARAMETER Result is NULL |
| **/ |
| RETURN_STATUS |
| EFIAPI |
| SafeInt8ToUint8 ( |
| IN INT8 Operand, |
| OUT UINT8 *Result |
| ); |
| |
| /** |
| INT8 -> CHAR8 conversion |
| |
| Converts the value specified by Operand to a value specified by Result type |
| and stores the converted value into the caller allocated output buffer |
| specified by Result. The caller must pass in a Result buffer that is at |
| least as large as the Result type. |
| |
| If Result is NULL, RETURN_INVALID_PARAMETER is returned. |
| |
| If the conversion results in an overflow or an underflow condition, then |
| Result is set to CHAR8_ERROR and RETURN_BUFFER_TOO_SMALL is returned. |
| |
| @param[in] Operand Operand to be converted to new type |
| @param[out] Result Pointer to the result of conversion |
| |
| @retval RETURN_SUCCESS Successful conversion |
| @retval RETURN_BUFFER_TOO_SMALL Overflow |
| @retval RETURN_INVALID_PARAMETER Result is NULL |
| **/ |
| RETURN_STATUS |
| EFIAPI |
| SafeInt8ToChar8 ( |
| IN INT8 Operand, |
| OUT CHAR8 *Result |
| ); |
| |
| /** |
| INT8 -> UINT16 conversion |
| |
| Converts the value specified by Operand to a value specified by Result type |
| and stores the converted value into the caller allocated output buffer |
| specified by Result. The caller must pass in a Result buffer that is at |
| least as large as the Result type. |
| |
| If Result is NULL, RETURN_INVALID_PARAMETER is returned. |
| |
| If the conversion results in an overflow or an underflow condition, then |
| Result is set to UINT16_ERROR and RETURN_BUFFER_TOO_SMALL is returned. |
| |
| @param[in] Operand Operand to be converted to new type |
| @param[out] Result Pointer to the result of conversion |
| |
| @retval RETURN_SUCCESS Successful conversion |
| @retval RETURN_BUFFER_TOO_SMALL Overflow |
| @retval RETURN_INVALID_PARAMETER Result is NULL |
| **/ |
| RETURN_STATUS |
| EFIAPI |
| SafeInt8ToUint16 ( |
| IN INT8 Operand, |
| OUT UINT16 *Result |
| ); |
| |
| /** |
| INT8 -> UINT32 conversion |
| |
| Converts the value specified by Operand to a value specified by Result type |
| and stores the converted value into the caller allocated output buffer |
| specified by Result. The caller must pass in a Result buffer that is at |
| least as large as the Result type. |
| |
| If Result is NULL, RETURN_INVALID_PARAMETER is returned. |
| |
| If the conversion results in an overflow or an underflow condition, then |
| Result is set to UINT32_ERROR and RETURN_BUFFER_TOO_SMALL is returned. |
| |
| @param[in] Operand Operand to be converted to new type |
| @param[out] Result Pointer to the result of conversion |
| |
| @retval RETURN_SUCCESS Successful conversion |
| @retval RETURN_BUFFER_TOO_SMALL Overflow |
| @retval RETURN_INVALID_PARAMETER Result is NULL |
| **/ |
| RETURN_STATUS |
| EFIAPI |
| SafeInt8ToUint32 ( |
| IN INT8 Operand, |
| OUT UINT32 *Result |
| ); |
| |
| /** |
| INT8 -> UINTN conversion |
| |
| Converts the value specified by Operand to a value specified by Result type |
| and stores the converted value into the caller allocated output buffer |
| specified by Result. The caller must pass in a Result buffer that is at |
| least as large as the Result type. |
| |
| If Result is NULL, RETURN_INVALID_PARAMETER is returned. |
| |
| If the conversion results in an overflow or an underflow condition, then |
| Result is set to UINTN_ERROR and RETURN_BUFFER_TOO_SMALL is returned. |
| |
| @param[in] Operand Operand to be converted to new type |
| @param[out] Result Pointer to the result of conversion |
| |
| @retval RETURN_SUCCESS Successful conversion |
| @retval RETURN_BUFFER_TOO_SMALL Overflow |
| @retval RETURN_INVALID_PARAMETER Result is NULL |
| **/ |
| RETURN_STATUS |
| EFIAPI |
| SafeInt8ToUintn ( |
| IN INT8 Operand, |
| OUT UINTN *Result |
| ); |
| |
| /** |
| INT8 -> UINT64 conversion |
| |
| Converts the value specified by Operand to a value specified by Result type |
| and stores the converted value into the caller allocated output buffer |
| specified by Result. The caller must pass in a Result buffer that is at |
| least as large as the Result type. |
| |
| If Result is NULL, RETURN_INVALID_PARAMETER is returned. |
| |
| If the conversion results in an overflow or an underflow condition, then |
| Result is set to UINT64_ERROR and RETURN_BUFFER_TOO_SMALL is returned. |
| |
| @param[in] Operand Operand to be converted to new type |
| @param[out] Result Pointer to the result of conversion |
| |
| @retval RETURN_SUCCESS Successful conversion |
| @retval RETURN_BUFFER_TOO_SMALL Overflow |
| @retval RETURN_INVALID_PARAMETER Result is NULL |
| **/ |
| RETURN_STATUS |
| EFIAPI |
| SafeInt8ToUint64 ( |
| IN INT8 Operand, |
| OUT UINT64 *Result |
| ); |
| |
| /** |
| UINT8 -> INT8 conversion |
| |
| Converts the value specified by Operand to a value specified by Result type |
| and stores the converted value into the caller allocated output buffer |
| specified by Result. The caller must pass in a Result buffer that is at |
| least as large as the Result type. |
| |
| If Result is NULL, RETURN_INVALID_PARAMETER is returned. |
| |
| If the conversion results in an overflow or an underflow condition, then |
| Result is set to INT8_ERROR and RETURN_BUFFER_TOO_SMALL is returned. |
| |
| @param[in] Operand Operand to be converted to new type |
| @param[out] Result Pointer to the result of conversion |
| |
| @retval RETURN_SUCCESS Successful conversion |
| @retval RETURN_BUFFER_TOO_SMALL Overflow |
| @retval RETURN_INVALID_PARAMETER Result is NULL |
| **/ |
| RETURN_STATUS |
| EFIAPI |
| SafeUint8ToInt8 ( |
| IN UINT8 Operand, |
| OUT INT8 *Result |
| ); |
| |
| /** |
| UINT8 -> CHAR8 conversion |
| |
| Converts the value specified by Operand to a value specified by Result type |
| and stores the converted value into the caller allocated output buffer |
| specified by Result. The caller must pass in a Result buffer that is at |
| least as large as the Result type. |
| |
| If Result is NULL, RETURN_INVALID_PARAMETER is returned. |
| |
| If the conversion results in an overflow or an underflow condition, then |
| Result is set to CHAR8_ERROR and RETURN_BUFFER_TOO_SMALL is returned. |
| |
| @param[in] Operand Operand to be converted to new type |
| @param[out] Result Pointer to the result of conversion |
| |
| @retval RETURN_SUCCESS Successful conversion |
| @retval RETURN_BUFFER_TOO_SMALL Overflow |
| @retval RETURN_INVALID_PARAMETER Result is NULL |
| **/ |
| RETURN_STATUS |
| EFIAPI |
| SafeUint8ToChar8 ( |
| IN UINT8 Operand, |
| OUT CHAR8 *Result |
| ); |
| |
| /** |
| INT16 -> INT8 conversion |
| |
| Converts the value specified by Operand to a value specified by Result type |
| and stores the converted value into the caller allocated output buffer |
| specified by Result. The caller must pass in a Result buffer that is at |
| least as large as the Result type. |
| |
| If Result is NULL, RETURN_INVALID_PARAMETER is returned. |
| |
| If the conversion results in an overflow or an underflow condition, then |
| Result is set to INT8_ERROR and RETURN_BUFFER_TOO_SMALL is returned. |
| |
| @param[in] Operand Operand to be converted to new type |
| @param[out] Result Pointer to the result of conversion |
| |
| @retval RETURN_SUCCESS Successful conversion |
| @retval RETURN_BUFFER_TOO_SMALL Overflow |
| @retval RETURN_INVALID_PARAMETER Result is NULL |
| **/ |
| RETURN_STATUS |
| EFIAPI |
| SafeInt16ToInt8 ( |
| IN INT16 Operand, |
| OUT INT8 *Result |
| ); |
| |
| /** |
| INT16 -> CHAR8 conversion |
| |
| Converts the value specified by Operand to a value specified by Result type |
| and stores the converted value into the caller allocated output buffer |
| specified by Result. The caller must pass in a Result buffer that is at |
| least as large as the Result type. |
| |
| If Result is NULL, RETURN_INVALID_PARAMETER is returned. |
| |
| If the conversion results in an overflow or an underflow condition, then |
| Result is set to CHAR8_ERROR and RETURN_BUFFER_TOO_SMALL is returned. |
| |
| @param[in] Operand Operand to be converted to new type |
| @param[out] Result Pointer to the result of conversion |
| |
| @retval RETURN_SUCCESS Successful conversion |
| @retval RETURN_BUFFER_TOO_SMALL Overflow |
| @retval RETURN_INVALID_PARAMETER Result is NULL |
| **/ |
| RETURN_STATUS |
| EFIAPI |
| SafeInt16ToChar8 ( |
| IN INT16 Operand, |
| OUT CHAR8 *Result |
| ); |
| |
| /** |
| INT16 -> UINT8 conversion |
| |
| Converts the value specified by Operand to a value specified by Result type |
| and stores the converted value into the caller allocated output buffer |
| specified by Result. The caller must pass in a Result buffer that is at |
| least as large as the Result type. |
| |
| If Result is NULL, RETURN_INVALID_PARAMETER is returned. |
| |
| If the conversion results in an overflow or an underflow condition, then |
| Result is set to UINT8_ERROR and RETURN_BUFFER_TOO_SMALL is returned. |
| |
| @param[in] Operand Operand to be converted to new type |
| @param[out] Result Pointer to the result of conversion |
| |
| @retval RETURN_SUCCESS Successful conversion |
| @retval RETURN_BUFFER_TOO_SMALL Overflow |
| @retval RETURN_INVALID_PARAMETER Result is NULL |
| **/ |
| RETURN_STATUS |
| EFIAPI |
| SafeInt16ToUint8 ( |
| IN INT16 Operand, |
| OUT UINT8 *Result |
| ); |
| |
| /** |
| INT16 -> UINT16 conversion |
| |
| Converts the value specified by Operand to a value specified by Result type |
| and stores the converted value into the caller allocated output buffer |
| specified by Result. The caller must pass in a Result buffer that is at |
| least as large as the Result type. |
| |
| If Result is NULL, RETURN_INVALID_PARAMETER is returned. |
| |
| If the conversion results in an overflow or an underflow condition, then |
| Result is set to UINT16_ERROR and RETURN_BUFFER_TOO_SMALL is returned. |
| |
| @param[in] Operand Operand to be converted to new type |
| @param[out] Result Pointer to the result of conversion |
| |
| @retval RETURN_SUCCESS Successful conversion |
| @retval RETURN_BUFFER_TOO_SMALL Overflow |
| @retval RETURN_INVALID_PARAMETER Result is NULL |
| **/ |
| RETURN_STATUS |
| EFIAPI |
| SafeInt16ToUint16 ( |
| IN INT16 Operand, |
| OUT UINT16 *Result |
| ); |
| |
| /** |
| INT16 -> UINT32 conversion |
| |
| Converts the value specified by Operand to a value specified by Result type |
| and stores the converted value into the caller allocated output buffer |
| specified by Result. The caller must pass in a Result buffer that is at |
| least as large as the Result type. |
| |
| If Result is NULL, RETURN_INVALID_PARAMETER is returned. |
| |
| If the conversion results in an overflow or an underflow condition, then |
| Result is set to UINT32_ERROR and RETURN_BUFFER_TOO_SMALL is returned. |
| |
| @param[in] Operand Operand to be converted to new type |
| @param[out] Result Pointer to the result of conversion |
| |
| @retval RETURN_SUCCESS Successful conversion |
| @retval RETURN_BUFFER_TOO_SMALL Overflow |
| @retval RETURN_INVALID_PARAMETER Result is NULL |
| **/ |
| RETURN_STATUS |
| EFIAPI |
| SafeInt16ToUint32 ( |
| IN INT16 Operand, |
| OUT UINT32 *Result |
| ); |
| |
| /** |
| INT16 -> UINTN conversion |
| |
| Converts the value specified by Operand to a value specified by Result type |
| and stores the converted value into the caller allocated output buffer |
| specified by Result. The caller must pass in a Result buffer that is at |
| least as large as the Result type. |
| |
| If Result is NULL, RETURN_INVALID_PARAMETER is returned. |
| |
| If the conversion results in an overflow or an underflow condition, then |
| Result is set to UINTN_ERROR and RETURN_BUFFER_TOO_SMALL is returned. |
| |
| @param[in] Operand Operand to be converted to new type |
| @param[out] Result Pointer to the result of conversion |
| |
| @retval RETURN_SUCCESS Successful conversion |
| @retval RETURN_BUFFER_TOO_SMALL Overflow |
| @retval RETURN_INVALID_PARAMETER Result is NULL |
| **/ |
| RETURN_STATUS |
| EFIAPI |
| SafeInt16ToUintn ( |
| IN INT16 Operand, |
| OUT UINTN *Result |
| ); |
| |
| /** |
| INT16 -> UINT64 conversion |
| |
| Converts the value specified by Operand to a value specified by Result type |
| and stores the converted value into the caller allocated output buffer |
| specified by Result. The caller must pass in a Result buffer that is at |
| least as large as the Result type. |
| |
| If Result is NULL, RETURN_INVALID_PARAMETER is returned. |
| |
| If the conversion results in an overflow or an underflow condition, then |
| Result is set to UINT64_ERROR and RETURN_BUFFER_TOO_SMALL is returned. |
| |
| @param[in] Operand Operand to be converted to new type |
| @param[out] Result Pointer to the result of conversion |
| |
| @retval RETURN_SUCCESS Successful conversion |
| @retval RETURN_BUFFER_TOO_SMALL Overflow |
| @retval RETURN_INVALID_PARAMETER Result is NULL |
| **/ |
| RETURN_STATUS |
| EFIAPI |
| SafeInt16ToUint64 ( |
| IN INT16 Operand, |
| OUT UINT64 *Result |
| ); |
| |
| /** |
| UINT16 -> INT8 conversion |
| |
| Converts the value specified by Operand to a value specified by Result type |
| and stores the converted value into the caller allocated output buffer |
| specified by Result. The caller must pass in a Result buffer that is at |
| least as large as the Result type. |
| |
| If Result is NULL, RETURN_INVALID_PARAMETER is returned. |
| |
| If the conversion results in an overflow or an underflow condition, then |
| Result is set to INT8_ERROR and RETURN_BUFFER_TOO_SMALL is returned. |
| |
| @param[in] Operand Operand to be converted to new type |
| @param[out] Result Pointer to the result of conversion |
| |
| @retval RETURN_SUCCESS Successful conversion |
| @retval RETURN_BUFFER_TOO_SMALL Overflow |
| @retval RETURN_INVALID_PARAMETER Result is NULL |
| **/ |
| RETURN_STATUS |
| EFIAPI |
| SafeUint16ToInt8 ( |
| IN UINT16 Operand, |
| OUT INT8 *Result |
| ); |
| |
| /** |
| UINT16 -> CHAR8 conversion |
| |
| Converts the value specified by Operand to a value specified by Result type |
| and stores the converted value into the caller allocated output buffer |
| specified by Result. The caller must pass in a Result buffer that is at |
| least as large as the Result type. |
| |
| If Result is NULL, RETURN_INVALID_PARAMETER is returned. |
| |
| If the conversion results in an overflow or an underflow condition, then |
| Result is set to CHAR8_ERROR and RETURN_BUFFER_TOO_SMALL is returned. |
| |
| @param[in] Operand Operand to be converted to new type |
| @param[out] Result Pointer to the result of conversion |
| |
| @retval RETURN_SUCCESS Successful conversion |
| @retval RETURN_BUFFER_TOO_SMALL Overflow |
| @retval RETURN_INVALID_PARAMETER Result is NULL |
| **/ |
| RETURN_STATUS |
| EFIAPI |
| SafeUint16ToChar8 ( |
| IN UINT16 Operand, |
| OUT CHAR8 *Result |
| ); |
| |
| /** |
| UINT16 -> UINT8 conversion |
| |
| Converts the value specified by Operand to a value specified by Result type |
| and stores the converted value into the caller allocated output buffer |
| specified by Result. The caller must pass in a Result buffer that is at |
| least as large as the Result type. |
| |
| If Result is NULL, RETURN_INVALID_PARAMETER is returned. |
| |
| If the conversion results in an overflow or an underflow condition, then |
| Result is set to UINT8_ERROR and RETURN_BUFFER_TOO_SMALL is returned. |
| |
| @param[in] Operand Operand to be converted to new type |
| @param[out] Result Pointer to the result of conversion |
| |
| @retval RETURN_SUCCESS Successful conversion |
| @retval RETURN_BUFFER_TOO_SMALL Overflow |
| @retval RETURN_INVALID_PARAMETER Result is NULL |
| **/ |
| RETURN_STATUS |
| EFIAPI |
| SafeUint16ToUint8 ( |
| IN UINT16 Operand, |
| OUT UINT8 *Result |
| ); |
| |
| /** |
| UINT16 -> INT16 conversion |
| |
| Converts the value specified by Operand to a value specified by Result type |
| and stores the converted value into the caller allocated output buffer |
| specified by Result. The caller must pass in a Result buffer that is at |
| least as large as the Result type. |
| |
| If Result is NULL, RETURN_INVALID_PARAMETER is returned. |
| |
| If the conversion results in an overflow or an underflow condition, then |
| Result is set to INT16_ERROR and RETURN_BUFFER_TOO_SMALL is returned. |
| |
| @param[in] Operand Operand to be converted to new type |
| @param[out] Result Pointer to the result of conversion |
| |
| @retval RETURN_SUCCESS Successful conversion |
| @retval RETURN_BUFFER_TOO_SMALL Overflow |
| @retval RETURN_INVALID_PARAMETER Result is NULL |
| **/ |
| RETURN_STATUS |
| EFIAPI |
| SafeUint16ToInt16 ( |
| IN UINT16 Operand, |
| OUT INT16 *Result |
| ); |
| |
| /** |
| INT32 -> INT8 conversion |
| |
| Converts the value specified by Operand to a value specified by Result type |
| and stores the converted value into the caller allocated output buffer |
| specified by Result. The caller must pass in a Result buffer that is at |
| least as large as the Result type. |
| |
| If Result is NULL, RETURN_INVALID_PARAMETER is returned. |
| |
| If the conversion results in an overflow or an underflow condition, then |
| Result is set to INT8_ERROR and RETURN_BUFFER_TOO_SMALL is returned. |
| |
| @param[in] Operand Operand to be converted to new type |
| @param[out] Result Pointer to the result of conversion |
| |
| @retval RETURN_SUCCESS Successful conversion |
| @retval RETURN_BUFFER_TOO_SMALL Overflow |
| @retval RETURN_INVALID_PARAMETER Result is NULL |
| **/ |
| RETURN_STATUS |
| EFIAPI |
| SafeInt32ToInt8 ( |
| IN INT32 Operand, |
| OUT INT8 *Result |
| ); |
| |
| /** |
| INT32 -> CHAR8 conversion |
| |
| Converts the value specified by Operand to a value specified by Result type |
| and stores the converted value into the caller allocated output buffer |
| specified by Result. The caller must pass in a Result buffer that is at |
| least as large as the Result type. |
| |
| If Result is NULL, RETURN_INVALID_PARAMETER is returned. |
| |
| If the conversion results in an overflow or an underflow condition, then |
| Result is set to CHAR8_ERROR and RETURN_BUFFER_TOO_SMALL is returned. |
| |
| @param[in] Operand Operand to be converted to new type |
| @param[out] Result Pointer to the result of conversion |
| |
| @retval RETURN_SUCCESS Successful conversion |
| @retval RETURN_BUFFER_TOO_SMALL Overflow |
| @retval RETURN_INVALID_PARAMETER Result is NULL |
| **/ |
| RETURN_STATUS |
| EFIAPI |
| SafeInt32ToChar8 ( |
| IN INT32 Operand, |
| OUT CHAR8 *Result |
| ); |
| |
| /** |
| INT32 -> UINT8 conversion |
| |
| Converts the value specified by Operand to a value specified by Result type |
| and stores the converted value into the caller allocated output buffer |
| specified by Result. The caller must pass in a Result buffer that is at |
| least as large as the Result type. |
| |
| If Result is NULL, RETURN_INVALID_PARAMETER is returned. |
| |
| If the conversion results in an overflow or an underflow condition, then |
| Result is set to UINT8_ERROR and RETURN_BUFFER_TOO_SMALL is returned. |
| |
| @param[in] Operand Operand to be converted to new type |
| @param[out] Result Pointer to the result of conversion |
| |
| @retval RETURN_SUCCESS Successful conversion |
| @retval RETURN_BUFFER_TOO_SMALL Overflow |
| @retval RETURN_INVALID_PARAMETER Result is NULL |
| **/ |
| RETURN_STATUS |
| EFIAPI |
| SafeInt32ToUint8 ( |
| IN INT32 Operand, |
| OUT UINT8 *Result |
| ); |
| |
| /** |
| INT32 -> INT16 conversion |
| |
| Converts the value specified by Operand to a value specified by Result type |
| and stores the converted value into the caller allocated output buffer |
| specified by Result. The caller must pass in a Result buffer that is at |
| least as large as the Result type. |
| |
| If Result is NULL, RETURN_INVALID_PARAMETER is returned. |
| |
| If the conversion results in an overflow or an underflow condition, then |
| Result is set to INT16_ERROR and RETURN_BUFFER_TOO_SMALL is returned. |
| |
| @param[in] Operand Operand to be converted to new type |
| @param[out] Result Pointer to the result of conversion |
| |
| @retval RETURN_SUCCESS Successful conversion |
| @retval RETURN_BUFFER_TOO_SMALL Overflow |
| @retval RETURN_INVALID_PARAMETER Result is NULL |
| **/ |
| RETURN_STATUS |
| EFIAPI |
| SafeInt32ToInt16 ( |
| IN INT32 Operand, |
| OUT INT16 *Result |
| ); |
| |
| /** |
| INT32 -> UINT16 conversion |
| |
| Converts the value specified by Operand to a value specified by Result type |
| and stores the converted value into the caller allocated output buffer |
| specified by Result. The caller must pass in a Result buffer that is at |
| least as large as the Result type. |
| |
| If Result is NULL, RETURN_INVALID_PARAMETER is returned. |
| |
| If the conversion results in an overflow or an underflow condition, then |
| Result is set to UINT16_ERROR and RETURN_BUFFER_TOO_SMALL is returned. |
| |
| @param[in] Operand Operand to be converted to new type |
| @param[out] Result Pointer to the result of conversion |
| |
| @retval RETURN_SUCCESS Successful conversion |
| @retval RETURN_BUFFER_TOO_SMALL Overflow |
| @retval RETURN_INVALID_PARAMETER Result is NULL |
| **/ |
| RETURN_STATUS |
| EFIAPI |
| SafeInt32ToUint16 ( |
| IN INT32 Operand, |
| OUT UINT16 *Result |
| ); |
| |
| /** |
| INT32 -> UINT32 conversion |
| |
| Converts the value specified by Operand to a value specified by Result type |
| and stores the converted value into the caller allocated output buffer |
| specified by Result. The caller must pass in a Result buffer that is at |
| least as large as the Result type. |
| |
| If Result is NULL, RETURN_INVALID_PARAMETER is returned. |
| |
| If the conversion results in an overflow or an underflow condition, then |
| Result is set to UINT32_ERROR and RETURN_BUFFER_TOO_SMALL is returned. |
| |
| @param[in] Operand Operand to be converted to new type |
| @param[out] Result Pointer to the result of conversion |
| |
| @retval RETURN_SUCCESS Successful conversion |
| @retval RETURN_BUFFER_TOO_SMALL Overflow |
| @retval RETURN_INVALID_PARAMETER Result is NULL |
| **/ |
| RETURN_STATUS |
| EFIAPI |
| SafeInt32ToUint32 ( |
| IN INT32 Operand, |
| OUT UINT32 *Result |
| ); |
| |
| /** |
| INT32 -> UINTN conversion |
| |
| Converts the value specified by Operand to a value specified by Result type |
| and stores the converted value into the caller allocated output buffer |
| specified by Result. The caller must pass in a Result buffer that is at |
| least as large as the Result type. |
| |
| If Result is NULL, RETURN_INVALID_PARAMETER is returned. |
| |
| If the conversion results in an overflow or an underflow condition, then |
| Result is set to UINTN_ERROR and RETURN_BUFFER_TOO_SMALL is returned. |
| |
| @param[in] Operand Operand to be converted to new type |
| @param[out] Result Pointer to the result of conversion |
| |
| @retval RETURN_SUCCESS Successful conversion |
| @retval RETURN_BUFFER_TOO_SMALL Overflow |
| @retval RETURN_INVALID_PARAMETER Result is NULL |
| **/ |
| RETURN_STATUS |
| EFIAPI |
| SafeInt32ToUintn ( |
| IN INT32 Operand, |
| OUT UINTN *Result |
| ); |
| |
| /** |
| INT32 -> UINT64 conversion |
| |
| Converts the value specified by Operand to a value specified by Result type |
| and stores the converted value into the caller allocated output buffer |
| specified by Result. The caller must pass in a Result buffer that is at |
| least as large as the Result type. |
| |
| If Result is NULL, RETURN_INVALID_PARAMETER is returned. |
| |
| If the conversion results in an overflow or an underflow condition, then |
| Result is set to UINT64_ERROR and RETURN_BUFFER_TOO_SMALL is returned. |
| |
| @param[in] Operand Operand to be converted to new type |
| @param[out] Result Pointer to the result of conversion |
| |
| @retval RETURN_SUCCESS Successful conversion |
| @retval RETURN_BUFFER_TOO_SMALL Overflow |
| @retval RETURN_INVALID_PARAMETER Result is NULL |
| **/ |
| RETURN_STATUS |
| EFIAPI |
| SafeInt32ToUint64 ( |
| IN INT32 Operand, |
| OUT UINT64 *Result |
| ); |
| |
| /** |
| UINT32 -> INT8 conversion |
| |
| Converts the value specified by Operand to a value specified by Result type |
| and stores the converted value into the caller allocated output buffer |
| specified by Result. The caller must pass in a Result buffer that is at |
| least as large as the Result type. |
| |
| If Result is NULL, RETURN_INVALID_PARAMETER is returned. |
| |
| If the conversion results in an overflow or an underflow condition, then |
| Result is set to INT8_ERROR and RETURN_BUFFER_TOO_SMALL is returned. |
| |
| @param[in] Operand Operand to be converted to new type |
| @param[out] Result Pointer to the result of conversion |
| |
| @retval RETURN_SUCCESS Successful conversion |
| @retval RETURN_BUFFER_TOO_SMALL Overflow |
| @retval RETURN_INVALID_PARAMETER Result is NULL |
| **/ |
| RETURN_STATUS |
| EFIAPI |
| SafeUint32ToInt8 ( |
| IN UINT32 Operand, |
| OUT INT8 *Result |
| ); |
| |
| /** |
| UINT32 -> CHAR8 conversion |
| |
| Converts the value specified by Operand to a value specified by Result type |
| and stores the converted value into the caller allocated output buffer |
| specified by Result. The caller must pass in a Result buffer that is at |
| least as large as the Result type. |
| |
| If Result is NULL, RETURN_INVALID_PARAMETER is returned. |
| |
| If the conversion results in an overflow or an underflow condition, then |
| Result is set to CHAR8_ERROR and RETURN_BUFFER_TOO_SMALL is returned. |
| |
| @param[in] Operand Operand to be converted to new type |
| @param[out] Result Pointer to the result of conversion |
| |
| @retval RETURN_SUCCESS Successful conversion |
| @retval RETURN_BUFFER_TOO_SMALL Overflow |
| @retval RETURN_INVALID_PARAMETER Result is NULL |
| **/ |
| RETURN_STATUS |
| EFIAPI |
| SafeUint32ToChar8 ( |
| IN UINT32 Operand, |
| OUT CHAR8 *Result |
| ); |
| |
| /** |
| UINT32 -> UINT8 conversion |
| |
| Converts the value specified by Operand to a value specified by Result type |
| and stores the converted value into the caller allocated output buffer |
| specified by Result. The caller must pass in a Result buffer that is at |
| least as large as the Result type. |
| |
| If Result is NULL, RETURN_INVALID_PARAMETER is returned. |
| |
| If the conversion results in an overflow or an underflow condition, then |
| Result is set to UINT8_ERROR and RETURN_BUFFER_TOO_SMALL is returned. |
| |
| @param[in] Operand Operand to be converted to new type |
| @param[out] Result Pointer to the result of conversion |
| |
| @retval RETURN_SUCCESS Successful conversion |
| @retval RETURN_BUFFER_TOO_SMALL Overflow |
| @retval RETURN_INVALID_PARAMETER Result is NULL |
| **/ |
| RETURN_STATUS |
| EFIAPI |
| SafeUint32ToUint8 ( |
| IN UINT32 Operand, |
| OUT UINT8 *Result |
| ); |
| |
| /** |
| UINT32 -> INT16 conversion |
| |
| Converts the value specified by Operand to a value specified by Result type |
| and stores the converted value into the caller allocated output buffer |
| specified by Result. The caller must pass in a Result buffer that is at |
| least as large as the Result type. |
| |
| If Result is NULL, RETURN_INVALID_PARAMETER is returned. |
| |
| If the conversion results in an overflow or an underflow condition, then |
| Result is set to INT16_ERROR and RETURN_BUFFER_TOO_SMALL is returned. |
| |
| @param[in] Operand Operand to be converted to new type |
| @param[out] Result Pointer to the result of conversion |
| |
| @retval RETURN_SUCCESS Successful conversion |
| @retval RETURN_BUFFER_TOO_SMALL Overflow |
| @retval RETURN_INVALID_PARAMETER Result is NULL |
| **/ |
| RETURN_STATUS |
| EFIAPI |
| SafeUint32ToInt16 ( |
| IN UINT32 Operand, |
| OUT INT16 *Result |
| ); |
| |
| /** |
| UINT32 -> UINT16 conversion |
| |
| Converts the value specified by Operand to a value specified by Result type |
| and stores the converted value into the caller allocated output buffer |
| specified by Result. The caller must pass in a Result buffer that is at |
| least as large as the Result type. |
| |
| If Result is NULL, RETURN_INVALID_PARAMETER is returned. |
| |
| If the conversion results in an overflow or an underflow condition, then |
| Result is set to UINT16_ERROR and RETURN_BUFFER_TOO_SMALL is returned. |
| |
| @param[in] Operand Operand to be converted to new type |
| @param[out] Result Pointer to the result of conversion |
| |
| @retval RETURN_SUCCESS Successful conversion |
| @retval RETURN_BUFFER_TOO_SMALL Overflow |
| @retval RETURN_INVALID_PARAMETER Result is NULL |
| **/ |
| RETURN_STATUS |
| EFIAPI |
| SafeUint32ToUint16 ( |
| IN UINT32 Operand, |
| OUT UINT16 *Result |
| ); |
| |
| /** |
| UINT32 -> INT32 conversion |
| |
| Converts the value specified by Operand to a value specified by Result type |
| and stores the converted value into the caller allocated output buffer |
| specified by Result. The caller must pass in a Result buffer that is at |
| least as large as the Result type. |
| |
| If Result is NULL, RETURN_INVALID_PARAMETER is returned. |
| |
| If the conversion results in an overflow or an underflow condition, then |
| Result is set to INT32_ERROR and RETURN_BUFFER_TOO_SMALL is returned. |
| |
| @param[in] Operand Operand to be converted to new type |
| @param[out] Result Pointer to the result of conversion |
| |
| @retval RETURN_SUCCESS Successful conversion |
| @retval RETURN_BUFFER_TOO_SMALL Overflow |
| @retval RETURN_INVALID_PARAMETER Result is NULL |
| **/ |
| RETURN_STATUS |
| EFIAPI |
| SafeUint32ToInt32 ( |
| IN UINT32 Operand, |
| OUT INT32 *Result |
| ); |
| |
| /** |
| UINT32 -> INTN conversion |
| |
| Converts the value specified by Operand to a value specified by Result type |
| and stores the converted value into the caller allocated output buffer |
| specified by Result. The caller must pass in a Result buffer that is at |
| least as large as the Result type. |
| |
| If Result is NULL, RETURN_INVALID_PARAMETER is returned. |
| |
| If the conversion results in an overflow or an underflow condition, then |
| Result is set to INTN_ERROR and RETURN_BUFFER_TOO_SMALL is returned. |
| |
| @param[in] Operand Operand to be converted to new type |
| @param[out] Result Pointer to the result of conversion |
| |
| @retval RETURN_SUCCESS Successful conversion |
| @retval RETURN_BUFFER_TOO_SMALL Overflow |
| @retval RETURN_INVALID_PARAMETER Result is NULL |
| **/ |
| RETURN_STATUS |
| EFIAPI |
| SafeUint32ToIntn ( |
| IN UINT32 Operand, |
| OUT INTN *Result |
| ); |
| |
| /** |
| INTN -> INT8 conversion |
| |
| Converts the value specified by Operand to a value specified by Result type |
| and stores the converted value into the caller allocated output buffer |
| specified by Result. The caller must pass in a Result buffer that is at |
| least as large as the Result type. |
| |
| If Result is NULL, RETURN_INVALID_PARAMETER is returned. |
| |
| If the conversion results in an overflow or an underflow condition, then |
| Result is set to INT8_ERROR and RETURN_BUFFER_TOO_SMALL is returned. |
| |
| @param[in] Operand Operand to be converted to new type |
| @param[out] Result Pointer to the result of conversion |
| |
| @retval RETURN_SUCCESS Successful conversion |
| @retval RETURN_BUFFER_TOO_SMALL Overflow |
| @retval RETURN_INVALID_PARAMETER Result is NULL |
| **/ |
| RETURN_STATUS |
| EFIAPI |
| SafeIntnToInt8 ( |
| IN INTN Operand, |
| OUT INT8 *Result |
| ); |
| |
| /** |
| INTN -> CHAR8 conversion |
| |
| Converts the value specified by Operand to a value specified by Result type |
| and stores the converted value into the caller allocated output buffer |
| specified by Result. The caller must pass in a Result buffer that is at |
| least as large as the Result type. |
| |
| If Result is NULL, RETURN_INVALID_PARAMETER is returned. |
| |
| If the conversion results in an overflow or an underflow condition, then |
| Result is set to CHAR8_ERROR and RETURN_BUFFER_TOO_SMALL is returned. |
| |
| @param[in] Operand Operand to be converted to new type |
| @param[out] Result Pointer to the result of conversion |
| |
| @retval RETURN_SUCCESS Successful conversion |
| @retval RETURN_BUFFER_TOO_SMALL Overflow |
| @retval RETURN_INVALID_PARAMETER Result is NULL |
| **/ |
| RETURN_STATUS |
| EFIAPI |
| SafeIntnToChar8 ( |
| IN INTN Operand, |
| OUT CHAR8 *Result |
| ); |
| |
| /** |
| INTN -> UINT8 conversion |
| |
| Converts the value specified by Operand to a value specified by Result type |
| and stores the converted value into the caller allocated output buffer |
| specified by Result. The caller must pass in a Result buffer that is at |
| least as large as the Result type. |
| |
| If Result is NULL, RETURN_INVALID_PARAMETER is returned. |
| |
| If the conversion results in an overflow or an underflow condition, then |
| Result is set to UINT8_ERROR and RETURN_BUFFER_TOO_SMALL is returned. |
| |
| @param[in] Operand Operand to be converted to new type |
| @param[out] Result Pointer to the result of conversion |
| |
| @retval RETURN_SUCCESS Successful conversion |
| @retval RETURN_BUFFER_TOO_SMALL Overflow |
| @retval RETURN_INVALID_PARAMETER Result is NULL |
| **/ |
| RETURN_STATUS |
| EFIAPI |
| SafeIntnToUint8 ( |
| IN INTN Operand, |
| OUT UINT8 *Result |
| ); |
| |
| /** |
| INTN -> INT16 conversion |
| |
| Converts the value specified by Operand to a value specified by Result type |
| and stores the converted value into the caller allocated output buffer |
| specified by Result. The caller must pass in a Result buffer that is at |
| least as large as the Result type. |
| |
| If Result is NULL, RETURN_INVALID_PARAMETER is returned. |
| |
| If the conversion results in an overflow or an underflow condition, then |
| Result is set to INT16_ERROR and RETURN_BUFFER_TOO_SMALL is returned. |
| |
| @param[in] Operand Operand to be converted to new type |
| @param[out] Result Pointer to the result of conversion |
| |
| @retval RETURN_SUCCESS Successful conversion |
| @retval RETURN_BUFFER_TOO_SMALL Overflow |
| @retval RETURN_INVALID_PARAMETER Result is NULL |
| **/ |
| RETURN_STATUS |
| EFIAPI |
| SafeIntnToInt16 ( |
| IN INTN Operand, |
| OUT INT16 *Result |
| ); |
| |
| /** |
| INTN -> UINT16 conversion |
| |
| Converts the value specified by Operand to a value specified by Result type |
| and stores the converted value into the caller allocated output buffer |
| specified by Result. The caller must pass in a Result buffer that is at |
| least as large as the Result type. |
| |
| If Result is NULL, RETURN_INVALID_PARAMETER is returned. |
| |
| If the conversion results in an overflow or an underflow condition, then |
| Result is set to UINT16_ERROR and RETURN_BUFFER_TOO_SMALL is returned. |
| |
| @param[in] Operand Operand to be converted to new type |
| @param[out] Result Pointer to the result of conversion |
| |
| @retval RETURN_SUCCESS Successful conversion |
| @retval RETURN_BUFFER_TOO_SMALL Overflow |
| @retval RETURN_INVALID_PARAMETER Result is NULL |
| **/ |
| RETURN_STATUS |
| EFIAPI |
| SafeIntnToUint16 ( |
| IN INTN Operand, |
| OUT UINT16 *Result |
| ); |
| |
| /** |
| INTN -> INT32 conversion |
| |
| Converts the value specified by Operand to a value specified by Result type |
| and stores the converted value into the caller allocated output buffer |
| specified by Result. The caller must pass in a Result buffer that is at |
| least as large as the Result type. |
| |
| If Result is NULL, RETURN_INVALID_PARAMETER is returned. |
| |
| If the conversion results in an overflow or an underflow condition, then |
| Result is set to INT32_ERROR and RETURN_BUFFER_TOO_SMALL is returned. |
| |
| @param[in] Operand Operand to be converted to new type |
| @param[out] Result Pointer to the result of conversion |
| |
| @retval RETURN_SUCCESS Successful conversion |
| @retval RETURN_BUFFER_TOO_SMALL Overflow |
| @retval RETURN_INVALID_PARAMETER Result is NULL |
| **/ |
| RETURN_STATUS |
| EFIAPI |
| SafeIntnToInt32 ( |
| IN INTN Operand, |
| OUT INT32 *Result |
| ); |
| |
| /** |
| INTN -> UINT32 conversion |
| |
| Converts the value specified by Operand to a value specified by Result type |
| and stores the converted value into the caller allocated output buffer |
| specified by Result. The caller must pass in a Result buffer that is at |
| least as large as the Result type. |
| |
| If Result is NULL, RETURN_INVALID_PARAMETER is returned. |
| |
| If the conversion results in an overflow or an underflow condition, then |
| Result is set to UINT32_ERROR and RETURN_BUFFER_TOO_SMALL is returned. |
| |
| @param[in] Operand Operand to be converted to new type |
| @param[out] Result Pointer to the result of conversion |
| |
| @retval RETURN_SUCCESS Successful conversion |
| @retval RETURN_BUFFER_TOO_SMALL Overflow |
| @retval RETURN_INVALID_PARAMETER Result is NULL |
| **/ |
| RETURN_STATUS |
| EFIAPI |
| SafeIntnToUint32 ( |
| IN INTN Operand, |
| OUT UINT32 *Result |
| ); |
| |
| /** |
| INTN -> UINTN conversion |
| |
| Converts the value specified by Operand to a value specified by Result type |
| and stores the converted value into the caller allocated output buffer |
| specified by Result. The caller must pass in a Result buffer that is at |
| least as large as the Result type. |
| |
| If Result is NULL, RETURN_INVALID_PARAMETER is returned. |
| |
| If the conversion results in an overflow or an underflow condition, then |
| Result is set to UINTN_ERROR and RETURN_BUFFER_TOO_SMALL is returned. |
| |
| @param[in] Operand Operand to be converted to new type |
| @param[out] Result Pointer to the result of conversion |
| |
| @retval RETURN_SUCCESS Successful conversion |
| @retval RETURN_BUFFER_TOO_SMALL Overflow |
| @retval RETURN_INVALID_PARAMETER Result is NULL |
| **/ |
| RETURN_STATUS |
| EFIAPI |
| SafeIntnToUintn ( |
| IN INTN Operand, |
| OUT UINTN *Result |
| ); |
| |
| /** |
| INTN -> UINT64 conversion |
| |
| Converts the value specified by Operand to a value specified by Result type |
| and stores the converted value into the caller allocated output buffer |
| specified by Result. The caller must pass in a Result buffer that is at |
| least as large as the Result type. |
| |
| If Result is NULL, RETURN_INVALID_PARAMETER is returned. |
| |
| If the conversion results in an overflow or an underflow condition, then |
| Result is set to UINT64_ERROR and RETURN_BUFFER_TOO_SMALL is returned. |
| |
| @param[in] Operand Operand to be converted to new type |
| @param[out] Result Pointer to the result of conversion |
| |
| @retval RETURN_SUCCESS Successful conversion |
| @retval RETURN_BUFFER_TOO_SMALL Overflow |
| @retval RETURN_INVALID_PARAMETER Result is NULL |
| **/ |
| RETURN_STATUS |
| EFIAPI |
| SafeIntnToUint64 ( |
| IN INTN Operand, |
| OUT UINT64 *Result |
| ); |
| |
| /** |
| UINTN -> INT8 conversion |
| |
| Converts the value specified by Operand to a value specified by Result type |
| and stores the converted value into the caller allocated output buffer |
| specified by Result. The caller must pass in a Result buffer that is at |
| least as large as the Result type. |
| |
| If Result is NULL, RETURN_INVALID_PARAMETER is returned. |
| |
| If the conversion results in an overflow or an underflow condition, then |
| Result is set to INT8_ERROR and RETURN_BUFFER_TOO_SMALL is returned. |
| |
| @param[in] Operand Operand to be converted to new type |
| @param[out] Result Pointer to the result of conversion |
| |
| @retval RETURN_SUCCESS Successful conversion |
| @retval RETURN_BUFFER_TOO_SMALL Overflow |
| @retval RETURN_INVALID_PARAMETER Result is NULL |
| **/ |
| RETURN_STATUS |
| EFIAPI |
| SafeUintnToInt8 ( |
| IN UINTN Operand, |
| OUT INT8 *Result |
| ); |
| |
| /** |
| UINTN -> CHAR8 conversion |
| |
| Converts the value specified by Operand to a value specified by Result type |
| and stores the converted value into the caller allocated output buffer |
| specified by Result. The caller must pass in a Result buffer that is at |
| least as large as the Result type. |
| |
| If Result is NULL, RETURN_INVALID_PARAMETER is returned. |
| |
| If the conversion results in an overflow or an underflow condition, then |
| Result is set to CHAR8_ERROR and RETURN_BUFFER_TOO_SMALL is returned. |
| |
| @param[in] Operand Operand to be converted to new type |
| @param[out] Result Pointer to the result of conversion |
| |
| @retval RETURN_SUCCESS Successful conversion |
| @retval RETURN_BUFFER_TOO_SMALL Overflow |
| @retval RETURN_INVALID_PARAMETER Result is NULL |
| **/ |
| RETURN_STATUS |
| EFIAPI |
| SafeUintnToChar8 ( |
| IN UINTN Operand, |
| OUT CHAR8 *Result |
| ); |
| |
| /** |
| UINTN -> UINT8 conversion |
| |
| Converts the value specified by Operand to a value specified by Result type |
| and stores the converted value into the caller allocated output buffer |
| specified by Result. The caller must pass in a Result buffer that is at |
| least as large as the Result type. |
| |
| If Result is NULL, RETURN_INVALID_PARAMETER is returned. |
| |
| If the conversion results in an overflow or an underflow condition, then |
| Result is set to UINT8_ERROR and RETURN_BUFFER_TOO_SMALL is returned. |
| |
| @param[in] Operand Operand to be converted to new type |
| @param[out] Result Pointer to the result of conversion |
| |
| @retval RETURN_SUCCESS Successful conversion |
| @retval RETURN_BUFFER_TOO_SMALL Overflow |
| @retval RETURN_INVALID_PARAMETER Result is NULL |
| **/ |
| RETURN_STATUS |
| EFIAPI |
| SafeUintnToUint8 ( |
| IN UINTN Operand, |
| OUT UINT8 *Result |
| ); |
| |
| /** |
| UINTN -> INT16 conversion |
| |
| Converts the value specified by Operand to a value specified by Result type |
| and stores the converted value into the caller allocated output buffer |
| specified by Result. The caller must pass in a Result buffer that is at |
| least as large as the Result type. |
| |
| If Result is NULL, RETURN_INVALID_PARAMETER is returned. |
| |
| If the conversion results in an overflow or an underflow condition, then |
| Result is set to INT16_ERROR and RETURN_BUFFER_TOO_SMALL is returned. |
| |
| @param[in] Operand Operand to be converted to new type |
| @param[out] Result Pointer to the result of conversion |
| |
| @retval RETURN_SUCCESS Successful conversion |
| @retval RETURN_BUFFER_TOO_SMALL Overflow |
| @retval RETURN_INVALID_PARAMETER Result is NULL |
| **/ |
| RETURN_STATUS |
| EFIAPI |
| SafeUintnToInt16 ( |
| IN UINTN Operand, |
| OUT INT16 *Result |
| ); |
| |
| /** |
| UINTN -> UINT16 conversion |
| |
| Converts the value specified by Operand to a value specified by Result type |
| and stores the converted value into the caller allocated output buffer |
| specified by Result. The caller must pass in a Result buffer that is at |
| least as large as the Result type. |
| |
| If Result is NULL, RETURN_INVALID_PARAMETER is returned. |
| |
| If the conversion results in an overflow or an underflow condition, then |
| Result is set to UINT16_ERROR and RETURN_BUFFER_TOO_SMALL is returned. |
| |
| @param[in] Operand Operand to be converted to new type |
| @param[out] Result Pointer to the result of conversion |
| |
| @retval RETURN_SUCCESS Successful conversion |
| @retval RETURN_BUFFER_TOO_SMALL Overflow |
| @retval RETURN_INVALID_PARAMETER Result is NULL |
| **/ |
| RETURN_STATUS |
| EFIAPI |
| SafeUintnToUint16 ( |
| IN UINTN Operand, |
| OUT UINT16 *Result |
| ); |
| |
| /** |
| UINTN -> INT32 conversion |
| |
| Converts the value specified by Operand to a value specified by Result type |
| and stores the converted value into the caller allocated output buffer |
| specified by Result. The caller must pass in a Result buffer that is at |
| least as large as the Result type. |
| |
| If Result is NULL, RETURN_INVALID_PARAMETER is returned. |
| |
| If the conversion results in an overflow or an underflow condition, then |
| Result is set to INT32_ERROR and RETURN_BUFFER_TOO_SMALL is returned. |
| |
| @param[in] Operand Operand to be converted to new type |
| @param[out] Result Pointer to the result of conversion |
| |
| @retval RETURN_SUCCESS Successful conversion |
| @retval RETURN_BUFFER_TOO_SMALL Overflow |
| @retval RETURN_INVALID_PARAMETER Result is NULL |
| **/ |
| RETURN_STATUS |
| EFIAPI |
| SafeUintnToInt32 ( |
| IN UINTN Operand, |
| OUT INT32 *Result |
| ); |
| |
| /** |
| UINTN -> UINT32 conversion |
| |
| Converts the value specified by Operand to a value specified by Result type |
| and stores the converted value into the caller allocated output buffer |
| specified by Result. The caller must pass in a Result buffer that is at |
| least as large as the Result type. |
| |
| If Result is NULL, RETURN_INVALID_PARAMETER is returned. |
| |
| If the conversion results in an overflow or an underflow condition, then |
| Result is set to UINT32_ERROR and RETURN_BUFFER_TOO_SMALL is returned. |
| |
| @param[in] Operand Operand to be converted to new type |
| @param[out] Result Pointer to the result of conversion |
| |
| @retval RETURN_SUCCESS Successful conversion |
| @retval RETURN_BUFFER_TOO_SMALL Overflow |
| @retval RETURN_INVALID_PARAMETER Result is NULL |
| **/ |
| RETURN_STATUS |
| EFIAPI |
| SafeUintnToUint32 ( |
| IN UINTN Operand, |
| OUT UINT32 *Result |
| ); |
| |
| /** |
| UINTN -> INTN conversion |
| |
| Converts the value specified by Operand to a value specified by Result type |
| and stores the converted value into the caller allocated output buffer |
| specified by Result. The caller must pass in a Result buffer that is at |
| least as large as the Result type. |
| |
| If Result is NULL, RETURN_INVALID_PARAMETER is returned. |
| |
| If the conversion results in an overflow or an underflow condition, then |
| Result is set to INTN_ERROR and RETURN_BUFFER_TOO_SMALL is returned. |
| |
| @param[in] Operand Operand to be converted to new type |
| @param[out] Result Pointer to the result of conversion |
| |
| @retval RETURN_SUCCESS Successful conversion |
| @retval RETURN_BUFFER_TOO_SMALL Overflow |
| @retval RETURN_INVALID_PARAMETER Result is NULL |
| **/ |
| RETURN_STATUS |
| EFIAPI |
| SafeUintnToIntn ( |
| IN UINTN Operand, |
| OUT INTN *Result |
| ); |
| |
| /** |
| UINTN -> INT64 conversion |
| |
| Converts the value specified by Operand to a value specified by Result type |
| and stores the converted value into the caller allocated output buffer |
| specified by Result. The caller must pass in a Result buffer that is at |
| least as large as the Result type. |
| |
| If Result is NULL, RETURN_INVALID_PARAMETER is returned. |
| |
| If the conversion results in an overflow or an underflow condition, then |
| Result is set to INT64_ERROR and RETURN_BUFFER_TOO_SMALL is returned. |
| |
| @param[in] Operand Operand to be converted to new type |
| @param[out] Result Pointer to the result of conversion |
| |
| @retval RETURN_SUCCESS Successful conversion |
| @retval RETURN_BUFFER_TOO_SMALL Overflow |
| @retval RETURN_INVALID_PARAMETER Result is NULL |
| **/ |
| RETURN_STATUS |
| EFIAPI |
| SafeUintnToInt64 ( |
| IN UINTN Operand, |
| OUT INT64 *Result |
| ); |
| |
| /** |
| INT64 -> INT8 conversion |
| |
| Converts the value specified by Operand to a value specified by Result type |
| and stores the converted value into the caller allocated output buffer |
| specified by Result. The caller must pass in a Result buffer that is at |
| least as large as the Result type. |
| |
| If Result is NULL, RETURN_INVALID_PARAMETER is returned. |
| |
| If the conversion results in an overflow or an underflow condition, then |
| Result is set to INT8_ERROR and RETURN_BUFFER_TOO_SMALL is returned. |
| |
| @param[in] Operand Operand to be converted to new type |
| @param[out] Result Pointer to the result of conversion |
| |
| @retval RETURN_SUCCESS Successful conversion |
| @retval RETURN_BUFFER_TOO_SMALL Overflow |
| @retval RETURN_INVALID_PARAMETER Result is NULL |
| **/ |
| RETURN_STATUS |
| EFIAPI |
| SafeInt64ToInt8 ( |
| IN INT64 Operand, |
| OUT INT8 *Result |
| ); |
| |
| /** |
| INT64 -> CHAR8 conversion |
| |
| Converts the value specified by Operand to a value specified by Result type |
| and stores the converted value into the caller allocated output buffer |
| specified by Result. The caller must pass in a Result buffer that is at |
| least as large as the Result type. |
| |
| If Result is NULL, RETURN_INVALID_PARAMETER is returned. |
| |
| If the conversion results in an overflow or an underflow condition, then |
| Result is set to CHAR8_ERROR and RETURN_BUFFER_TOO_SMALL is returned. |
| |
| @param[in] Operand Operand to be converted to new type |
| @param[out] Result Pointer to the result of conversion |
| |
| @retval RETURN_SUCCESS Successful conversion |
| @retval RETURN_BUFFER_TOO_SMALL Overflow |
| @retval RETURN_INVALID_PARAMETER Result is NULL |
| **/ |
| RETURN_STATUS |
| EFIAPI |
| SafeInt64ToChar8 ( |
| IN INT64 Operand, |
| OUT CHAR8 *Result |
| ); |
| |
| /** |
| INT64 -> UINT8 conversion |
| |
| Converts the value specified by Operand to a value specified by Result type |
| and stores the converted value into the caller allocated output buffer |
| specified by Result. The caller must pass in a Result buffer that is at |
| least as large as the Result type. |
| |
| If Result is NULL, RETURN_INVALID_PARAMETER is returned. |
| |
| If the conversion results in an overflow or an underflow condition, then |
| Result is set to UINT8_ERROR and RETURN_BUFFER_TOO_SMALL is returned. |
| |
| @param[in] Operand Operand to be converted to new type |
| @param[out] Result Pointer to the result of conversion |
| |
| @retval RETURN_SUCCESS Successful conversion |
| @retval RETURN_BUFFER_TOO_SMALL Overflow |
| @retval RETURN_INVALID_PARAMETER Result is NULL |
| **/ |
| RETURN_STATUS |
| EFIAPI |
| SafeInt64ToUint8 ( |
| IN INT64 Operand, |
| OUT UINT8 *Result |
| ); |
| |
| /** |
| INT64 -> INT16 conversion |
| |
| Converts the value specified by Operand to a value specified by Result type |
| and stores the converted value into the caller allocated output buffer |
| specified by Result. The caller must pass in a Result buffer that is at |
| least as large as the Result type. |
| |
| If Result is NULL, RETURN_INVALID_PARAMETER is returned. |
| |
| If the conversion results in an overflow or an underflow condition, then |
| Result is set to INT16_ERROR and RETURN_BUFFER_TOO_SMALL is returned. |
| |
| @param[in] Operand Operand to be converted to new type |
| @param[out] Result Pointer to the result of conversion |
| |
| @retval RETURN_SUCCESS Successful conversion |
| @retval RETURN_BUFFER_TOO_SMALL Overflow |
| @retval RETURN_INVALID_PARAMETER Result is NULL |
| **/ |
| RETURN_STATUS |
| EFIAPI |
| SafeInt64ToInt16 ( |
| IN INT64 Operand, |
| OUT INT16 *Result |
| ); |
| |
| /** |
| INT64 -> UINT16 conversion |
| |
| Converts the value specified by Operand to a value specified by Result type |
| and stores the converted value into the caller allocated output buffer |
| specified by Result. The caller must pass in a Result buffer that is at |
| least as large as the Result type. |
| |
| If Result is NULL, RETURN_INVALID_PARAMETER is returned. |
| |
| If the conversion results in an overflow or an underflow condition, then |
| Result is set to UINT16_ERROR and RETURN_BUFFER_TOO_SMALL is returned. |
| |
| @param[in] Operand Operand to be converted to new type |
| @param[out] Result Pointer to the result of conversion |
| |
| @retval RETURN_SUCCESS Successful conversion |
| @retval RETURN_BUFFER_TOO_SMALL Overflow |
| @retval RETURN_INVALID_PARAMETER Result is NULL |
| **/ |
| RETURN_STATUS |
| EFIAPI |
| SafeInt64ToUint16 ( |
| IN INT64 Operand, |
| OUT UINT16 *Result |
| ); |
| |
| /** |
| INT64 -> INT32 conversion |
| |
| Converts the value specified by Operand to a value specified by Result type |
| and stores the converted value into the caller allocated output buffer |
| specified by Result. The caller must pass in a Result buffer that is at |
| least as large as the Result type. |
| |
| If Result is NULL, RETURN_INVALID_PARAMETER is returned. |
| |
| If the conversion results in an overflow or an underflow condition, then |
| Result is set to INT32_ERROR and RETURN_BUFFER_TOO_SMALL is returned. |
| |
| @param[in] Operand Operand to be converted to new type |
| @param[out] Result Pointer to the result of conversion |
| |
| @retval RETURN_SUCCESS Successful conversion |
| @retval RETURN_BUFFER_TOO_SMALL Overflow |
| @retval RETURN_INVALID_PARAMETER Result is NULL |
| **/ |
| RETURN_STATUS |
| EFIAPI |
| SafeInt64ToInt32 ( |
| IN INT64 Operand, |
| OUT INT32 *Result |
| ); |
| |
| /** |
| INT64 -> UINT32 conversion |
| |
| Converts the value specified by Operand to a value specified by Result type |
| and stores the converted value into the caller allocated output buffer |
| specified by Result. The caller must pass in a Result buffer that is at |
| least as large as the Result type. |
| |
| If Result is NULL, RETURN_INVALID_PARAMETER is returned. |
| |
| If the conversion results in an overflow or an underflow condition, then |
| Result is set to UINT32_ERROR and RETURN_BUFFER_TOO_SMALL is returned. |
| |
| @param[in] Operand Operand to be converted to new type |
| @param[out] Result Pointer to the result of conversion |
| |
| @retval RETURN_SUCCESS Successful conversion |
| @retval RETURN_BUFFER_TOO_SMALL Overflow |
| @retval RETURN_INVALID_PARAMETER Result is NULL |
| **/ |
| RETURN_STATUS |
| EFIAPI |
| SafeInt64ToUint32 ( |
| IN INT64 Operand, |
| OUT UINT32 *Result |
| ); |
| |
| /** |
| INT64 -> INTN conversion |
| |
| Converts the value specified by Operand to a value specified by Result type |
| and stores the converted value into the caller allocated output buffer |
| specified by Result. The caller must pass in a Result buffer that is at |
| least as large as the Result type. |
| |
| If Result is NULL, RETURN_INVALID_PARAMETER is returned. |
| |
| If the conversion results in an overflow or an underflow condition, then |
| Result is set to INTN_ERROR and RETURN_BUFFER_TOO_SMALL is returned. |
| |
| @param[in] Operand Operand to be converted to new type |
| @param[out] Result Pointer to the result of conversion |
| |
| @retval RETURN_SUCCESS Successful conversion |
| @retval RETURN_BUFFER_TOO_SMALL Overflow |
| @retval RETURN_INVALID_PARAMETER Result is NULL |
| **/ |
| RETURN_STATUS |
| EFIAPI |
| SafeInt64ToIntn ( |
| IN INT64 Operand, |
| OUT INTN *Result |
| ); |
| |
| /** |
| INT64 -> UINTN conversion |
| |
| Converts the value specified by Operand to a value specified by Result type |
| and stores the converted value into the caller allocated output buffer |
| specified by Result. The caller must pass in a Result buffer that is at |
| least as large as the Result type. |
| |
| If Result is NULL, RETURN_INVALID_PARAMETER is returned. |
| |
| If the conversion results in an overflow or an underflow condition, then |
| Result is set to UINTN_ERROR and RETURN_BUFFER_TOO_SMALL is returned. |
| |
| @param[in] Operand Operand to be converted to new type |
| @param[out] Result Pointer to the result of conversion |
| |
| @retval RETURN_SUCCESS Successful conversion |
| @retval RETURN_BUFFER_TOO_SMALL Overflow |
| @retval RETURN_INVALID_PARAMETER Result is NULL |
| **/ |
| RETURN_STATUS |
| EFIAPI |
| SafeInt64ToUintn ( |
| IN INT64 Operand, |
| OUT UINTN *Result |
| ); |
| |
| /** |
| INT64 -> UINT64 conversion |
| |
| Converts the value specified by Operand to a value specified by Result type |
| and stores the converted value into the caller allocated output buffer |
| specified by Result. The caller must pass in a Result buffer that is at |
| least as large as the Result type. |
| |
| If Result is NULL, RETURN_INVALID_PARAMETER is returned. |
| |
| If the conversion results in an overflow or an underflow condition, then |
| Result is set to UINT64_ERROR and RETURN_BUFFER_TOO_SMALL is returned. |
| |
| @param[in] Operand Operand to be converted to new type |
| @param[out] Result Pointer to the result of conversion |
| |
| @retval RETURN_SUCCESS Successful conversion |
| @retval RETURN_BUFFER_TOO_SMALL Overflow |
| @retval RETURN_INVALID_PARAMETER Result is NULL |
| **/ |
| RETURN_STATUS |
| EFIAPI |
| SafeInt64ToUint64 ( |
| IN INT64 Operand, |
| OUT UINT64 *Result |
| ); |
| |
| /** |
| UINT64 -> INT8 conversion |
| |
| Converts the value specified by Operand to a value specified by Result type |
| and stores the converted value into the caller allocated output buffer |
| specified by Result. The caller must pass in a Result buffer that is at |
| least as large as the Result type. |
| |
| If Result is NULL, RETURN_INVALID_PARAMETER is returned. |
| |
| If the conversion results in an overflow or an underflow condition, then |
| Result is set to INT8_ERROR and RETURN_BUFFER_TOO_SMALL is returned. |
| |
| @param[in] Operand Operand to be converted to new type |
| @param[out] Result Pointer to the result of conversion |
| |
| @retval RETURN_SUCCESS Successful conversion |
| @retval RETURN_BUFFER_TOO_SMALL Overflow |
| @retval RETURN_INVALID_PARAMETER Result is NULL |
| **/ |
| RETURN_STATUS |
| EFIAPI |
| SafeUint64ToInt8 ( |
| IN UINT64 Operand, |
| OUT INT8 *Result |
| ); |
| |
| /** |
| UINT64 -> CHAR8 conversion |
| |
| Converts the value specified by Operand to a value specified by Result type |
| and stores the converted value into the caller allocated output buffer |
| specified by Result. The caller must pass in a Result buffer that is at |
| least as large as the Result type. |
| |
| If Result is NULL, RETURN_INVALID_PARAMETER is returned. |
| |
| If the conversion results in an overflow or an underflow condition, then |
| Result is set to CHAR8_ERROR and RETURN_BUFFER_TOO_SMALL is returned. |
| |
| @param[in] Operand Operand to be converted to new type |
| @param[out] Result Pointer to the result of conversion |
| |
| @retval RETURN_SUCCESS Successful conversion |
| @retval RETURN_BUFFER_TOO_SMALL Overflow |
| @retval RETURN_INVALID_PARAMETER Result is NULL |
| **/ |
| RETURN_STATUS |
| EFIAPI |
| SafeUint64ToChar8 ( |
| IN UINT64 Operand, |
| OUT CHAR8 *Result |
| ); |
| |
| /** |
| UINT64 -> UINT8 conversion |
| |
| Converts the value specified by Operand to a value specified by Result type |
| and stores the converted value into the caller allocated output buffer |
| specified by Result. The caller must pass in a Result buffer that is at |
| least as large as the Result type. |
| |
| If Result is NULL, RETURN_INVALID_PARAMETER is returned. |
| |
| If the conversion results in an overflow or an underflow condition, then |
| Result is set to UINT8_ERROR and RETURN_BUFFER_TOO_SMALL is returned. |
| |
| @param[in] Operand Operand to be converted to new type |
| @param[out] Result Pointer to the result of conversion |
| |
| @retval RETURN_SUCCESS Successful conversion |
| @retval RETURN_BUFFER_TOO_SMALL Overflow |
| @retval RETURN_INVALID_PARAMETER Result is NULL |
| **/ |
| RETURN_STATUS |
| EFIAPI |
| SafeUint64ToUint8 ( |
| IN UINT64 Operand, |
| OUT UINT8 *Result |
| ); |
| |
| /** |
| UINT64 -> INT16 conversion |
| |
| Converts the value specified by Operand to a value specified by Result type |
| and stores the converted value into the caller allocated output buffer |
| specified by Result. The caller must pass in a Result buffer that is at |
| least as large as the Result type. |
| |
| If Result is NULL, RETURN_INVALID_PARAMETER is returned. |
| |
| If the conversion results in an overflow or an underflow condition, then |
| Result is set to INT16_ERROR and RETURN_BUFFER_TOO_SMALL is returned. |
| |
| @param[in] Operand Operand to be converted to new type |
| @param[out] Result Pointer to the result of conversion |
| |
| @retval RETURN_SUCCESS Successful conversion |
| @retval RETURN_BUFFER_TOO_SMALL Overflow |
| @retval RETURN_INVALID_PARAMETER Result is NULL |
| **/ |
| RETURN_STATUS |
| EFIAPI |
| SafeUint64ToInt16 ( |
| IN UINT64 Operand, |
| OUT INT16 *Result |
| ); |
| |
| /** |
| UINT64 -> UINT16 conversion |
| |
| Converts the value specified by Operand to a value specified by Result type |
| and stores the converted value into the caller allocated output buffer |
| specified by Result. The caller must pass in a Result buffer that is at |
| least as large as the Result type. |
| |
| If Result is NULL, RETURN_INVALID_PARAMETER is returned. |
| |
| If the conversion results in an overflow or an underflow condition, then |
| Result is set to UINT16_ERROR and RETURN_BUFFER_TOO_SMALL is returned. |
| |
| @param[in] Operand Operand to be converted to new type |
| @param[out] Result Pointer to the result of conversion |
| |
| @retval RETURN_SUCCESS Successful conversion |
| @retval RETURN_BUFFER_TOO_SMALL Overflow |
| @retval RETURN_INVALID_PARAMETER Result is NULL |
| **/ |
| RETURN_STATUS |
| EFIAPI |
| SafeUint64ToUint16 ( |
| IN UINT64 Operand, |
| OUT UINT16 *Result |
| ); |
| |
| /** |
| UINT64 -> INT32 conversion |
| |
| Converts the value specified by Operand to a value specified by Result type |
| and stores the converted value into the caller allocated output buffer |
| specified by Result. The caller must pass in a Result buffer that is at |
| least as large as the Result type. |
| |
| If Result is NULL, RETURN_INVALID_PARAMETER is returned. |
| |
| If the conversion results in an overflow or an underflow condition, then |
| Result is set to INT32_ERROR and RETURN_BUFFER_TOO_SMALL is returned. |
| |
| @param[in] Operand Operand to be converted to new type |
| @param[out] Result Pointer to the result of conversion |
| |
| @retval RETURN_SUCCESS Successful conversion |
| @retval RETURN_BUFFER_TOO_SMALL Overflow |
| @retval RETURN_INVALID_PARAMETER Result is NULL |
| **/ |
| RETURN_STATUS |
| EFIAPI |
| SafeUint64ToInt32 ( |
| IN UINT64 Operand, |
| OUT INT32 *Result |
| ); |
| |
| /** |
| UINT64 -> UINT32 conversion |
| |
| Converts the value specified by Operand to a value specified by Result type |
| and stores the converted value into the caller allocated output buffer |
| specified by Result. The caller must pass in a Result buffer that is at |
| least as large as the Result type. |
| |
| If Result is NULL, RETURN_INVALID_PARAMETER is returned. |
| |
| If the conversion results in an overflow or an underflow condition, then |
| Result is set to UINT32_ERROR and RETURN_BUFFER_TOO_SMALL is returned. |
| |
| @param[in] Operand Operand to be converted to new type |
| @param[out] Result Pointer to the result of conversion |
| |
| @retval RETURN_SUCCESS Successful conversion |
| @retval RETURN_BUFFER_TOO_SMALL Overflow |
| @retval RETURN_INVALID_PARAMETER Result is NULL |
| **/ |
| RETURN_STATUS |
| EFIAPI |
| SafeUint64ToUint32 ( |
| IN UINT64 Operand, |
| OUT UINT32 *Result |
| ); |
| |
| /** |
| UINT64 -> INTN conversion |
| |
| Converts the value specified by Operand to a value specified by Result type |
| and stores the converted value into the caller allocated output buffer |
| specified by Result. The caller must pass in a Result buffer that is at |
| least as large as the Result type. |
| |
| If Result is NULL, RETURN_INVALID_PARAMETER is returned. |
| |
| If the conversion results in an overflow or an underflow condition, then |
| Result is set to INTN_ERROR and RETURN_BUFFER_TOO_SMALL is returned. |
| |
| @param[in] Operand Operand to be converted to new type |
| @param[out] Result Pointer to the result of conversion |
| |
| @retval RETURN_SUCCESS Successful conversion |
| @retval RETURN_BUFFER_TOO_SMALL Overflow |
| @retval RETURN_INVALID_PARAMETER Result is NULL |
| **/ |
| RETURN_STATUS |
| EFIAPI |
| SafeUint64ToIntn ( |
| IN UINT64 Operand, |
| OUT INTN *Result |
| ); |
| |
| /** |
| UINT64 -> UINTN conversion |
| |
| Converts the value specified by Operand to a value specified by Result type |
| and stores the converted value into the caller allocated output buffer |
| specified by Result. The caller must pass in a Result buffer that is at |
| least as large as the Result type. |
| |
| If Result is NULL, RETURN_INVALID_PARAMETER is returned. |
| |
| If the conversion results in an overflow or an underflow condition, then |
| Result is set to UINTN_ERROR and RETURN_BUFFER_TOO_SMALL is returned. |
| |
| @param[in] Operand Operand to be converted to new type |
| @param[out] Result Pointer to the result of conversion |
| |
| @retval RETURN_SUCCESS Successful conversion |
| @retval RETURN_BUFFER_TOO_SMALL Overflow |
| @retval RETURN_INVALID_PARAMETER Result is NULL |
| **/ |
| RETURN_STATUS |
| EFIAPI |
| SafeUint64ToUintn ( |
| IN UINT64 Operand, |
| OUT UINTN *Result |
| ); |
| |
| /** |
| UINT64 -> INT64 conversion |
| |
| Converts the value specified by Operand to a value specified by Result type |
| and stores the converted value into the caller allocated output buffer |
| specified by Result. The caller must pass in a Result buffer that is at |
| least as large as the Result type. |
| |
| If Result is NULL, RETURN_INVALID_PARAMETER is returned. |
| |
| If the conversion results in an overflow or an underflow condition, then |
| Result is set to INT64_ERROR and RETURN_BUFFER_TOO_SMALL is returned. |
| |
| @param[in] Operand Operand to be converted to new type |
| @param[out] Result Pointer to the result of conversion |
| |
| @retval RETURN_SUCCESS Successful conversion |
| @retval RETURN_BUFFER_TOO_SMALL Overflow |
| @retval RETURN_INVALID_PARAMETER Result is NULL |
| **/ |
| RETURN_STATUS |
| EFIAPI |
| SafeUint64ToInt64 ( |
| IN UINT64 Operand, |
| OUT INT64 *Result |
| ); |
| |
| // |
| // Addition functions |
| // |
| |
| /** |
| UINT8 addition |
| |
| Performs the requested operation using the input parameters into a value |
| specified by Result type and stores the converted value into the caller |
| allocated output buffer specified by Result. The caller must pass in a |
| Result buffer that is at least as large as the Result type. |
| |
| If Result is NULL, RETURN_INVALID_PARAMETER is returned. |
| |
| If the requested operation results in an overflow or an underflow condition, |
| then Result is set to UINT8_ERROR and RETURN_BUFFER_TOO_SMALL is returned. |
| |
| @param[in] Augend A number to which addend will be added |
| @param[in] Addend A number to be added to another |
| @param[out] Result Pointer to the result of addition |
| |
| @retval RETURN_SUCCESS Successful addition |
| @retval RETURN_BUFFER_TOO_SMALL Overflow |
| @retval RETURN_INVALID_PARAMETER Result is NULL |
| **/ |
| RETURN_STATUS |
| EFIAPI |
| SafeUint8Add ( |
| IN UINT8 Augend, |
| IN UINT8 Addend, |
| OUT UINT8 *Result |
| ); |
| |
| /** |
| UINT16 addition |
| |
| Performs the requested operation using the input parameters into a value |
| specified by Result type and stores the converted value into the caller |
| allocated output buffer specified by Result. The caller must pass in a |
| Result buffer that is at least as large as the Result type. |
| |
| If Result is NULL, RETURN_INVALID_PARAMETER is returned. |
| |
| If the requested operation results in an overflow or an underflow condition, |
| then Result is set to UINT16_ERROR and RETURN_BUFFER_TOO_SMALL is returned. |
| |
| @param[in] Augend A number to which addend will be added |
| @param[in] Addend A number to be added to another |
| @param[out] Result Pointer to the result of addition |
| |
| @retval RETURN_SUCCESS Successful addition |
| @retval RETURN_BUFFER_TOO_SMALL Overflow |
| @retval RETURN_INVALID_PARAMETER Result is NULL |
| **/ |
| RETURN_STATUS |
| EFIAPI |
| SafeUint16Add ( |
| IN UINT16 Augend, |
| IN UINT16 Addend, |
| OUT UINT16 *Result |
| ); |
| |
| /** |
| UINT32 addition |
| |
| Performs the requested operation using the input parameters into a value |
| specified by Result type and stores the converted value into the caller |
| allocated output buffer specified by Result. The caller must pass in a |
| Result buffer that is at least as large as the Result type. |
| |
| If Result is NULL, RETURN_INVALID_PARAMETER is returned. |
| |
| If the requested operation results in an overflow or an underflow condition, |
| then Result is set to UINT32_ERROR and RETURN_BUFFER_TOO_SMALL is returned. |
| |
| @param[in] Augend A number to which addend will be added |
| @param[in] Addend A number to be added to another |
| @param[out] Result Pointer to the result of addition |
| |
| @retval RETURN_SUCCESS Successful addition |
| @retval RETURN_BUFFER_TOO_SMALL Overflow |
| @retval RETURN_INVALID_PARAMETER Result is NULL |
| **/ |
| RETURN_STATUS |
| EFIAPI |
| SafeUint32Add ( |
| IN UINT32 Augend, |
| IN UINT32 Addend, |
| OUT UINT32 *Result |
| ); |
| |
| /** |
| UINTN addition |
| |
| Performs the requested operation using the input parameters into a value |
| specified by Result type and stores the converted value into the caller |
| allocated output buffer specified by Result. The caller must pass in a |
| Result buffer that is at least as large as the Result type. |
| |
| If Result is NULL, RETURN_INVALID_PARAMETER is returned. |
| |
| If the requested operation results in an overflow or an underflow condition, |
| then Result is set to UINTN_ERROR and RETURN_BUFFER_TOO_SMALL is returned. |
| |
| @param[in] Augend A number to which addend will be added |
| @param[in] Addend A number to be added to another |
| @param[out] Result Pointer to the result of addition |
| |
| @retval RETURN_SUCCESS Successful addition |
| @retval RETURN_BUFFER_TOO_SMALL Overflow |
| @retval RETURN_INVALID_PARAMETER Result is NULL |
| **/ |
| RETURN_STATUS |
| EFIAPI |
| SafeUintnAdd ( |
| IN UINTN Augend, |
| IN UINTN Addend, |
| OUT UINTN *Result |
| ); |
| |
| /** |
| UINT64 addition |
| |
| Performs the requested operation using the input parameters into a value |
| specified by Result type and stores the converted value into the caller |
| allocated output buffer specified by Result. The caller must pass in a |
| Result buffer that is at least as large as the Result type. |
| |
| If Result is NULL, RETURN_INVALID_PARAMETER is returned. |
| |
| If the requested operation results in an overflow or an underflow condition, |
| then Result is set to UINT64_ERROR and RETURN_BUFFER_TOO_SMALL is returned. |
| |
| @param[in] Augend A number to which addend will be added |
| @param[in] Addend A number to be added to another |
| @param[out] Result Pointer to the result of addition |
| |
| @retval RETURN_SUCCESS Successful addition |
| @retval RETURN_BUFFER_TOO_SMALL Overflow |
| @retval RETURN_INVALID_PARAMETER Result is NULL |
| **/ |
| RETURN_STATUS |
| EFIAPI |
| SafeUint64Add ( |
| IN UINT64 Augend, |
| IN UINT64 Addend, |
| OUT UINT64 *Result |
| ); |
| |
| // |
| // Subtraction functions |
| // |
| |
| /** |
| UINT8 subtraction |
| |
| Performs the requested operation using the input parameters into a value |
| specified by Result type and stores the converted value into the caller |
| allocated output buffer specified by Result. The caller must pass in a |
| Result buffer that is at least as large as the Result type. |
| |
| If Result is NULL, RETURN_INVALID_PARAMETER is returned. |
| |
| If the requested operation results in an overflow or an underflow condition, |
| then Result is set to UINT8_ERROR and RETURN_BUFFER_TOO_SMALL is returned. |
| |
| @param[in] Minuend A number from which another is to be subtracted. |
| @param[in] Subtrahend A number to be subtracted from another |
| @param[out] Result Pointer to the result of subtraction |
| |
| @retval RETURN_SUCCESS Successful subtraction |
| @retval RETURN_BUFFER_TOO_SMALL Underflow |
| @retval RETURN_INVALID_PARAMETER Result is NULL |
| **/ |
| RETURN_STATUS |
| EFIAPI |
| SafeUint8Sub ( |
| IN UINT8 Minuend, |
| IN UINT8 Subtrahend, |
| OUT UINT8 *Result |
| ); |
| |
| /** |
| UINT16 subtraction |
| |
| Performs the requested operation using the input parameters into a value |
| specified by Result type and stores the converted value into the caller |
| allocated output buffer specified by Result. The caller must pass in a |
| Result buffer that is at least as large as the Result type. |
| |
| If Result is NULL, RETURN_INVALID_PARAMETER is returned. |
| |
| If the requested operation results in an overflow or an underflow condition, |
| then Result is set to UINT16_ERROR and RETURN_BUFFER_TOO_SMALL is returned. |
| |
| @param[in] Minuend A number from which another is to be subtracted. |
| @param[in] Subtrahend A number to be subtracted from another |
| @param[out] Result Pointer to the result of subtraction |
| |
| @retval RETURN_SUCCESS Successful subtraction |
| @retval RETURN_BUFFER_TOO_SMALL Underflow |
| @retval RETURN_INVALID_PARAMETER Result is NULL |
| **/ |
| RETURN_STATUS |
| EFIAPI |
| SafeUint16Sub ( |
| IN UINT16 Minuend, |
| IN UINT16 Subtrahend, |
| OUT UINT16 *Result |
| ); |
| |
| /** |
| UINT32 subtraction |
| |
| Performs the requested operation using the input parameters into a value |
| specified by Result type and stores the converted value into the caller |
| allocated output buffer specified by Result. The caller must pass in a |
| Result buffer that is at least as large as the Result type. |
| |
| If Result is NULL, RETURN_INVALID_PARAMETER is returned. |
| |
| If the requested operation results in an overflow or an underflow condition, |
| then Result is set to UINT32_ERROR and RETURN_BUFFER_TOO_SMALL is returned. |
| |
| @param[in] Minuend A number from which another is to be subtracted. |
| @param[in] Subtrahend A number to be subtracted from another |
| @param[out] Result Pointer to the result of subtraction |
| |
| @retval RETURN_SUCCESS Successful subtraction |
| @retval RETURN_BUFFER_TOO_SMALL Underflow |
| @retval RETURN_INVALID_PARAMETER Result is NULL |
| **/ |
| RETURN_STATUS |
| EFIAPI |
| SafeUint32Sub ( |
| IN UINT32 Minuend, |
| IN UINT32 Subtrahend, |
| OUT UINT32 *Result |
| ); |
| |
| /** |
| UINTN subtraction |
| |
| Performs the requested operation using the input parameters into a value |
| specified by Result type and stores the converted value into the caller |
| allocated output buffer specified by Result. The caller must pass in a |
| Result buffer that is at least as large as the Result type. |
| |
| If Result is NULL, RETURN_INVALID_PARAMETER is returned. |
| |
| If the requested operation results in an overflow or an underflow condition, |
| then Result is set to UINTN_ERROR and RETURN_BUFFER_TOO_SMALL is returned. |
| |
| @param[in] Minuend A number from which another is to be subtracted. |
| @param[in] Subtrahend A number to be subtracted from another |
| @param[out] Result Pointer to the result of subtraction |
| |
| @retval RETURN_SUCCESS Successful subtraction |
| @retval RETURN_BUFFER_TOO_SMALL Underflow |
| @retval RETURN_INVALID_PARAMETER Result is NULL |
| **/ |
| RETURN_STATUS |
| EFIAPI |
| SafeUintnSub ( |
| IN UINTN Minuend, |
| IN UINTN Subtrahend, |
| OUT UINTN *Result |
| ); |
| |
| /** |
| UINT64 subtraction |
| |
| Performs the requested operation using the input parameters into a value |
| specified by Result type and stores the converted value into the caller |
| allocated output buffer specified by Result. The caller must pass in a |
| Result buffer that is at least as large as the Result type. |
| |
| If Result is NULL, RETURN_INVALID_PARAMETER is returned. |
| |
| If the requested operation results in an overflow or an underflow condition, |
| then Result is set to UINT64_ERROR and RETURN_BUFFER_TOO_SMALL is returned. |
| |
| @param[in] Minuend A number from which another is to be subtracted. |
| @param[in] Subtrahend A number to be subtracted from another |
| @param[out] Result Pointer to the result of subtraction |
| |
| @retval RETURN_SUCCESS Successful subtraction |
| @retval RETURN_BUFFER_TOO_SMALL Underflow |
| @retval RETURN_INVALID_PARAMETER Result is NULL |
| **/ |
| RETURN_STATUS |
| EFIAPI |
| SafeUint64Sub ( |
| IN UINT64 Minuend, |
| IN UINT64 Subtrahend, |
| OUT UINT64 *Result |
| ); |
| |
| // |
| // Multiplication functions |
| // |
| |
| /** |
| UINT8 multiplication |
| |
| Performs the requested operation using the input parameters into a value |
| specified by Result type and stores the converted value into the caller |
| allocated output buffer specified by Result. The caller must pass in a |
| Result buffer that is at least as large as the Result type. |
| |
| If Result is NULL, RETURN_INVALID_PARAMETER is returned. |
| |
| If the requested operation results in an overflow or an underflow condition, |
| then Result is set to UINT8_ERROR and RETURN_BUFFER_TOO_SMALL is returned. |
| |
| @param[in] Multiplicand A number that is to be multiplied by another |
| @param[in] Multiplier A number by which the multiplicand is to be multiplied |
| @param[out] Result Pointer to the result of multiplication |
| |
| @retval RETURN_SUCCESS Successful multiplication |
| @retval RETURN_BUFFER_TOO_SMALL Overflow |
| @retval RETURN_INVALID_PARAMETER Result is NULL |
| **/ |
| RETURN_STATUS |
| EFIAPI |
| SafeUint8Mult ( |
| IN UINT8 Multiplicand, |
| IN UINT8 Multiplier, |
| OUT UINT8 *Result |
| ); |
| |
| /** |
| UINT16 multiplication |
| |
| Performs the requested operation using the input parameters into a value |
| specified by Result type and stores the converted value into the caller |
| allocated output buffer specified by Result. The caller must pass in a |
| Result buffer that is at least as large as the Result type. |
| |
| If Result is NULL, RETURN_INVALID_PARAMETER is returned. |
| |
| If the requested operation results in an overflow or an underflow condition, |
| then Result is set to UINT16_ERROR and RETURN_BUFFER_TOO_SMALL is returned. |
| |
| @param[in] Multiplicand A number that is to be multiplied by another |
| @param[in] Multiplier A number by which the multiplicand is to be multiplied |
| @param[out] Result Pointer to the result of multiplication |
| |
| @retval RETURN_SUCCESS Successful multiplication |
| @retval RETURN_BUFFER_TOO_SMALL Overflow |
| @retval RETURN_INVALID_PARAMETER Result is NULL |
| **/ |
| RETURN_STATUS |
| EFIAPI |
| SafeUint16Mult ( |
| IN UINT16 Multiplicand, |
| IN UINT16 Multiplier, |
| OUT UINT16 *Result |
| ); |
| |
| /** |
| UINT32 multiplication |
| |
| Performs the requested operation using the input parameters into a value |
| specified by Result type and stores the converted value into the caller |
| allocated output buffer specified by Result. The caller must pass in a |
| Result buffer that is at least as large as the Result type. |
| |
| If Result is NULL, RETURN_INVALID_PARAMETER is returned. |
| |
| If the requested operation results in an overflow or an underflow condition, |
| then Result is set to UINT32_ERROR and RETURN_BUFFER_TOO_SMALL is returned. |
| |
| @param[in] Multiplicand A number that is to be multiplied by another |
| @param[in] Multiplier A number by which the multiplicand is to be multiplied |
| @param[out] Result Pointer to the result of multiplication |
| |
| @retval RETURN_SUCCESS Successful multiplication |
| @retval RETURN_BUFFER_TOO_SMALL Overflow |
| @retval RETURN_INVALID_PARAMETER Result is NULL |
| **/ |
| RETURN_STATUS |
| EFIAPI |
| SafeUint32Mult ( |
| IN UINT32 Multiplicand, |
| IN UINT32 Multiplier, |
| OUT UINT32 *Result |
| ); |
| |
| /** |
| UINTN multiplication |
| |
| Performs the requested operation using the input parameters into a value |
| specified by Result type and stores the converted value into the caller |
| allocated output buffer specified by Result. The caller must pass in a |
| Result buffer that is at least as large as the Result type. |
| |
| If Result is NULL, RETURN_INVALID_PARAMETER is returned. |
| |
| If the requested operation results in an overflow or an underflow condition, |
| then Result is set to UINTN_ERROR and RETURN_BUFFER_TOO_SMALL is returned. |
| |
| @param[in] Multiplicand A number that is to be multiplied by another |
| @param[in] Multiplier A number by which the multiplicand is to be multiplied |
| @param[out] Result Pointer to the result of multiplication |
| |
| @retval RETURN_SUCCESS Successful multiplication |
| @retval RETURN_BUFFER_TOO_SMALL Overflow |
| @retval RETURN_INVALID_PARAMETER Result is NULL |
| **/ |
| RETURN_STATUS |
| EFIAPI |
| SafeUintnMult ( |
| IN UINTN Multiplicand, |
| IN UINTN Multiplier, |
| OUT UINTN *Result |
| ); |
| |
| /** |
| UINT64 multiplication |
| |
| Performs the requested operation using the input parameters into a value |
| specified by Result type and stores the converted value into the caller |
| allocated output buffer specified by Result. The caller must pass in a |
| Result buffer that is at least as large as the Result type. |
| |
| If Result is NULL, RETURN_INVALID_PARAMETER is returned. |
| |
| If the requested operation results in an overflow or an underflow condition, |
| then Result is set to UINT64_ERROR and RETURN_BUFFER_TOO_SMALL is returned. |
| |
| @param[in] Multiplicand A number that is to be multiplied by another |
| @param[in] Multiplier A number by which the multiplicand is to be multiplied |
| @param[out] Result Pointer to the result of multiplication |
| |
| @retval RETURN_SUCCESS Successful multiplication |
| @retval RETURN_BUFFER_TOO_SMALL Overflow |
| @retval RETURN_INVALID_PARAMETER Result is NULL |
| **/ |
| RETURN_STATUS |
| EFIAPI |
| SafeUint64Mult ( |
| IN UINT64 Multiplicand, |
| IN UINT64 Multiplier, |
| OUT UINT64 *Result |
| ); |
| |
| // |
| // Signed operations |
| // |
| // Strongly consider using unsigned numbers. |
| // |
| // Signed numbers are often used where unsigned numbers should be used. |
| // For example file sizes and array indices should always be unsigned. |
| // Subtracting a larger positive signed number from a smaller positive |
| // signed number with SafeInt32Sub will succeed, producing a negative number, |
| // that then must not be used as an array index (but can occasionally be |
| // used as a pointer index.) Similarly for adding a larger magnitude |
| // negative number to a smaller magnitude positive number. |
| // |
| // This library does not protect you from such errors. It tells you if your |
| // integer operations overflowed, not if you are doing the right thing |
| // with your non-overflowed integers. |
| // |
| // Likewise you can overflow a buffer with a non-overflowed unsigned index. |
| // |
| |
| // |
| // Signed addition functions |
| // |
| |
| /** |
| INT8 Addition |
| |
| Performs the requested operation using the input parameters into a value |
| specified by Result type and stores the converted value into the caller |
| allocated output buffer specified by Result. The caller must pass in a |
| Result buffer that is at least as large as the Result type. |
| |
| If Result is NULL, RETURN_INVALID_PARAMETER is returned. |
| |
| If the requested operation results in an overflow or an underflow condition, |
| then Result is set to INT8_ERROR and RETURN_BUFFER_TOO_SMALL is returned. |
| |
| @param[in] Augend A number to which addend will be added |
| @param[in] Addend A number to be added to another |
| @param[out] Result Pointer to the result of addition |
| |
| @retval RETURN_SUCCESS Successful addition |
| @retval RETURN_BUFFER_TOO_SMALL Overflow |
| @retval RETURN_INVALID_PARAMETER Result is NULL |
| **/ |
| RETURN_STATUS |
| EFIAPI |
| SafeInt8Add ( |
| IN INT8 Augend, |
| IN INT8 Addend, |
| OUT INT8 *Result |
| ); |
| |
| /** |
| CHAR8 Addition |
| |
| Performs the requested operation using the input parameters into a value |
| specified by Result type and stores the converted value into the caller |
| allocated output buffer specified by Result. The caller must pass in a |
| Result buffer that is at least as large as the Result type. |
| |
| If Result is NULL, RETURN_INVALID_PARAMETER is returned. |
| |
| If the requested operation results in an overflow or an underflow condition, |
| then Result is set to CHAR8_ERROR and RETURN_BUFFER_TOO_SMALL is returned. |
| |
| @param[in] Augend A number to which addend will be added |
| @param[in] Addend A number to be added to another |
| @param[out] Result Pointer to the result of addition |
| |
| @retval RETURN_SUCCESS Successful addition |
| @retval RETURN_BUFFER_TOO_SMALL Overflow |
| @retval RETURN_INVALID_PARAMETER Result is NULL |
| **/ |
| RETURN_STATUS |
| EFIAPI |
| SafeChar8Add ( |
| IN CHAR8 Augend, |
| IN CHAR8 Addend, |
| OUT CHAR8 *Result |
| ); |
| |
| /** |
| INT16 Addition |
| |
| Performs the requested operation using the input parameters into a value |
| specified by Result type and stores the converted value into the caller |
| allocated output buffer specified by Result. The caller must pass in a |
| Result buffer that is at least as large as the Result type. |
| |
| If Result is NULL, RETURN_INVALID_PARAMETER is returned. |
| |
| If the requested operation results in an overflow or an underflow condition, |
| then Result is set to INT16_ERROR and RETURN_BUFFER_TOO_SMALL is returned. |
| |
| @param[in] Augend A number to which addend will be added |
| @param[in] Addend A number to be added to another |
| @param[out] Result Pointer to the result of addition |
| |
| @retval RETURN_SUCCESS Successful addition |
| @retval RETURN_BUFFER_TOO_SMALL Overflow |
| @retval RETURN_INVALID_PARAMETER Result is NULL |
| **/ |
| RETURN_STATUS |
| EFIAPI |
| SafeInt16Add ( |
| IN INT16 Augend, |
| IN INT16 Addend, |
| OUT INT16 *Result |
| ); |
| |
| /** |
| INT32 Addition |
| |
| Performs the requested operation using the input parameters into a value |
| specified by Result type and stores the converted value into the caller |
| allocated output buffer specified by Result. The caller must pass in a |
| Result buffer that is at least as large as the Result type. |
| |
| If Result is NULL, RETURN_INVALID_PARAMETER is returned. |
| |
| If the requested operation results in an overflow or an underflow condition, |
| then Result is set to INT32_ERROR and RETURN_BUFFER_TOO_SMALL is returned. |
| |
| @param[in] Augend A number to which addend will be added |
| @param[in] Addend A number to be added to another |
| @param[out] Result Pointer to the result of addition |
| |
| @retval RETURN_SUCCESS Successful addition |
| @retval RETURN_BUFFER_TOO_SMALL Overflow |
| @retval RETURN_INVALID_PARAMETER Result is NULL |
| **/ |
| RETURN_STATUS |
| EFIAPI |
| SafeInt32Add ( |
| IN INT32 Augend, |
| IN INT32 Addend, |
| OUT INT32 *Result |
| ); |
| |
| /** |
| INTN Addition |
| |
| Performs the requested operation using the input parameters into a value |
| specified by Result type and stores the converted value into the caller |
| allocated output buffer specified by Result. The caller must pass in a |
| Result buffer that is at least as large as the Result type. |
| |
| If Result is NULL, RETURN_INVALID_PARAMETER is returned. |
| |
| If the requested operation results in an overflow or an underflow condition, |
| then Result is set to INTN_ERROR and RETURN_BUFFER_TOO_SMALL is returned. |
| |
| @param[in] Augend A number to which addend will be added |
| @param[in] Addend A number to be added to another |
| @param[out] Result Pointer to the result of addition |
| |
| @retval RETURN_SUCCESS Successful addition |
| @retval RETURN_BUFFER_TOO_SMALL Overflow |
| @retval RETURN_INVALID_PARAMETER Result is NULL |
| **/ |
| RETURN_STATUS |
| EFIAPI |
| SafeIntnAdd ( |
| IN INTN Augend, |
| IN INTN Addend, |
| OUT INTN *Result |
| ); |
| |
| /** |
| INT64 Addition |
| |
| Performs the requested operation using the input parameters into a value |
| specified by Result type and stores the converted value into the caller |
| allocated output buffer specified by Result. The caller must pass in a |
| Result buffer that is at least as large as the Result type. |
| |
| If Result is NULL, RETURN_INVALID_PARAMETER is returned. |
| |
| If the requested operation results in an overflow or an underflow condition, |
| then Result is set to INT64_ERROR and RETURN_BUFFER_TOO_SMALL is returned. |
| |
| @param[in] Augend A number to which addend will be added |
| @param[in] Addend A number to be added to another |
| @param[out] Result Pointer to the result of addition |
| |
| @retval RETURN_SUCCESS Successful addition |
| @retval RETURN_BUFFER_TOO_SMALL Overflow |
| @retval RETURN_INVALID_PARAMETER Result is NULL |
| **/ |
| RETURN_STATUS |
| EFIAPI |
| SafeInt64Add ( |
| IN INT64 Augend, |
| IN INT64 Addend, |
| OUT INT64 *Result |
| ); |
| |
| // |
| // Signed subtraction functions |
| // |
| |
| /** |
| INT8 Subtraction |
| |
| Performs the requested operation using the input parameters into a value |
| specified by Result type and stores the converted value into the caller |
| allocated output buffer specified by Result. The caller must pass in a |
| Result buffer that is at least as large as the Result type. |
| |
| If Result is NULL, RETURN_INVALID_PARAMETER is returned. |
| |
| If the requested operation results in an overflow or an underflow condition, |
| then Result is set to INT8_ERROR and RETURN_BUFFER_TOO_SMALL is returned. |
| |
| @param[in] Minuend A number from which another is to be subtracted. |
| @param[in] Subtrahend A number to be subtracted from another |
| @param[out] Result Pointer to the result of subtraction |
| |
| @retval RETURN_SUCCESS Successful subtraction |
| @retval RETURN_BUFFER_TOO_SMALL Underflow |
| @retval RETURN_INVALID_PARAMETER Result is NULL |
| **/ |
| RETURN_STATUS |
| EFIAPI |
| SafeInt8Sub ( |
| IN INT8 Minuend, |
| IN INT8 Subtrahend, |
| OUT INT8 *Result |
| ); |
| |
| /** |
| CHAR8 Subtraction |
| |
| Performs the requested operation using the input parameters into a value |
| specified by Result type and stores the converted value into the caller |
| allocated output buffer specified by Result. The caller must pass in a |
| Result buffer that is at least as large as the Result type. |
| |
| If Result is NULL, RETURN_INVALID_PARAMETER is returned. |
| |
| If the requested operation results in an overflow or an underflow condition, |
| then Result is set to CHAR8_ERROR and RETURN_BUFFER_TOO_SMALL is returned. |
| |
| @param[in] Minuend A number from which another is to be subtracted. |
| @param[in] Subtrahend A number to be subtracted from another |
| @param[out] Result Pointer to the result of subtraction |
| |
| @retval RETURN_SUCCESS Successful subtraction |
| @retval RETURN_BUFFER_TOO_SMALL Underflow |
| @retval RETURN_INVALID_PARAMETER Result is NULL |
| **/ |
| RETURN_STATUS |
| EFIAPI |
| SafeChar8Sub ( |
| IN CHAR8 Minuend, |
| IN CHAR8 Subtrahend, |
| OUT CHAR8 *Result |
| ); |
| |
| /** |
| INT16 Subtraction |
| |
| Performs the requested operation using the input parameters into a value |
| specified by Result type and stores the converted value into the caller |
| allocated output buffer specified by Result. The caller must pass in a |
| Result buffer that is at least as large as the Result type. |
| |
| If Result is NULL, RETURN_INVALID_PARAMETER is returned. |
| |
| If the requested operation results in an overflow or an underflow condition, |
| then Result is set to INT16_ERROR and RETURN_BUFFER_TOO_SMALL is returned. |
| |
| @param[in] Minuend A number from which another is to be subtracted. |
| @param[in] Subtrahend A number to be subtracted from another |
| @param[out] Result Pointer to the result of subtraction |
| |
| @retval RETURN_SUCCESS Successful subtraction |
| @retval RETURN_BUFFER_TOO_SMALL Underflow |
| @retval RETURN_INVALID_PARAMETER Result is NULL |
| **/ |
| RETURN_STATUS |
| EFIAPI |
| SafeInt16Sub ( |
| IN INT16 Minuend, |
| IN INT16 Subtrahend, |
| OUT INT16 *Result |
| ); |
| |
| /** |
| INT32 Subtraction |
| |
| Performs the requested operation using the input parameters into a value |
| specified by Result type and stores the converted value into the caller |
| allocated output buffer specified by Result. The caller must pass in a |
| Result buffer that is at least as large as the Result type. |
| |
| If Result is NULL, RETURN_INVALID_PARAMETER is returned. |
| |
| If the requested operation results in an overflow or an underflow condition, |
| then Result is set to INT32_ERROR and RETURN_BUFFER_TOO_SMALL is returned. |
| |
| @param[in] Minuend A number from which another is to be subtracted. |
| @param[in] Subtrahend A number to be subtracted from another |
| @param[out] Result Pointer to the result of subtraction |
| |
| @retval RETURN_SUCCESS Successful subtraction |
| @retval RETURN_BUFFER_TOO_SMALL Underflow |
| @retval RETURN_INVALID_PARAMETER Result is NULL |
| **/ |
| RETURN_STATUS |
| EFIAPI |
| SafeInt32Sub ( |
| IN INT32 Minuend, |
| IN INT32 Subtrahend, |
| OUT INT32 *Result |
| ); |
| |
| /** |
| INTN Subtraction |
| |
| Performs the requested operation using the input parameters into a value |
| specified by Result type and stores the converted value into the caller |
| allocated output buffer specified by Result. The caller must pass in a |
| Result buffer that is at least as large as the Result type. |
| |
| If Result is NULL, RETURN_INVALID_PARAMETER is returned. |
| |
| If the requested operation results in an overflow or an underflow condition, |
| then Result is set to INTN_ERROR and RETURN_BUFFER_TOO_SMALL is returned. |
| |
| @param[in] Minuend A number from which another is to be subtracted. |
| @param[in] Subtrahend A number to be subtracted from another |
| @param[out] Result Pointer to the result of subtraction |
| |
| @retval RETURN_SUCCESS Successful subtraction |
| @retval RETURN_BUFFER_TOO_SMALL Underflow |
| @retval RETURN_INVALID_PARAMETER Result is NULL |
| **/ |
| RETURN_STATUS |
| EFIAPI |
| SafeIntnSub ( |
| IN INTN Minuend, |
| IN INTN Subtrahend, |
| OUT INTN *Result |
| ); |
| |
| /** |
| INT64 Subtraction |
| |
| Performs the requested operation using the input parameters into a value |
| specified by Result type and stores the converted value into the caller |
| allocated output buffer specified by Result. The caller must pass in a |
| Result buffer that is at least as large as the Result type. |
| |
| If Result is NULL, RETURN_INVALID_PARAMETER is returned. |
| |
| If the requested operation results in an overflow or an underflow condition, |
| then Result is set to INT64_ERROR and RETURN_BUFFER_TOO_SMALL is returned. |
| |
| @param[in] Minuend A number from which another is to be subtracted. |
| @param[in] Subtrahend A number to be subtracted from another |
| @param[out] Result Pointer to the result of subtraction |
| |
| @retval RETURN_SUCCESS Successful subtraction |
| @retval RETURN_BUFFER_TOO_SMALL Underflow |
| @retval RETURN_INVALID_PARAMETER Result is NULL |
| **/ |
| RETURN_STATUS |
| EFIAPI |
| SafeInt64Sub ( |
| IN INT64 Minuend, |
| IN INT64 Subtrahend, |
| OUT INT64 *Result |
| ); |
| |
| // |
| // Signed multiplication functions |
| // |
| |
| /** |
| INT8 multiplication |
| |
| Performs the requested operation using the input parameters into a value |
| specified by Result type and stores the converted value into the caller |
| allocated output buffer specified by Result. The caller must pass in a |
| Result buffer that is at least as large as the Result type. |
| |
| If Result is NULL, RETURN_INVALID_PARAMETER is returned. |
| |
| If the requested operation results in an overflow or an underflow condition, |
| then Result is set to INT8_ERROR and RETURN_BUFFER_TOO_SMALL is returned. |
| |
| @param[in] Multiplicand A number that is to be multiplied by another |
| @param[in] Multiplier A number by which the multiplicand is to be multiplied |
| @param[out] Result Pointer to the result of multiplication |
| |
| @retval RETURN_SUCCESS Successful multiplication |
| @retval RETURN_BUFFER_TOO_SMALL Overflow |
| @retval RETURN_INVALID_PARAMETER Result is NULL |
| **/ |
| RETURN_STATUS |
| EFIAPI |
| SafeInt8Mult ( |
| IN INT8 Multiplicand, |
| IN INT8 Multiplier, |
| OUT INT8 *Result |
| ); |
| |
| /** |
| CHAR8 multiplication |
| |
| Performs the requested operation using the input parameters into a value |
| specified by Result type and stores the converted value into the caller |
| allocated output buffer specified by Result. The caller must pass in a |
| Result buffer that is at least as large as the Result type. |
| |
| If Result is NULL, RETURN_INVALID_PARAMETER is returned. |
| |
| If the requested operation results in an overflow or an underflow condition, |
| then Result is set to CHAR8_ERROR and RETURN_BUFFER_TOO_SMALL is returned. |
| |
| @param[in] Multiplicand A number that is to be multiplied by another |
| @param[in] Multiplier A number by which the multiplicand is to be multiplied |
| @param[out] Result Pointer to the result of multiplication |
| |
| @retval RETURN_SUCCESS Successful multiplication |
| @retval RETURN_BUFFER_TOO_SMALL Overflow |
| @retval RETURN_INVALID_PARAMETER Result is NULL |
| **/ |
| RETURN_STATUS |
| EFIAPI |
| SafeChar8Mult ( |
| IN CHAR8 Multiplicand, |
| IN CHAR8 Multiplier, |
| OUT CHAR8 *Result |
| ); |
| |
| /** |
| INT16 multiplication |
| |
| Performs the requested operation using the input parameters into a value |
| specified by Result type and stores the converted value into the caller |
| allocated output buffer specified by Result. The caller must pass in a |
| Result buffer that is at least as large as the Result type. |
| |
| If Result is NULL, RETURN_INVALID_PARAMETER is returned. |
| |
| If the requested operation results in an overflow or an underflow condition, |
| then Result is set to INT16_ERROR and RETURN_BUFFER_TOO_SMALL is returned. |
| |
| @param[in] Multiplicand A number that is to be multiplied by another |
| @param[in] Multiplier A number by which the multiplicand is to be multiplied |
| @param[out] Result Pointer to the result of multiplication |
| |
| @retval RETURN_SUCCESS Successful multiplication |
| @retval RETURN_BUFFER_TOO_SMALL Overflow |
| @retval RETURN_INVALID_PARAMETER Result is NULL |
| **/ |
| RETURN_STATUS |
| EFIAPI |
| SafeInt16Mult ( |
| IN INT16 Multiplicand, |
| IN INT16 Multiplier, |
| OUT INT16 *Result |
| ); |
| |
| /** |
| INT32 multiplication |
| |
| Performs the requested operation using the input parameters into a value |
| specified by Result type and stores the converted value into the caller |
| allocated output buffer specified by Result. The caller must pass in a |
| Result buffer that is at least as large as the Result type. |
| |
| If Result is NULL, RETURN_INVALID_PARAMETER is returned. |
| |
| If the requested operation results in an overflow or an underflow condition, |
| then Result is set to INT32_ERROR and RETURN_BUFFER_TOO_SMALL is returned. |
| |
| @param[in] Multiplicand A number that is to be multiplied by another |
| @param[in] Multiplier A number by which the multiplicand is to be multiplied |
| @param[out] Result Pointer to the result of multiplication |
| |
| @retval RETURN_SUCCESS Successful multiplication |
| @retval RETURN_BUFFER_TOO_SMALL Overflow |
| @retval RETURN_INVALID_PARAMETER Result is NULL |
| **/ |
| RETURN_STATUS |
| EFIAPI |
| SafeInt32Mult ( |
| IN INT32 Multiplicand, |
| IN INT32 Multiplier, |
| OUT INT32 *Result |
| ); |
| |
| /** |
| INTN multiplication |
| |
| Performs the requested operation using the input parameters into a value |
| specified by Result type and stores the converted value into the caller |
| allocated output buffer specified by Result. The caller must pass in a |
| Result buffer that is at least as large as the Result type. |
| |
| If Result is NULL, RETURN_INVALID_PARAMETER is returned. |
| |
| If the requested operation results in an overflow or an underflow condition, |
| then Result is set to INTN_ERROR and RETURN_BUFFER_TOO_SMALL is returned. |
| |
| @param[in] Multiplicand A number that is to be multiplied by another |
| @param[in] Multiplier A number by which the multiplicand is to be multiplied |
| @param[out] Result Pointer to the result of multiplication |
| |
| @retval RETURN_SUCCESS Successful multiplication |
| @retval RETURN_BUFFER_TOO_SMALL Overflow |
| @retval RETURN_INVALID_PARAMETER Result is NULL |
| **/ |
| RETURN_STATUS |
| EFIAPI |
| SafeIntnMult ( |
| IN INTN Multiplicand, |
| IN INTN Multiplier, |
| OUT INTN *Result |
| ); |
| |
| /** |
| INT64 multiplication |
| |
| Performs the requested operation using the input parameters into a value |
| specified by Result type and stores the converted value into the caller |
| allocated output buffer specified by Result. The caller must pass in a |
| Result buffer that is at least as large as the Result type. |
| |
| If Result is NULL, RETURN_INVALID_PARAMETER is returned. |
| |
| If the requested operation results in an overflow or an underflow condition, |
| then Result is set to INT64_ERROR and RETURN_BUFFER_TOO_SMALL is returned. |
| |
| @param[in] Multiplicand A number that is to be multiplied by another |
| @param[in] Multiplier A number by which the multiplicand is to be multiplied |
| @param[out] Result Pointer to the result of multiplication |
| |
| @retval RETURN_SUCCESS Successful multiplication |
| @retval RETURN_BUFFER_TOO_SMALL Overflow |
| @retval RETURN_INVALID_PARAMETER Result is NULL |
| **/ |
| RETURN_STATUS |
| EFIAPI |
| SafeInt64Mult ( |
| IN INT64 Multiplicand, |
| IN INT64 Multiplier, |
| OUT INT64 *Result |
| ); |
| |
| #endif // __INT_SAFE_LIB_H__ |