utmath.c File Reference

#include "acpi.h"
#include "accommon.h"

Include dependency graph for utmath.c:

Go to the source code of this file.

Classes
struct	uint64_struct
union	uint64_overlay

Macros
#define	_COMPONENT   ACPI_UTILITIES

Typedefs
typedef struct uint64_struct	UINT64_STRUCT
typedef union uint64_overlay	UINT64_OVERLAY

Functions
ACPI_STATUS	AcpiUtShortMultiply (UINT64 Multiplicand, UINT32 Multiplier, UINT64 *OutProduct)
ACPI_STATUS	AcpiUtShortShiftLeft (UINT64 Operand, UINT32 Count, UINT64 *OutResult)
ACPI_STATUS	AcpiUtShortShiftRight (UINT64 Operand, UINT32 Count, UINT64 *OutResult)
ACPI_STATUS	AcpiUtShortDivide (UINT64 Dividend, UINT32 Divisor, UINT64 *OutQuotient, UINT32 *OutRemainder)
ACPI_STATUS	AcpiUtDivide (UINT64 InDividend, UINT64 InDivisor, UINT64 *OutQuotient, UINT64 *OutRemainder)

Macro Definition Documentation

_COMPONENT

#define _COMPONENT   ACPI_UTILITIES

Definition at line 48 of file utmath.c.

Typedef Documentation

UINT64_OVERLAY

typedef union uint64_overlay UINT64_OVERLAY

UINT64_STRUCT

typedef struct uint64_struct UINT64_STRUCT

Function Documentation

AcpiUtDivide()

ACPI_STATUS AcpiUtDivide	(	UINT64	InDividend,
		UINT64	InDivisor,
		UINT64 *	OutQuotient,
		UINT64 *	OutRemainder
	)

Definition at line 402 of file utmath.c.

{
    UINT64_OVERLAY          Dividend;
    UINT64_OVERLAY          Divisor;
    UINT64_OVERLAY          Quotient;
    UINT64_OVERLAY          Remainder;
    UINT64_OVERLAY          NormalizedDividend;
    UINT64_OVERLAY          NormalizedDivisor;
    UINT32                  Partial1;
    UINT64_OVERLAY          Partial2;
    UINT64_OVERLAY          Partial3;
 
 
    ACPI_FUNCTION_TRACE (UtDivide);
 
 
    /* Always check for a zero divisor */
 
    if (InDivisor == 0)
    {
        ACPI_ERROR ((AE_INFO, "Divide by zero"));
        return_ACPI_STATUS (AE_AML_DIVIDE_BY_ZERO);
    }
 
    Divisor.Full  = InDivisor;
    Dividend.Full = InDividend;
    if (Divisor.Part.Hi == 0)
    {
        /*
         * 1) Simplest case is where the divisor is 32 bits, we can
         * just do two divides
         */
        Remainder.Part.Hi = 0;
 
        /*
         * The quotient is 64 bits, the remainder is always 32 bits,
         * and is generated by the second divide.
         */
        ACPI_DIV_64_BY_32 (0, Dividend.Part.Hi, Divisor.Part.Lo,
            Quotient.Part.Hi, Partial1);
 
        ACPI_DIV_64_BY_32 (Partial1, Dividend.Part.Lo, Divisor.Part.Lo,
            Quotient.Part.Lo, Remainder.Part.Lo);
    }
 
    else
    {
        /*
         * 2) The general case where the divisor is a full 64 bits
         * is more difficult
         */
        Quotient.Part.Hi   = 0;
        NormalizedDividend = Dividend;
        NormalizedDivisor  = Divisor;
 
        /* Normalize the operands (shift until the divisor is < 32 bits) */
 
        do
        {
            ACPI_SHIFT_RIGHT_64 (
                NormalizedDivisor.Part.Hi, NormalizedDivisor.Part.Lo);
            ACPI_SHIFT_RIGHT_64 (
                NormalizedDividend.Part.Hi, NormalizedDividend.Part.Lo);
 
        } while (NormalizedDivisor.Part.Hi != 0);
 
        /* Partial divide */
 
        ACPI_DIV_64_BY_32 (
            NormalizedDividend.Part.Hi, NormalizedDividend.Part.Lo,
            NormalizedDivisor.Part.Lo, Quotient.Part.Lo, Partial1);
 
        /*
         * The quotient is always 32 bits, and simply requires
         * adjustment. The 64-bit remainder must be generated.
         */
        Partial1 = Quotient.Part.Lo * Divisor.Part.Hi;
        Partial2.Full = (UINT64) Quotient.Part.Lo * Divisor.Part.Lo;
        Partial3.Full = (UINT64) Partial2.Part.Hi + Partial1;
 
        Remainder.Part.Hi = Partial3.Part.Lo;
        Remainder.Part.Lo = Partial2.Part.Lo;
 
        if (Partial3.Part.Hi == 0)
        {
            if (Partial3.Part.Lo >= Dividend.Part.Hi)
            {
                if (Partial3.Part.Lo == Dividend.Part.Hi)
                {
                    if (Partial2.Part.Lo > Dividend.Part.Lo)
                    {
                        Quotient.Part.Lo--;
                        Remainder.Full -= Divisor.Full;
                    }
                }
                else
                {
                    Quotient.Part.Lo--;
                    Remainder.Full -= Divisor.Full;
                }
            }
 
            Remainder.Full = Remainder.Full - Dividend.Full;
            Remainder.Part.Hi = (UINT32) -((INT32) Remainder.Part.Hi);
            Remainder.Part.Lo = (UINT32) -((INT32) Remainder.Part.Lo);
 
            if (Remainder.Part.Lo)
            {
                Remainder.Part.Hi--;
            }
        }
    }
 
    /* Return only what was requested */
 
    if (OutQuotient)
    {
        *OutQuotient = Quotient.Full;
    }
    if (OutRemainder)
    {
        *OutRemainder = Remainder.Full;
    }
 
    return_ACPI_STATUS (AE_OK);
}

Referenced by AcpiExOpcode_2A_1T_1R(), AcpiExOpcode_2A_2T_1R(), and AcpiUtPutNumber().

AcpiUtShortDivide()

ACPI_STATUS AcpiUtShortDivide	(	UINT64	Dividend,
		UINT32	Divisor,
		UINT64 *	OutQuotient,
		UINT32 *	OutRemainder
	)

Definition at line 337 of file utmath.c.

{
    UINT64_OVERLAY          DividendOvl;
    UINT64_OVERLAY          Quotient;
    UINT32                  Remainder32;
 
 
    ACPI_FUNCTION_TRACE (UtShortDivide);
 
 
    /* Always check for a zero divisor */
 
    if (Divisor == 0)
    {
        ACPI_ERROR ((AE_INFO, "Divide by zero"));
        return_ACPI_STATUS (AE_AML_DIVIDE_BY_ZERO);
    }
 
    DividendOvl.Full = Dividend;
 
    /*
     * The quotient is 64 bits, the remainder is always 32 bits,
     * and is generated by the second divide.
     */
    ACPI_DIV_64_BY_32 (0, DividendOvl.Part.Hi, Divisor,
        Quotient.Part.Hi, Remainder32);
 
    ACPI_DIV_64_BY_32 (Remainder32, DividendOvl.Part.Lo, Divisor,
        Quotient.Part.Lo, Remainder32);
 
    /* Return only what was requested */
 
    if (OutQuotient)
    {
        *OutQuotient = Quotient.Full;
    }
    if (OutRemainder)
    {
        *OutRemainder = Remainder32;
    }
 
    return_ACPI_STATUS (AE_OK);
}

Referenced by AcpiExConvertToAscii(), AcpiExDigitsNeeded(), AcpiExIntegerToString(), AcpiExOpcode_1A_1T_1R(), AcpiExSystemMemorySpaceHandler(), AcpiGetTimerDuration(), and AcpiUtStrtoulMultiply64().

AcpiUtShortMultiply()

ACPI_STATUS AcpiUtShortMultiply	(	UINT64	Multiplicand,
		UINT32	Multiplier,
		UINT64 *	OutProduct
	)

Definition at line 88 of file utmath.c.

{
    UINT64_OVERLAY          MultiplicandOvl;
    UINT64_OVERLAY          Product;
    UINT32                  Carry32;
 
 
    ACPI_FUNCTION_TRACE (UtShortMultiply);
 
 
    MultiplicandOvl.Full = Multiplicand;
 
    /*
     * The Product is 64 bits, the carry is always 32 bits,
     * and is generated by the second multiply.
     */
    ACPI_MUL_64_BY_32 (0, MultiplicandOvl.Part.Hi, Multiplier,
        Product.Part.Hi, Carry32);
 
    ACPI_MUL_64_BY_32 (0, MultiplicandOvl.Part.Lo, Multiplier,
        Product.Part.Lo, Carry32);
 
    Product.Part.Hi += Carry32;
 
    /* Return only what was requested */
 
    if (OutProduct)
    {
        *OutProduct = Product.Full;
    }
 
    return_ACPI_STATUS (AE_OK);
}

Referenced by AcpiUtScanNumber().

AcpiUtShortShiftLeft()

ACPI_STATUS AcpiUtShortShiftLeft	(	UINT64	Operand,
		UINT32	Count,
		UINT64 *	OutResult
	)

Definition at line 139 of file utmath.c.

{
    UINT64_OVERLAY          OperandOvl;
 
 
    ACPI_FUNCTION_TRACE (UtShortShiftLeft);
 
 
    OperandOvl.Full = Operand;
 
    if ((Count & 63) >= 32)
    {
        OperandOvl.Part.Hi = OperandOvl.Part.Lo;
        OperandOvl.Part.Lo = 0;
        Count = (Count & 63) - 32;
    }
    ACPI_SHIFT_LEFT_64_BY_32 (OperandOvl.Part.Hi,
        OperandOvl.Part.Lo, Count);
 
    /* Return only what was requested */
 
    if (OutResult)
    {
        *OutResult = OperandOvl.Full;
    }
 
    return_ACPI_STATUS (AE_OK);
}

AcpiUtShortShiftRight()

ACPI_STATUS AcpiUtShortShiftRight	(	UINT64	Operand,
		UINT32	Count,
		UINT64 *	OutResult
	)

Definition at line 184 of file utmath.c.

{
    UINT64_OVERLAY          OperandOvl;
 
 
    ACPI_FUNCTION_TRACE (UtShortShiftRight);
 
 
    OperandOvl.Full = Operand;
 
    if ((Count & 63) >= 32)
    {
        OperandOvl.Part.Lo = OperandOvl.Part.Hi;
        OperandOvl.Part.Hi = 0;
        Count = (Count & 63) - 32;
    }
    ACPI_SHIFT_RIGHT_64_BY_32 (OperandOvl.Part.Hi,
        OperandOvl.Part.Lo, Count);
 
    /* Return only what was requested */
 
    if (OutResult)
    {
        *OutResult = OperandOvl.Full;
    }
 
    return_ACPI_STATUS (AE_OK);
}

Referenced by AcpiUtHexToAsciiChar().