/** @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. | |
Redistribution and use in source and binary forms, with or without | |
modification, are permitted provided that the following conditions are met: | |
1. Redistributions of source code must retain the above copyright notice, | |
this list of conditions and the following disclaimer. | |
2. Redistributions in binary form must reproduce the above copyright notice, | |
this list of conditions and the following disclaimer in the documentation | |
and/or other materials provided with the distribution. | |
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND | |
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED | |
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. | |
IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, | |
INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, | |
BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, | |
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF | |
LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE | |
OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF | |
ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | |
**/ | |
#include <Base.h> | |
#include <Library/SafeIntLib.h> | |
#include <Library/BaseLib.h> | |
// | |
// Magnitude of MIN_INT64 as expressed by a UINT64 number. | |
// | |
#define MIN_INT64_MAGNITUDE (((UINT64)(- (MIN_INT64 + 1))) + 1) | |
// | |
// 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 | |
) | |
{ | |
RETURN_STATUS Status; | |
if (Result == NULL) { | |
return RETURN_INVALID_PARAMETER; | |
} | |
if (Operand >= 0) { | |
*Result = (UINT8)Operand; | |
Status = RETURN_SUCCESS; | |
} else { | |
*Result = UINT8_ERROR; | |
Status = RETURN_BUFFER_TOO_SMALL; | |
} | |
return Status; | |
} | |
/** | |
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 | |
) | |
{ | |
RETURN_STATUS Status; | |
if (Result == NULL) { | |
return RETURN_INVALID_PARAMETER; | |
} | |
if (Operand >= 0) { | |
*Result = (CHAR8)Operand; | |
Status = RETURN_SUCCESS; | |
} else { | |
*Result = CHAR8_ERROR; | |
Status = RETURN_BUFFER_TOO_SMALL; | |
} | |
return Status; | |
} | |
/** | |
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 | |
) | |
{ | |
RETURN_STATUS Status; | |
if (Result == NULL) { | |
return RETURN_INVALID_PARAMETER; | |
} | |
if (Operand >= 0) { | |
*Result = (UINT16)Operand; | |
Status = RETURN_SUCCESS; | |
} else { | |
*Result = UINT16_ERROR; | |
Status = RETURN_BUFFER_TOO_SMALL; | |
} | |
return Status; | |
} | |
/** | |
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 | |
) | |
{ | |
RETURN_STATUS Status; | |
if (Result == NULL) { | |
return RETURN_INVALID_PARAMETER; | |
} | |
if (Operand >= 0) { | |
*Result = (UINT32)Operand; | |
Status = RETURN_SUCCESS; | |
} else { | |
*Result = UINT32_ERROR; | |
Status = RETURN_BUFFER_TOO_SMALL; | |
} | |
return Status; | |
} | |
/** | |
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 | |
) | |
{ | |
RETURN_STATUS Status; | |
if (Result == NULL) { | |
return RETURN_INVALID_PARAMETER; | |
} | |
if (Operand >= 0) { | |
*Result = (UINTN)Operand; | |
Status = RETURN_SUCCESS; | |
} else { | |
*Result = UINTN_ERROR; | |
Status = RETURN_BUFFER_TOO_SMALL; | |
} | |
return Status; | |
} | |
/** | |
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 | |
) | |
{ | |
RETURN_STATUS Status; | |
if (Result == NULL) { | |
return RETURN_INVALID_PARAMETER; | |
} | |
if (Operand >= 0) { | |
*Result = (UINT64)Operand; | |
Status = RETURN_SUCCESS; | |
} else { | |
*Result = UINT64_ERROR; | |
Status = RETURN_BUFFER_TOO_SMALL; | |
} | |
return Status; | |
} | |
/** | |
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 | |
) | |
{ | |
RETURN_STATUS Status; | |
if (Result == NULL) { | |
return RETURN_INVALID_PARAMETER; | |
} | |
if (Operand <= MAX_INT8) { | |
*Result = (INT8)Operand; | |
Status = RETURN_SUCCESS; | |
} else { | |
*Result = INT8_ERROR; | |
Status = RETURN_BUFFER_TOO_SMALL; | |
} | |
return Status; | |
} | |
/** | |
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 | |
) | |
{ | |
RETURN_STATUS Status; | |
if (Result == NULL) { | |
return RETURN_INVALID_PARAMETER; | |
} | |
if (Operand <= MAX_INT8) { | |
*Result = (CHAR8)Operand; | |
Status = RETURN_SUCCESS; | |
} else { | |
*Result = CHAR8_ERROR; | |
Status = RETURN_BUFFER_TOO_SMALL; | |
} | |
return Status; | |
} | |
/** | |
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 | |
) | |
{ | |
RETURN_STATUS Status; | |
if (Result == NULL) { | |
return RETURN_INVALID_PARAMETER; | |
} | |
if ((Operand >= MIN_INT8) && (Operand <= MAX_INT8)) { | |
*Result = (INT8)Operand; | |
Status = RETURN_SUCCESS; | |
} else { | |
*Result = INT8_ERROR; | |
Status = RETURN_BUFFER_TOO_SMALL; | |
} | |
return Status; | |
} | |
/** | |
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 | |
) | |
{ | |
RETURN_STATUS Status; | |
if (Result == NULL) { | |
return RETURN_INVALID_PARAMETER; | |
} | |
if ((Operand >= 0) && (Operand <= MAX_INT8)) { | |
*Result = (CHAR8)Operand; | |
Status = RETURN_SUCCESS; | |
} else { | |
*Result = CHAR8_ERROR; | |
Status = RETURN_BUFFER_TOO_SMALL; | |
} | |
return Status; | |
} | |
/** | |
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 | |
) | |
{ | |
RETURN_STATUS Status; | |
if (Result == NULL) { | |
return RETURN_INVALID_PARAMETER; | |
} | |
if ((Operand >= 0) && (Operand <= MAX_UINT8)) { | |
*Result = (UINT8)Operand; | |
Status = RETURN_SUCCESS; | |
} else { | |
*Result = UINT8_ERROR; | |
Status = RETURN_BUFFER_TOO_SMALL; | |
} | |
return Status; | |
} | |
/** | |
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 | |
) | |
{ | |
RETURN_STATUS Status; | |
if (Result == NULL) { | |
return RETURN_INVALID_PARAMETER; | |
} | |
if (Operand >= 0) { | |
*Result = (UINT16)Operand; | |
Status = RETURN_SUCCESS; | |
} else { | |
*Result = UINT16_ERROR; | |
Status = RETURN_BUFFER_TOO_SMALL; | |
} | |
return Status; | |
} | |
/** | |
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 | |
) | |
{ | |
RETURN_STATUS Status; | |
if (Result == NULL) { | |
return RETURN_INVALID_PARAMETER; | |
} | |
if (Operand >= 0) { | |
*Result = (UINT32)Operand; | |
Status = RETURN_SUCCESS; | |
} else { | |
*Result = UINT32_ERROR; | |
Status = RETURN_BUFFER_TOO_SMALL; | |
} | |
return Status; | |
} | |
/** | |
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 | |
) | |
{ | |
RETURN_STATUS Status; | |
if (Result == NULL) { | |
return RETURN_INVALID_PARAMETER; | |
} | |
if (Operand >= 0) { | |
*Result = (UINTN)Operand; | |
Status = RETURN_SUCCESS; | |
} else { | |
*Result = UINTN_ERROR; | |
Status = RETURN_BUFFER_TOO_SMALL; | |
} | |
return Status; | |
} | |
/** | |
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 | |
) | |
{ | |
RETURN_STATUS Status; | |
if (Result == NULL) { | |
return RETURN_INVALID_PARAMETER; | |
} | |
if (Operand >= 0) { | |
*Result = (UINT64)Operand; | |
Status = RETURN_SUCCESS; | |
} else { | |
*Result = UINT64_ERROR; | |
Status = RETURN_BUFFER_TOO_SMALL; | |
} | |
return Status; | |
} | |
/** | |
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 | |
) | |
{ | |
RETURN_STATUS Status; | |
if (Result == NULL) { | |
return RETURN_INVALID_PARAMETER; | |
} | |
if (Operand <= MAX_INT8) { | |
*Result = (INT8)Operand; | |
Status = RETURN_SUCCESS; | |
} else { | |
*Result = INT8_ERROR; | |
Status = RETURN_BUFFER_TOO_SMALL; | |
} | |
return Status; | |
} | |
/** | |
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 | |
) | |
{ | |
RETURN_STATUS Status; | |
if (Result == NULL) { | |
return RETURN_INVALID_PARAMETER; | |
} | |
if (Operand <= MAX_INT8) { | |
*Result = (INT8)Operand; | |
Status = RETURN_SUCCESS; | |
} else { | |
*Result = CHAR8_ERROR; | |
Status = RETURN_BUFFER_TOO_SMALL; | |
} | |
return Status; | |
} | |
/** | |
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 | |
) | |
{ | |
RETURN_STATUS Status; | |
if (Result == NULL) { | |
return RETURN_INVALID_PARAMETER; | |
} | |
if (Operand <= MAX_UINT8) { | |
*Result = (UINT8)Operand; | |
Status = RETURN_SUCCESS; | |
} else { | |
*Result = UINT8_ERROR; | |
Status = RETURN_BUFFER_TOO_SMALL; | |
} | |
return Status; | |
} | |
/** | |
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 | |
) | |
{ | |
RETURN_STATUS Status; | |
if (Result == NULL) { | |
return RETURN_INVALID_PARAMETER; | |
} | |
if (Operand <= MAX_INT16) { | |
*Result = (INT16)Operand; | |
Status = RETURN_SUCCESS; | |
} else { | |
*Result = INT16_ERROR; | |
Status = RETURN_BUFFER_TOO_SMALL; | |
} | |
return Status; | |
} | |
/** | |
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 | |
) | |
{ | |
RETURN_STATUS Status; | |
if (Result == NULL) { | |
return RETURN_INVALID_PARAMETER; | |
} | |
if ((Operand >= MIN_INT8) && (Operand <= MAX_INT8)) { | |
*Result = (INT8)Operand; | |
Status = RETURN_SUCCESS; | |
} else { | |
*Result = INT8_ERROR; | |
Status = RETURN_BUFFER_TOO_SMALL; | |
} | |
return Status; | |
} | |
/** | |
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 | |
) | |
{ | |
RETURN_STATUS Status; | |
if (Result == NULL) { | |
return RETURN_INVALID_PARAMETER; | |
} | |
if ((Operand >= 0) && (Operand <= MAX_INT8)) { | |
*Result = (CHAR8)Operand; | |
Status = RETURN_SUCCESS; | |
} else { | |
*Result = CHAR8_ERROR; | |
Status = RETURN_BUFFER_TOO_SMALL; | |
} | |
return Status; | |
} | |
/** | |
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 | |
) | |
{ | |
RETURN_STATUS Status; | |
if (Result == NULL) { | |
return RETURN_INVALID_PARAMETER; | |
} | |
if ((Operand >= 0) && (Operand <= MAX_UINT8)) { | |
*Result = (UINT8)Operand; | |
Status = RETURN_SUCCESS; | |
} else { | |
*Result = UINT8_ERROR; | |
Status = RETURN_BUFFER_TOO_SMALL; | |
} | |
return Status; | |
} | |
/** | |
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 | |
) | |
{ | |
RETURN_STATUS Status; | |
if (Result == NULL) { | |
return RETURN_INVALID_PARAMETER; | |
} | |
if ((Operand >= MIN_INT16) && (Operand <= MAX_INT16)) { | |
*Result = (INT16)Operand; | |
Status = RETURN_SUCCESS; | |
} else { | |
*Result = INT16_ERROR; | |
Status = RETURN_BUFFER_TOO_SMALL; | |
} | |
return Status; | |
} | |
/** | |
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 | |
) | |
{ | |
RETURN_STATUS Status; | |
if (Result == NULL) { | |
return RETURN_INVALID_PARAMETER; | |
} | |
if ((Operand >= 0) && (Operand <= MAX_UINT16)) { | |
*Result = (UINT16)Operand; | |
Status = RETURN_SUCCESS; | |
} else { | |
*Result = UINT16_ERROR; | |
Status = RETURN_BUFFER_TOO_SMALL; | |
} | |
return Status; | |
} | |
/** | |
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 | |
) | |
{ | |
RETURN_STATUS Status; | |
if (Result == NULL) { | |
return RETURN_INVALID_PARAMETER; | |
} | |
if (Operand >= 0) { | |
*Result = (UINT32)Operand; | |
Status = RETURN_SUCCESS; | |
} else { | |
*Result = UINT32_ERROR; | |
Status = RETURN_BUFFER_TOO_SMALL; | |
} | |
return Status; | |
} | |
/** | |
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 | |
) | |
{ | |
RETURN_STATUS Status; | |
if (Result == NULL) { | |
return RETURN_INVALID_PARAMETER; | |
} | |
if (Operand >= 0) { | |
*Result = (UINT64)Operand; | |
Status = RETURN_SUCCESS; | |
} else { | |
*Result = UINT64_ERROR; | |
Status = RETURN_BUFFER_TOO_SMALL; | |
} | |
return Status; | |
} | |
/** | |
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 | |
) | |
{ | |
RETURN_STATUS Status; | |
if (Result == NULL) { | |
return RETURN_INVALID_PARAMETER; | |
} | |
if (Operand <= MAX_INT8) { | |
*Result = (INT8)Operand; | |
Status = RETURN_SUCCESS; | |
} else { | |
*Result = INT8_ERROR; | |
Status = RETURN_BUFFER_TOO_SMALL; | |
} | |
return Status; | |
} | |
/** | |
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 | |
) | |
{ | |
RETURN_STATUS Status; | |
if (Result == NULL) { | |
return RETURN_INVALID_PARAMETER; | |
} | |
if (Operand <= MAX_INT8) { | |
*Result = (INT8)Operand; | |
Status = RETURN_SUCCESS; | |
} else { | |
*Result = CHAR8_ERROR; | |
Status = RETURN_BUFFER_TOO_SMALL; | |
} | |
return Status; | |
} | |
/** | |
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 | |
) | |
{ | |
RETURN_STATUS Status; | |
if (Result == NULL) { | |
return RETURN_INVALID_PARAMETER; | |
} | |
if (Operand <= MAX_UINT8) { | |
*Result = (UINT8)Operand; | |
Status = RETURN_SUCCESS; | |
} else { | |
*Result = UINT8_ERROR; | |
Status = RETURN_BUFFER_TOO_SMALL; | |
} | |
return Status; | |
} | |
/** | |
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 | |
) | |
{ | |
RETURN_STATUS Status; | |
if (Result == NULL) { | |
return RETURN_INVALID_PARAMETER; | |
} | |
if (Operand <= MAX_INT16) { | |
*Result = (INT16)Operand; | |
Status = RETURN_SUCCESS; | |
} else { | |
*Result = INT16_ERROR; | |
Status = RETURN_BUFFER_TOO_SMALL; | |
} | |
return Status; | |
} | |
/** | |
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 | |
) | |
{ | |
RETURN_STATUS Status; | |
if (Result == NULL) { | |
return RETURN_INVALID_PARAMETER; | |
} | |
if (Operand <= MAX_UINT16) { | |
*Result = (UINT16)Operand; | |
Status = RETURN_SUCCESS; | |
} else { | |
*Result = UINT16_ERROR; | |
Status = RETURN_BUFFER_TOO_SMALL; | |
} | |
return Status; | |
} | |
/** | |
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 | |
) | |
{ | |
RETURN_STATUS Status; | |
if (Result == NULL) { | |
return RETURN_INVALID_PARAMETER; | |
} | |
if (Operand <= MAX_INT32) { | |
*Result = (INT32)Operand; | |
Status = RETURN_SUCCESS; | |
} else { | |
*Result = INT32_ERROR; | |
Status = RETURN_BUFFER_TOO_SMALL; | |
} | |
return Status; | |
} | |
/** | |
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 | |
) | |
{ | |
RETURN_STATUS Status; | |
if (Result == NULL) { | |
return RETURN_INVALID_PARAMETER; | |
} | |
if ((Operand >= MIN_INT8) && (Operand <= MAX_INT8)) { | |
*Result = (INT8)Operand; | |
Status = RETURN_SUCCESS; | |
} else { | |
*Result = INT8_ERROR; | |
Status = RETURN_BUFFER_TOO_SMALL; | |
} | |
return Status; | |
} | |
/** | |
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 | |
) | |
{ | |
RETURN_STATUS Status; | |
if (Result == NULL) { | |
return RETURN_INVALID_PARAMETER; | |
} | |
if ((Operand >= 0) && (Operand <= MAX_INT8)) { | |
*Result = (CHAR8)Operand; | |
Status = RETURN_SUCCESS; | |
} else { | |
*Result = CHAR8_ERROR; | |
Status = RETURN_BUFFER_TOO_SMALL; | |
} | |
return Status; | |
} | |
/** | |
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 | |
) | |
{ | |
RETURN_STATUS Status; | |
if (Result == NULL) { | |
return RETURN_INVALID_PARAMETER; | |
} | |
if ((Operand >= 0) && (Operand <= MAX_UINT8)) { | |
*Result = (UINT8)Operand; | |
Status = RETURN_SUCCESS; | |
} else { | |
*Result = UINT8_ERROR; | |
Status = RETURN_BUFFER_TOO_SMALL; | |
} | |
return Status; | |
} | |
/** | |
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 | |
) | |
{ | |
RETURN_STATUS Status; | |
if (Result == NULL) { | |
return RETURN_INVALID_PARAMETER; | |
} | |
if ((Operand >= MIN_INT16) && (Operand <= MAX_INT16)) { | |
*Result = (INT16)Operand; | |
Status = RETURN_SUCCESS; | |
} else { | |
*Result = INT16_ERROR; | |
Status = RETURN_BUFFER_TOO_SMALL; | |
} | |
return Status; | |
} | |
/** | |
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 | |
) | |
{ | |
RETURN_STATUS Status; | |
if (Result == NULL) { | |
return RETURN_INVALID_PARAMETER; | |
} | |
if ((Operand >= 0) && (Operand <= MAX_UINT16)) { | |
*Result = (UINT16)Operand; | |
Status = RETURN_SUCCESS; | |
} else { | |
*Result = UINT16_ERROR; | |
Status = RETURN_BUFFER_TOO_SMALL; | |
} | |
return Status; | |
} | |
/** | |
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 | |
) | |
{ | |
RETURN_STATUS Status; | |
if (Result == NULL) { | |
return RETURN_INVALID_PARAMETER; | |
} | |
if (Operand >= 0) { | |
*Result = (UINTN)Operand; | |
Status = RETURN_SUCCESS; | |
} else { | |
*Result = UINTN_ERROR; | |
Status = RETURN_BUFFER_TOO_SMALL; | |
} | |
return Status; | |
} | |
/** | |
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 | |
) | |
{ | |
RETURN_STATUS Status; | |
if (Result == NULL) { | |
return RETURN_INVALID_PARAMETER; | |
} | |
if (Operand >= 0) { | |
*Result = (UINT64)Operand; | |
Status = RETURN_SUCCESS; | |
} else { | |
*Result = UINT64_ERROR; | |
Status = RETURN_BUFFER_TOO_SMALL; | |
} | |
return Status; | |
} | |
/** | |
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 | |
) | |
{ | |
RETURN_STATUS Status; | |
if (Result == NULL) { | |
return RETURN_INVALID_PARAMETER; | |
} | |
if (Operand <= MAX_INT8) { | |
*Result = (INT8)Operand; | |
Status = RETURN_SUCCESS; | |
} else { | |
*Result = INT8_ERROR; | |
Status = RETURN_BUFFER_TOO_SMALL; | |
} | |
return Status; | |
} | |
/** | |
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 | |
) | |
{ | |
RETURN_STATUS Status; | |
if (Result == NULL) { | |
return RETURN_INVALID_PARAMETER; | |
} | |
if (Operand <= MAX_INT8) { | |
*Result = (INT8)Operand; | |
Status = RETURN_SUCCESS; | |
} else { | |
*Result = CHAR8_ERROR; | |
Status = RETURN_BUFFER_TOO_SMALL; | |
} | |
return Status; | |
} | |
/** | |
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 | |
) | |
{ | |
RETURN_STATUS Status; | |
if (Result == NULL) { | |
return RETURN_INVALID_PARAMETER; | |
} | |
if (Operand <= MAX_UINT8) { | |
*Result = (UINT8)Operand; | |
Status = RETURN_SUCCESS; | |
} else { | |
*Result = UINT8_ERROR; | |
Status = RETURN_BUFFER_TOO_SMALL; | |
} | |
return Status; | |
} | |
/** | |
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 | |
) | |
{ | |
RETURN_STATUS Status; | |
if (Result == NULL) { | |
return RETURN_INVALID_PARAMETER; | |
} | |
if (Operand <= MAX_INT16) { | |
*Result = (INT16)Operand; | |
Status = RETURN_SUCCESS; | |
} else { | |
*Result = INT16_ERROR; | |
Status = RETURN_BUFFER_TOO_SMALL; | |
} | |
return Status; | |
} | |
/** | |
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 | |
) | |
{ | |
RETURN_STATUS Status; | |
if (Result == NULL) { | |
return RETURN_INVALID_PARAMETER; | |
} | |
if (Operand <= MAX_UINT16) { | |
*Result = (UINT16)Operand; | |
Status = RETURN_SUCCESS; | |
} else { | |
*Result = UINT16_ERROR; | |
Status = RETURN_BUFFER_TOO_SMALL; | |
} | |
return Status; | |
} | |
/** | |
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 | |
) | |
{ | |
RETURN_STATUS Status; | |
if (Result == NULL) { | |
return RETURN_INVALID_PARAMETER; | |
} | |
if (Operand <= MAX_INT32) { | |
*Result = (INT32)Operand; | |
Status = RETURN_SUCCESS; | |
} else { | |
*Result = INT32_ERROR; | |
Status = RETURN_BUFFER_TOO_SMALL; | |
} | |
return Status; | |
} | |
/** | |
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 | |
) | |
{ | |
RETURN_STATUS Status; | |
if (Result == NULL) { | |
return RETURN_INVALID_PARAMETER; | |
} | |
if (Operand <= MAX_INTN) { | |
*Result = (INTN)Operand; | |
Status = RETURN_SUCCESS; | |
} else { | |
*Result = INTN_ERROR; | |
Status = RETURN_BUFFER_TOO_SMALL; | |
} | |
return Status; | |
} | |
/** | |
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 | |
) | |
{ | |
RETURN_STATUS Status; | |
if (Result == NULL) { | |
return RETURN_INVALID_PARAMETER; | |
} | |
if ((Operand >= MIN_INT8) && (Operand <= MAX_INT8)) { | |
*Result = (INT8)Operand; | |
Status = RETURN_SUCCESS; | |
} else { | |
*Result = INT8_ERROR; | |
Status = RETURN_BUFFER_TOO_SMALL; | |
} | |
return Status; | |
} | |
/** | |
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 | |
) | |
{ | |
RETURN_STATUS Status; | |
if (Result == NULL) { | |
return RETURN_INVALID_PARAMETER; | |
} | |
if ((Operand >= 0) && (Operand <= MAX_INT8)) { | |
*Result = (CHAR8)Operand; | |
Status = RETURN_SUCCESS; | |
} else { | |
*Result = CHAR8_ERROR; | |
Status = RETURN_BUFFER_TOO_SMALL; | |
} | |
return Status; | |
} | |
/** | |
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 | |
) | |
{ | |
RETURN_STATUS Status; | |
if (Result == NULL) { | |
return RETURN_INVALID_PARAMETER; | |
} | |
if ((Operand >= 0) && (Operand <= MAX_UINT8)) { | |
*Result = (UINT8)Operand; | |
Status = RETURN_SUCCESS; | |
} else { | |
*Result = UINT8_ERROR; | |
Status = RETURN_BUFFER_TOO_SMALL; | |
} | |
return Status; | |
} | |
/** | |
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 | |
) | |
{ | |
RETURN_STATUS Status; | |
if (Result == NULL) { | |
return RETURN_INVALID_PARAMETER; | |
} | |
if ((Operand >= MIN_INT16) && (Operand <= MAX_INT16)) { | |
*Result = (INT16)Operand; | |
Status = RETURN_SUCCESS; | |
} else { | |
*Result = INT16_ERROR; | |
Status = RETURN_BUFFER_TOO_SMALL; | |
} | |
return Status; | |
} | |
/** | |
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 | |
) | |
{ | |
RETURN_STATUS Status; | |
if (Result == NULL) { | |
return RETURN_INVALID_PARAMETER; | |
} | |
if ((Operand >= 0) && (Operand <= MAX_UINT16)) { | |
*Result = (UINT16)Operand; | |
Status = RETURN_SUCCESS; | |
} else { | |
*Result = UINT16_ERROR; | |
Status = RETURN_BUFFER_TOO_SMALL; | |
} | |
return Status; | |
} | |
/** | |
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 | |
) | |
{ | |
RETURN_STATUS Status; | |
if (Result == NULL) { | |
return RETURN_INVALID_PARAMETER; | |
} | |
if ((Operand >= MIN_INT32) && (Operand <= MAX_INT32)) { | |
*Result = (INT32)Operand; | |
Status = RETURN_SUCCESS; | |
} else { | |
*Result = INT32_ERROR; | |
Status = RETURN_BUFFER_TOO_SMALL; | |
} | |
return Status; | |
} | |
/** | |
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 | |
) | |
{ | |
RETURN_STATUS Status; | |
if (Result == NULL) { | |
return RETURN_INVALID_PARAMETER; | |
} | |
if ((Operand >= 0) && (Operand <= MAX_UINT32)) { | |
*Result = (UINT32)Operand; | |
Status = RETURN_SUCCESS; | |
} else { | |
*Result = UINT32_ERROR; | |
Status = RETURN_BUFFER_TOO_SMALL; | |
} | |
return Status; | |
} | |
/** | |
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 | |
) | |
{ | |
RETURN_STATUS Status; | |
if (Result == NULL) { | |
return RETURN_INVALID_PARAMETER; | |
} | |
if (Operand >= 0) { | |
*Result = (UINT64)Operand; | |
Status = RETURN_SUCCESS; | |
} else { | |
*Result = UINT64_ERROR; | |
Status = RETURN_BUFFER_TOO_SMALL; | |
} | |
return Status; | |
} | |
/** | |
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 | |
) | |
{ | |
RETURN_STATUS Status; | |
if (Result == NULL) { | |
return RETURN_INVALID_PARAMETER; | |
} | |
if (Operand <= MAX_INT8) { | |
*Result = (INT8)Operand; | |
Status = RETURN_SUCCESS; | |
} else { | |
*Result = INT8_ERROR; | |
Status = RETURN_BUFFER_TOO_SMALL; | |
} | |
return Status; | |
} | |
/** | |
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 | |
) | |
{ | |
RETURN_STATUS Status; | |
if (Result == NULL) { | |
return RETURN_INVALID_PARAMETER; | |
} | |
if (Operand <= MAX_INT8) { | |
*Result = (INT8)Operand; | |
Status = RETURN_SUCCESS; | |
} else { | |
*Result = CHAR8_ERROR; | |
Status = RETURN_BUFFER_TOO_SMALL; | |
} | |
return Status; | |
} | |
/** | |
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 | |
) | |
{ | |
RETURN_STATUS Status; | |
if (Result == NULL) { | |
return RETURN_INVALID_PARAMETER; | |
} | |
if (Operand <= MAX_UINT8) { | |
*Result = (UINT8)Operand; | |
Status = RETURN_SUCCESS; | |
} else { | |
*Result = UINT8_ERROR; | |
Status = RETURN_BUFFER_TOO_SMALL; | |
} | |
return Status; | |
} | |
/** | |
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 | |
) | |
{ | |
RETURN_STATUS Status; | |
if (Result == NULL) { | |
return RETURN_INVALID_PARAMETER; | |
} | |
if (Operand <= MAX_INT16) { | |
*Result = (INT16)Operand; | |
Status = RETURN_SUCCESS; | |
} else { | |
*Result = INT16_ERROR; | |
Status = RETURN_BUFFER_TOO_SMALL; | |
} | |
return Status; | |
} | |
/** | |
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 | |
) | |
{ | |
RETURN_STATUS Status; | |
if (Result == NULL) { | |
return RETURN_INVALID_PARAMETER; | |
} | |
if (Operand <= MAX_UINT16) { | |
*Result = (UINT16)Operand; | |
Status = RETURN_SUCCESS; | |
} else { | |
*Result = UINT16_ERROR; | |
Status = RETURN_BUFFER_TOO_SMALL; | |
} | |
return Status; | |
} | |
/** | |
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 | |
) | |
{ | |
RETURN_STATUS Status; | |
if (Result == NULL) { | |
return RETURN_INVALID_PARAMETER; | |
} | |
if (Operand <= MAX_INT32) { | |
*Result = (INT32)Operand; | |
Status = RETURN_SUCCESS; | |
} else { | |
*Result = INT32_ERROR; | |
Status = RETURN_BUFFER_TOO_SMALL; | |
} | |
return Status; | |
} | |
/** | |
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 | |
) | |
{ | |
RETURN_STATUS Status; | |
if (Result == NULL) { | |
return RETURN_INVALID_PARAMETER; | |
} | |
if (Operand <= MAX_UINT32) { | |
*Result = (UINT32)Operand; | |
Status = RETURN_SUCCESS; | |
} else { | |
*Result = UINT32_ERROR; | |
Status = RETURN_BUFFER_TOO_SMALL; | |
} | |
return Status; | |
} | |
/** | |
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 | |
) | |
{ | |
RETURN_STATUS Status; | |
if (Result == NULL) { | |
return RETURN_INVALID_PARAMETER; | |
} | |
if (Operand <= MAX_INTN) { | |
*Result = (INTN)Operand; | |
Status = RETURN_SUCCESS; | |
} else { | |
*Result = INTN_ERROR; | |
Status = RETURN_BUFFER_TOO_SMALL; | |
} | |
return Status; | |
} | |
/** | |
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 | |
) | |
{ | |
RETURN_STATUS Status; | |
if (Result == NULL) { | |
return RETURN_INVALID_PARAMETER; | |
} | |
if (Operand <= MAX_INT64) { | |
*Result = (INT64)Operand; | |
Status = RETURN_SUCCESS; | |
} else { | |
*Result = INT64_ERROR; | |
Status = RETURN_BUFFER_TOO_SMALL; | |
} | |
return Status; | |
} | |
// | |
// 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 | |
) | |
{ | |
RETURN_STATUS Status; | |
if (Result == NULL) { | |
return RETURN_INVALID_PARAMETER; | |
} | |
if (((UINT8)(Augend + Addend)) >= Augend) { | |
*Result = (UINT8)(Augend + Addend); | |
Status = RETURN_SUCCESS; | |
} else { | |
*Result = UINT8_ERROR; | |
Status = RETURN_BUFFER_TOO_SMALL; | |
} | |
return Status; | |
} | |
/** | |
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 | |
) | |
{ | |
RETURN_STATUS Status; | |
if (Result == NULL) { | |
return RETURN_INVALID_PARAMETER; | |
} | |
if (((UINT16)(Augend + Addend)) >= Augend) { | |
*Result = (UINT16)(Augend + Addend); | |
Status = RETURN_SUCCESS; | |
} else { | |
*Result = UINT16_ERROR; | |
Status = RETURN_BUFFER_TOO_SMALL; | |
} | |
return Status; | |
} | |
/** | |
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 | |
) | |
{ | |
RETURN_STATUS Status; | |
if (Result == NULL) { | |
return RETURN_INVALID_PARAMETER; | |
} | |
if ((Augend + Addend) >= Augend) { | |
*Result = (Augend + Addend); | |
Status = RETURN_SUCCESS; | |
} else { | |
*Result = UINT32_ERROR; | |
Status = RETURN_BUFFER_TOO_SMALL; | |
} | |
return Status; | |
} | |
/** | |
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 | |
) | |
{ | |
RETURN_STATUS Status; | |
if (Result == NULL) { | |
return RETURN_INVALID_PARAMETER; | |
} | |
if ((Augend + Addend) >= Augend) { | |
*Result = (Augend + Addend); | |
Status = RETURN_SUCCESS; | |
} else { | |
*Result = UINT64_ERROR; | |
Status = RETURN_BUFFER_TOO_SMALL; | |
} | |
return Status; | |
} | |
// | |
// 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 | |
) | |
{ | |
RETURN_STATUS Status; | |
if (Result == NULL) { | |
return RETURN_INVALID_PARAMETER; | |
} | |
if (Minuend >= Subtrahend) { | |
*Result = (UINT8)(Minuend - Subtrahend); | |
Status = RETURN_SUCCESS; | |
} else { | |
*Result = UINT8_ERROR; | |
Status = RETURN_BUFFER_TOO_SMALL; | |
} | |
return Status; | |
} | |
/** | |
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 | |
) | |
{ | |
RETURN_STATUS Status; | |
if (Result == NULL) { | |
return RETURN_INVALID_PARAMETER; | |
} | |
if (Minuend >= Subtrahend) { | |
*Result = (UINT16)(Minuend - Subtrahend); | |
Status = RETURN_SUCCESS; | |
} else { | |
*Result = UINT16_ERROR; | |
Status = RETURN_BUFFER_TOO_SMALL; | |
} | |
return Status; | |
} | |
/** | |
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 | |
) | |
{ | |
RETURN_STATUS Status; | |
if (Result == NULL) { | |
return RETURN_INVALID_PARAMETER; | |
} | |
if (Minuend >= Subtrahend) { | |
*Result = (Minuend - Subtrahend); | |
Status = RETURN_SUCCESS; | |
} else { | |
*Result = UINT32_ERROR; | |
Status = RETURN_BUFFER_TOO_SMALL; | |
} | |
return Status; | |
} | |
/** | |
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 | |
) | |
{ | |
RETURN_STATUS Status; | |
if (Result == NULL) { | |
return RETURN_INVALID_PARAMETER; | |
} | |
if (Minuend >= Subtrahend) { | |
*Result = (Minuend - Subtrahend); | |
Status = RETURN_SUCCESS; | |
} else { | |
*Result = UINT64_ERROR; | |
Status = RETURN_BUFFER_TOO_SMALL; | |
} | |
return Status; | |
} | |
// | |
// 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 | |
) | |
{ | |
UINT32 IntermediateResult; | |
IntermediateResult = ((UINT32)Multiplicand) *((UINT32)Multiplier); | |
return SafeUint32ToUint8 (IntermediateResult, 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 IntermediateResult; | |
IntermediateResult = ((UINT32)Multiplicand) *((UINT32)Multiplier); | |
return SafeUint32ToUint16 (IntermediateResult, 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 | |
) | |
{ | |
UINT64 IntermediateResult; | |
IntermediateResult = ((UINT64) Multiplicand) *((UINT64) Multiplier); | |
return SafeUint64ToUint32 (IntermediateResult, 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 | |
) | |
{ | |
RETURN_STATUS Status; | |
UINT32 DwordA; | |
UINT32 DwordB; | |
UINT32 DwordC; | |
UINT32 DwordD; | |
UINT64 ProductAD; | |
UINT64 ProductBC; | |
UINT64 ProductBD; | |
UINT64 UnsignedResult; | |
if (Result == NULL) { | |
return RETURN_INVALID_PARAMETER; | |
} | |
ProductAD = 0; | |
ProductBC = 0; | |
ProductBD = 0; | |
UnsignedResult = 0; | |
Status = RETURN_BUFFER_TOO_SMALL; | |
// | |
// 64x64 into 128 is like 32.32 x 32.32. | |
// | |
// a.b * c.d = a*(c.d) + .b*(c.d) = a*c + a*.d + .b*c + .b*.d | |
// back in non-decimal notation where A=a*2^32 and C=c*2^32: | |
// A*C + A*d + b*C + b*d | |
// So there are four components to add together. | |
// result = (a*c*2^64) + (a*d*2^32) + (b*c*2^32) + (b*d) | |
// | |
// a * c must be 0 or there would be bits in the high 64-bits | |
// a * d must be less than 2^32 or there would be bits in the high 64-bits | |
// b * c must be less than 2^32 or there would be bits in the high 64-bits | |
// then there must be no overflow of the resulting values summed up. | |
// | |
DwordA = (UINT32)RShiftU64 (Multiplicand, 32); | |
DwordC = (UINT32)RShiftU64 (Multiplier, 32); | |
// | |
// common case -- if high dwords are both zero, no chance for overflow | |
// | |
if ((DwordA == 0) && (DwordC == 0)) { | |
DwordB = (UINT32)Multiplicand; | |
DwordD = (UINT32)Multiplier; | |
*Result = (((UINT64)DwordB) *(UINT64)DwordD); | |
Status = RETURN_SUCCESS; | |
} else { | |
// | |
// a * c must be 0 or there would be bits set in the high 64-bits | |
// | |
if ((DwordA == 0) || | |
(DwordC == 0)) { | |
DwordD = (UINT32)Multiplier; | |
// | |
// a * d must be less than 2^32 or there would be bits set in the high 64-bits | |
// | |
ProductAD = (((UINT64)DwordA) *(UINT64)DwordD); | |
if ((ProductAD & 0xffffffff00000000) == 0) { | |
DwordB = (UINT32)Multiplicand; | |
// | |
// b * c must be less than 2^32 or there would be bits set in the high 64-bits | |
// | |
ProductBC = (((UINT64)DwordB) *(UINT64)DwordC); | |
if ((ProductBC & 0xffffffff00000000) == 0) { | |
// | |
// now sum them all up checking for overflow. | |
// shifting is safe because we already checked for overflow above | |
// | |
if (!RETURN_ERROR (SafeUint64Add (LShiftU64 (ProductBC, 32), LShiftU64 (ProductAD, 32), &UnsignedResult))) { | |
// | |
// b * d | |
// | |
ProductBD = (((UINT64)DwordB) *(UINT64)DwordD); | |
if (!RETURN_ERROR (SafeUint64Add (UnsignedResult, ProductBD, &UnsignedResult))) { | |
*Result = UnsignedResult; | |
Status = RETURN_SUCCESS; | |
} | |
} | |
} | |
} | |
} | |
} | |
if (RETURN_ERROR (Status)) { | |
*Result = UINT64_ERROR; | |
} | |
return Status; | |
} | |
// | |
// 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 | |
) | |
{ | |
return SafeInt32ToInt8 (((INT32)Augend) + ((INT32)Addend), 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 | |
) | |
{ | |
INT32 Augend32; | |
INT32 Addend32; | |
if (Result == NULL) { | |
return RETURN_INVALID_PARAMETER; | |
} | |
Augend32 = (INT32)Augend; | |
Addend32 = (INT32)Addend; | |
if (Augend32 < 0 || Augend32 > MAX_INT8) { | |
*Result = CHAR8_ERROR; | |
return RETURN_BUFFER_TOO_SMALL; | |
} | |
if (Addend32 < 0 || Addend32 > MAX_INT8) { | |
*Result = CHAR8_ERROR; | |
return RETURN_BUFFER_TOO_SMALL; | |
} | |
return SafeInt32ToChar8 (Augend32 + Addend32, 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 | |
) | |
{ | |
return SafeInt32ToInt16 (((INT32)Augend) + ((INT32)Addend), 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 | |
) | |
{ | |
return SafeInt64ToInt32 (((INT64)Augend) + ((INT64)Addend), 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 | |
) | |
{ | |
RETURN_STATUS Status; | |
if (Result == NULL) { | |
return RETURN_INVALID_PARAMETER; | |
} | |
// | |
// * An Addend of zero can never cause underflow or overflow. | |
// | |
// * A positive Addend can only cause overflow. The overflow condition is | |
// | |
// (Augend + Addend) > MAX_INT64 | |
// | |
// Subtracting Addend from both sides yields | |
// | |
// Augend > (MAX_INT64 - Addend) | |
// | |
// This condition can be coded directly in C because the RHS will neither | |
// underflow nor overflow. That is due to the starting condition: | |
// | |
// 0 < Addend <= MAX_INT64 | |
// | |
// Multiplying all three sides by (-1) yields | |
// | |
// 0 > (-Addend) >= (-MAX_INT64) | |
// | |
// Adding MAX_INT64 to all three sides yields | |
// | |
// MAX_INT64 > (MAX_INT64 - Addend) >= 0 | |
// | |
// * A negative Addend can only cause underflow. The underflow condition is | |
// | |
// (Augend + Addend) < MIN_INT64 | |
// | |
// Subtracting Addend from both sides yields | |
// | |
// Augend < (MIN_INT64 - Addend) | |
// | |
// This condition can be coded directly in C because the RHS will neither | |
// underflow nor overflow. That is due to the starting condition: | |
// | |
// MIN_INT64 <= Addend < 0 | |
// | |
// Multiplying all three sides by (-1) yields | |
// | |
// (-MIN_INT64) >= (-Addend) > 0 | |
// | |
// Adding MIN_INT64 to all three sides yields | |
// | |
// 0 >= (MIN_INT64 - Addend) > MIN_INT64 | |
// | |
if (((Addend > 0) && (Augend > (MAX_INT64 - Addend))) || | |
((Addend < 0) && (Augend < (MIN_INT64 - Addend)))) { | |
*Result = INT64_ERROR; | |
Status = RETURN_BUFFER_TOO_SMALL; | |
} else { | |
*Result = Augend + Addend; | |
Status = RETURN_SUCCESS; | |
} | |
return Status; | |
} | |
// | |
// 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 | |
) | |
{ | |
return SafeInt32ToInt8 (((INT32)Minuend) - ((INT32)Subtrahend), 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 | |
) | |
{ | |
INT32 Minuend32; | |
INT32 Subtrahend32; | |
if (Result == NULL) { | |
return RETURN_INVALID_PARAMETER; | |
} | |
Minuend32 = (INT32)Minuend; | |
Subtrahend32 = (INT32)Subtrahend; | |
if (Minuend32 < 0 || Minuend32 > MAX_INT8) { | |
*Result = CHAR8_ERROR; | |
return RETURN_BUFFER_TOO_SMALL; | |
} | |
if (Subtrahend32 < 0 || Subtrahend32 > MAX_INT8) { | |
*Result = CHAR8_ERROR; | |
return RETURN_BUFFER_TOO_SMALL; | |
} | |
return SafeInt32ToChar8 (Minuend32 - Subtrahend32, 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 | |
) | |
{ | |
return SafeInt32ToInt16 (((INT32)Minuend) - ((INT32)Subtrahend), 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 | |
) | |
{ | |
return SafeInt64ToInt32 (((INT64)Minuend) - ((INT64)Subtrahend), 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 | |
) | |
{ | |
RETURN_STATUS Status; | |
if (Result == NULL) { | |
return RETURN_INVALID_PARAMETER; | |
} | |
// | |
// * A Subtrahend of zero can never cause underflow or overflow. | |
// | |
// * A positive Subtrahend can only cause underflow. The underflow condition | |
// is: | |
// | |
// (Minuend - Subtrahend) < MIN_INT64 | |
// | |
// Adding Subtrahend to both sides yields | |
// | |
// Minuend < (MIN_INT64 + Subtrahend) | |
// | |
// This condition can be coded directly in C because the RHS will neither | |
// underflow nor overflow. That is due to the starting condition: | |
// | |
// 0 < Subtrahend <= MAX_INT64 | |
// | |
// Adding MIN_INT64 to all three sides yields | |
// | |
// MIN_INT64 < (MIN_INT64 + Subtrahend) <= (MIN_INT64 + MAX_INT64) = -1 | |
// | |
// * A negative Subtrahend can only cause overflow. The overflow condition is | |
// | |
// (Minuend - Subtrahend) > MAX_INT64 | |
// | |
// Adding Subtrahend to both sides yields | |
// | |
// Minuend > (MAX_INT64 + Subtrahend) | |
// | |
// This condition can be coded directly in C because the RHS will neither | |
// underflow nor overflow. That is due to the starting condition: | |
// | |
// MIN_INT64 <= Subtrahend < 0 | |
// | |
// Adding MAX_INT64 to all three sides yields | |
// | |
// -1 = (MAX_INT64 + MIN_INT64) <= (MAX_INT64 + Subtrahend) < MAX_INT64 | |
// | |
if (((Subtrahend > 0) && (Minuend < (MIN_INT64 + Subtrahend))) || | |
((Subtrahend < 0) && (Minuend > (MAX_INT64 + Subtrahend)))) { | |
*Result = INT64_ERROR; | |
Status = RETURN_BUFFER_TOO_SMALL; | |
} else { | |
*Result = Minuend - Subtrahend; | |
Status = RETURN_SUCCESS; | |
} | |
return Status; | |
} | |
// | |
// 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 | |
) | |
{ | |
return SafeInt32ToInt8 (((INT32)Multiplier) *((INT32)Multiplicand), 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 | |
) | |
{ | |
INT32 Multiplicand32; | |
INT32 Multiplier32; | |
if (Result == NULL) { | |
return RETURN_INVALID_PARAMETER; | |
} | |
Multiplicand32 = (INT32)Multiplicand; | |
Multiplier32 = (INT32)Multiplier; | |
if (Multiplicand32 < 0 || Multiplicand32 > MAX_INT8) { | |
*Result = CHAR8_ERROR; | |
return RETURN_BUFFER_TOO_SMALL; | |
} | |
if (Multiplier32 < 0 || Multiplier32 > MAX_INT8) { | |
*Result = CHAR8_ERROR; | |
return RETURN_BUFFER_TOO_SMALL; | |
} | |
return SafeInt32ToChar8 (Multiplicand32 * Multiplier32, 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 | |
) | |
{ | |
return SafeInt32ToInt16 (((INT32)Multiplicand) *((INT32)Multiplier), 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 | |
) | |
{ | |
return SafeInt64ToInt32 (MultS64x64 (Multiplicand, Multiplier), 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 | |
) | |
{ | |
RETURN_STATUS Status; | |
UINT64 UnsignedMultiplicand; | |
UINT64 UnsignedMultiplier; | |
UINT64 UnsignedResult; | |
if (Result == NULL) { | |
return RETURN_INVALID_PARAMETER; | |
} | |
// | |
// Split into sign and magnitude, do unsigned operation, apply sign. | |
// | |
if (Multiplicand < 0) { | |
// | |
// Avoid negating the most negative number. | |
// | |
UnsignedMultiplicand = ((UINT64)(- (Multiplicand + 1))) + 1; | |
} else { | |
UnsignedMultiplicand = (UINT64)Multiplicand; | |
} | |
if (Multiplier < 0) { | |
// | |
// Avoid negating the most negative number. | |
// | |
UnsignedMultiplier = ((UINT64)(- (Multiplier + 1))) + 1; | |
} else { | |
UnsignedMultiplier = (UINT64)Multiplier; | |
} | |
Status = SafeUint64Mult (UnsignedMultiplicand, UnsignedMultiplier, &UnsignedResult); | |
if (!RETURN_ERROR (Status)) { | |
if ((Multiplicand < 0) != (Multiplier < 0)) { | |
if (UnsignedResult > MIN_INT64_MAGNITUDE) { | |
*Result = INT64_ERROR; | |
Status = RETURN_BUFFER_TOO_SMALL; | |
} else if (UnsignedResult == MIN_INT64_MAGNITUDE) { | |
*Result = MIN_INT64; | |
} else { | |
*Result = - ((INT64)UnsignedResult); | |
} | |
} else { | |
if (UnsignedResult > MAX_INT64) { | |
*Result = INT64_ERROR; | |
Status = RETURN_BUFFER_TOO_SMALL; | |
} else { | |
*Result = (INT64)UnsignedResult; | |
} | |
} | |
} else { | |
*Result = INT64_ERROR; | |
} | |
return Status; | |
} | |