/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 Copyright (c) 1989-2000 Microsoft Corporation

 Module Name:

        proccls.cxx

 Abstract:

        Implementation of offline methods for the proc / param code generation
        classes.

 Notes:

 History:

        Sep-14-1993             VibhasC         Created.
 ----------------------------------------------------------------------------*/

/****************************************************************************
 *      include files
 ***************************************************************************/
#include "becls.hxx"
#pragma hdrstop

extern CMD_ARG * pCommand;

/* 
    These flags could be picked up from the actual rpcdcep.h file.
    However, this would give us a bad dependency and the flags cannot change anyway
    because of backward compatibility reasons: in the interpreted modes the value
    of the flag is used in format strings, not the name like in the -Os code.
*/

#define RPC_NCA_FLAGS_DEFAULT       0x00000000  /* 0b000...000 */
#define RPC_NCA_FLAGS_IDEMPOTENT    0x00000001  /* 0b000...001 */
#define RPC_NCA_FLAGS_BROADCAST     0x00000002  /* 0b000...010 */
#define RPC_NCA_FLAGS_MAYBE         0x00000004  /* 0b000...100 */

#define RPCFLG_MESSAGE              0x01000000
#define RPCFLG_INPUT_SYNCHRONOUS    0x20000000
// the following flag is now redundant
// #define RPCFLG_ASYNCHRONOUS         0x40000000


/****************************************************************************/

/****************************************************************************
 *      procedure class methods.
 ***************************************************************************/
CG_PROC::CG_PROC(
        unsigned int    ProcNumber,
        node_skl        *       pProc,
        CG_HANDLE       *       pBH,
        CG_PARAM        *       pHU,
        BOOL                    fIn,
        BOOL                    fOut,
        BOOL                    fAtLeastOneShipped,
        BOOL                    fHasStat,
        BOOL                    fHasFull,
        CG_RETURN       *       pRT,
        OPTIM_OPTION    OptimFlags,
        unsigned short  OpBits, 
        BOOL            fDeny
        ) : 
        CG_NDR(pProc, XLAT_SIZE_INFO() ),
        fHasAsyncHandle( FALSE ),
        fHasDeny( fDeny ),
        fHasAsyncUUID( FALSE ),
        uNotifyTableOffset( 0 )
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

 Routine Description:

        Constructor for the parm cg class.

 Arguments:

        ProcNumber                      - The procedure number in the interface.
        pProc                           - a pointer to the original node in the type graph.
        pBH                                     - a pointer to a binding handle cg class.
        pHU                                     - the usage of the handle, a CG_PARAM or NULL
        fIn                                     - flag specifying at least one in param.
        fOut                            - flag specifying at least one out param.
        fAtLeastOneShipped      - flag specifying that at least one param is shipped.
        fHasStat                        - flag for any comm/fault statuses on return or params
        pRT                                     - pointer to CG_PARAM or NULL.
        OptimFlags                      - optimization flags for this proc

 Return Value:

        NA.

 Notes:

        The procedure number is the lexical sequence number of the procedure as
        specified in the interface, not counting the callback procedures. The
        type of the procnum matches the corresponding field of the rpc message.

----------------------------------------------------------------------------*/
{
    SetProcNum( ProcNumber );
    SetHandleClassPtr( pBH );
    SetHandleUsagePtr( pHU );
    SetOptimizationFlags( OptimFlags );
    SetOperationBits( OpBits );
    SetHasFullPtr( fHasFull );
    SetProckind(PROC_PUREVIRTUAL);

    fNoCode         = FALSE;
    fHasNotify      = FALSE;
    fHasNotifyFlag  = FALSE;
    fReturnsHRESULT = FALSE;

    fHasStatuses    = fHasStat;
    fHasExtraStatusParam  = 0;
    fOutLocalAnalysisDone = 0;
    pCallAsName     = NULL;

    if( fIn == TRUE )
        SetHasAtLeastOneIn();
    else
        ResetHasAtLeastOneIn();

    if( fOut == TRUE )
        SetHasAtLeastOneOut();
    else
        ResetHasAtLeastOneOut();

    SetReturnType( pRT );

    if( fAtLeastOneShipped )
        {
        SetHasAtLeastOneShipped();
        }
    else
        ResetHasAtLeastOneShipped();

    SetSStubDescriptor( 0 );
    SetCStubDescriptor( 0 );
    SetStatusResource( 0 );

    SetFormatStringParamStart(-1);

    SetMustInvokeRpcSSAllocate( 0 );

    SetRpcSSSpecified( 0 );

    SetContextHandleCount( 0 );

    SetHasPipes( 0 );
    fSupressHeader = FALSE;
    pSavedProcFormatString = NULL;
    pSavedFormatString = NULL;
    cRefSaved = 0;
    pCallAsType = NULL;

    fHasServerCorr = FALSE;
    fHasClientCorr = FALSE;

    fIsBeginProc = FALSE;
    fIsFinishProc = FALSE;
    pAsyncRelative = NULL;

    pCSTagRoutine = NULL;

    fHasComplexReturn = FALSE;
}

char    *
CG_PROC::GetInterfaceName()
        {
        return GetInterfaceNode()->GetSymName();
        }

BOOL CG_PROC::SetHasPipes(BOOL f)
        {
        if (f)
            GetInterfaceNode()->SetHasPipes(TRUE);
        return (fHasPipes = f);
        }

short
CG_PROC::GetInParamList(
        ITERATOR&       I )
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

 Routine Description:

        Get the list of [in] parameters.

 Arguments:

        I       - An iterator supplied by the caller.

 Return Value:

        Count of the number of in parameters.

 Notes:

----------------------------------------------------------------------------*/
{
        CG_ITERATOR             I1;
        CG_PARAM        *       pParam;
        short                   Count = 0;

        //
        // Get all the members of this cg class and pick ones which are in params.
        //

        GetMembers( I1 );

        ITERATOR_INIT( I1 );

        while( ITERATOR_GETNEXT( I1, pParam ) )
                {
                if( pParam->IsParamIn() && (pParam->GetType()->GetBasicType()->NodeKind() != NODE_VOID) )
                        {
                        ITERATOR_INSERT( I, pParam );
                        Count++;
                        }
                }
        return Count;
}

short
CG_PROC::GetOutParamList(
        ITERATOR&       I )
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

 Routine Description:

        Get the list of [out] parameters.

 Arguments:

        I       - An iterator supplied by the caller.

 Return Value:

        Count of the number of out parameters.

 Notes:

----------------------------------------------------------------------------*/
{
        CG_ITERATOR             I1;
        CG_PARAM        *       pParam;
        short                   Count = 0;

        //
        // Get all the members of this cg class and pick ones which are out params.
        //

        GetMembers( I1 );

        ITERATOR_INIT( I1 );

        while( ITERATOR_GETNEXT( I1, pParam ) )
                {
                if( pParam->IsParamOut() )
                        {
                        ITERATOR_INSERT( I, pParam );
                        Count++;
                        }
                }
        return Count;
}

long
CG_PROC::GetTotalStackSize(
     CCB  * pCCB 
     )
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
----------------------------------------------------------------------------*/
{
    //
    // Figure out the total stack size of all parameters.
    //
    CG_ITERATOR Iterator;
    CG_PARAM *  pParam;
    long        Size;
    BOOL        f64 = pCommand->Is64BitEnv();

    GetMembers( Iterator );

    Size = 0;

    pParam = 0;

    // Get the last parameter.
    while ( ITERATOR_GETNEXT( Iterator, pParam ) )
        ;

    if ( pParam )
        {
        Size += pParam->GetStackOffset( pCCB, I386_STACK_SIZING ) +
                pParam->GetStackSize();
        if ( f64 )
            Size = (Size + 7) & ~ 0x7;
        else
            Size = (Size + 3) & ~ 0x3;
        }
    else
        if ( IsObject() )
            {
            //
            // If our stack size is still 0 and we're an object proc then
            // add in the 'this' pointer size.
            //
            Size = SIZEOF_PTR( f64 );
            }

    if ( ( pParam = GetReturnType() ) != 0 )
        {
        Size += pParam->GetStackSize();
        if ( f64 )
            Size = (Size + 7) & ~ 0x7;
        else
            Size = (Size + 3) & ~ 0x3;
        }

    return Size;
}


BOOL
CG_PROC::MustUseSingleEngineCall(
         CCB    *       pCCB )
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

 Routine Description:

        Must we generate code for a single call to the marshalling engine routine ?

 Arguments:

        pCCB    - A pointer to the code gen controller block.

 Return Value:

        TRUE if one call is recommended.
        FALSE otherwise.

 Notes:

        If all parameters recommend that a single engine call be used, then
        recommend that.
----------------------------------------------------------------------------*/
{
    return (pCCB->GetOptimOption() & OPTIMIZE_INTERPRETER);
}

BOOL
CG_PROC::UseOldInterpreterMode( CCB* )
{
#ifdef TEMPORARY_OI_SERVER_STUBS
    return TRUE;
#else //  TEMPORARY_OI_SERVER_STUBS
    return FALSE;
#endif //  TEMPORARY_OI_SERVER_STUBS
}

BOOL
CG_PROC::NeedsServerThunk( CCB *    pCCB,
                           CGSIDE   Side )
{
    OPTIM_OPTION OptimizationFlags = GetOptimizationFlags();

    // -Os
    if ( ( ( (unsigned long)OptimizationFlags ) & OPTIMIZE_INTERPRETER ) == 0 )
        return FALSE;


    if ( (Side == CGSIDE_CLIENT) && (GetCGID() != ID_CG_CALLBACK_PROC) )
        return FALSE;

    pCCB->SetCGNodeContext( this );

    // not -Oicf
    if ( !( OptimizationFlags & OPTIMIZE_INTERPRETER_V2 ) )
        {
        long x86StackSize = GetTotalStackSize( pCCB );

        //
        // Now check if the parameter size threshold is exceeded on any of the
        // four platforms.  On the Alpha and win64 we allow a size twice as big to
        // compensate for the 8 byte aligned stacks.  The interpreter has the
        // necessary #ifdefs to handle this anomoly.
        // We ignore non-server platforms.

        long x86Limit;

        x86Limit = (long)(pCommand->Is64BitEnv() ? INTERPRETER_THUNK_PARAM_SIZE_THRESHOLD * 2
                                                 : INTERPRETER_THUNK_PARAM_SIZE_THRESHOLD);

        if ( x86StackSize > x86Limit )
            {
            return TRUE;
            }
        }

    return OptimizationFlags & OPTIMIZE_THUNKED_INTERPRET;
}


expr_node *
CG_PROC::GenBindOrUnBindExpression(
        CCB             *       pCCB,
        BOOL            fBind )
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

 Routine Description:

        Create the final binding expression for the procedure.

 Arguments:

        pCCB    - A pointer to the code gen controller block.
        fBind   - TRUE if called for binding, FALSE for unbinding.

 Return Value:

        The final expression.

 Notes:

        1. If the procedure is an auto binding handle procedure, then the final
           binding expression is the address of the AutoBindVariable.
        2. If the handle is a generic handle, then the binding expression is the
           call to the generic bind routine.
        3. If the handle is a context handle, then the bindiing expression is the
           NDRCContextBinding Expression.


        The Binding expression is passed on to the initialize routine or the
        single call engine routine.

----------------------------------------------------------------------------*/
{
    expr_node       *       pExpr   = 0;

    if( IsAutoHandle() )
        {
        if( fBind == TRUE )
            {
            RESOURCE * pR = pCCB->GetStandardResource( ST_RES_AUTO_BH_VARIABLE );

            // Make the code generator believe we have a binding resource.
            SetBindingResource( pR );
            }
        }
    else if( IsGenericHandle() )
        {

        // For a generic handle, the expression is the call to the generic
        // handle bind routine. To do this, we need to send the message to
        // the handle param to generate the parameter passed to this routine
        // and then generate an expression for the call to the procedure.

        ITERATOR        I;
        PNAME           p;
        node_skl*       pType   = ((CG_GENERIC_HANDLE *)GetHandleClassPtr())->GetHandleType();
        char    *       pName   = pType->GetSymName();

        if( GetHandleUsage() == HU_IMPLICIT )
            {
            node_skl * pID;

            if( (pID = pCCB->GetImplicitHandleIDNode()) == 0 )
                {
                pID = pCCB->SetImplicitHandleIDNode(
                                 GetHandleClassPtr()->GetHandleIDOrParam() );
                }
            pExpr   = new expr_variable( pID->GetSymName() );
            }
        else
            {

            // An explicit parameter is specified for the binding handle.

            pExpr   = ((CG_NDR *)SearchForBindingParam())->GenBindOrUnBindExpression    (
                                                                                        pCCB,
                                                                                        fBind
                                                                                        );

            // Register this genric handle with the ccb.

            }

        pCCB->RegisterGenericHandleType( pType );

        ITERATOR_INSERT( I, pExpr );

        // For unbind we have to specify the original binding handle variable
        // also as a parameter.

        if( fBind == FALSE )
            {
            RESOURCE * pTR = GetBindingResource();
            ITERATOR_INSERT( I, pTR );
            }

        // Generate the name: Type_bind;

        p       = new char [ strlen(pName) + 10 ];
        strcpy( p, pName );
        strcat( p, fBind ? "_bind" : "_unbind" );

        pExpr = MakeProcCallOutOfParamExprList( p,
                                                GetType(),
                                                I
                                              );
        if( fBind == TRUE )
            {
            pExpr = new expr_assign( GetBindingResource(), pExpr );
            }
        }
    else if(IsPrimitiveHandle() )
        {

        // This should never be called for an unbind request.

        MIDL_ASSERT( fBind == TRUE );

        // may be an explicit or implicit primitive handle.

        if( GetHandleUsage() == HU_IMPLICIT )
            {
            node_skl * pID;

            if( (pID = pCCB->GetImplicitHandleIDNode()) == 0 )
                {
                pID = pCCB->SetImplicitHandleIDNode(
                                 GetHandleClassPtr()->GetHandleIDOrParam() );
                }
            pExpr   = new expr_variable( pID->GetSymName() );
            }
        else
            {

            // The binding handle parameter derives the expression.
            pExpr   = ((CG_NDR *)SearchForBindingParam())->
                                GenBindOrUnBindExpression( pCCB, fBind );
            }

        if( fBind == TRUE )
            {
            pExpr = new expr_assign( GetBindingResource(), pExpr );
            }
        }
    else
        {
        // Context handles.
        // This method should never be called on an unbind.
        MIDL_ASSERT( fBind == TRUE );

        node_skl* pType = ((CG_CONTEXT_HANDLE *)GetHandleClassPtr())->GetHandleType();
        if( pType->NodeKind() == NODE_DEF )
            {
            pCCB->RegisterContextHandleType( pType );
            }
        }

    return pExpr;
}

unsigned int
CG_PROC::TranslateOpBitsIntoUnsignedInt()
        {
        unsigned int    OpBits  = GetOperationBits();
        unsigned int    Flags   = RPC_NCA_FLAGS_DEFAULT;

        if( OpBits & OPERATION_MAYBE )
                {
                Flags |= RPC_NCA_FLAGS_MAYBE;
                }

        if( OpBits & OPERATION_BROADCAST )
                {
                Flags |= RPC_NCA_FLAGS_BROADCAST;
                }

        if( OpBits & OPERATION_IDEMPOTENT )
                {
                Flags |= RPC_NCA_FLAGS_IDEMPOTENT;
                }

        if( OpBits & OPERATION_MESSAGE )
                {
                Flags |= RPCFLG_MESSAGE;
                pCommand->GetNdrVersionControl().SetHasMessageAttr();
                }

        if( OpBits & OPERATION_INPUT_SYNC )
                {
                Flags |= RPCFLG_INPUT_SYNCHRONOUS;
                }

        return Flags;
        }

BOOL
CG_PROC::HasInterpreterDeferredFree()
{
    CG_ITERATOR Iterator;
    CG_PARAM *  pParam;

    GetMembers( Iterator );

    //
    // Just check for pointers to basetypes for now.  Eventually we'll have
    // to check if a pointer to basetype actually occurs in any *_is
    // expression.
    //
    while ( ITERATOR_GETNEXT( Iterator, pParam ) )
        {
        if ( ((CG_NDR *)pParam->GetChild())->IsPointerToBaseType() )
            return TRUE;
        }

    // Don't have to check return type since it can't be part of a *_is
    // expression.

    return FALSE;
}

/****************************************************************************
 *      parameter class methods.
 */

CG_PARAM::CG_PARAM(
    node_skl      *     pParam,
    PARAM_DIR_FLAGS     Dir,
    XLAT_SIZE_INFO &    Info,
    expr_node *         pSw,
    unsigned short      Stat 
    )  
    : CG_NDR( pParam, Info ),
    fIsAsyncHandle( FALSE ),
    fSaveForAsyncFinish( false )
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

 Routine Description:

    Constructor for the parm cg class.

 Arguments:

    pParam  - a pointer to the original node in the type graph.
    Dir     - the direction : IN_PARAM, OUT_PARAM or IN_OUT_PARAM
    WA      - wire alignment.
    pSw     - any switch_is expression on the param
    Stat    - any comm/fault statuses on the param

 Notes:

----------------------------------------------------------------------------*/
{
    //
    // set the direction indicator for quick future reference.
    //
    fDirAttrs       = Dir;

    fDontCallFreeInst    = 0;
    fInterpreterMustSize = 1;
    fIsExtraStatusParam  = 0;
    fIsForceAllocate    = FALSE;

    // save the optional attributes; switch_is, comm/fault statuses

    pSwitchExpr = pSw;
    Statuses    = Stat;

    //
    // initialize phase specific information array.
    //

    SetFinalExpression( 0 );
    SetSizeExpression( 0 );
    SetSizeResource(0);
    SetLengthResource(0);
    SetFirstResource(0);
    SetSubstitutePtrResource(0);

    SetUnionFormatStringOffset(-1);

    SetParamNumber( -1 );

    SetIsCSSTag( FALSE );
    SetIsCSDRTag( FALSE );
    SetIsCSRTag( FALSE );
    SetIsOmittedParam( FALSE );
}

expr_node *
CG_PARAM::GenBindOrUnBindExpression(
        CCB     *       pCCB,
        BOOL    fBind )
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

 Routine Description:

        Generate the binding expression.

 Arguments:

        pCCB    - A pointer to the code generator controller block.
        fBind   - bool to indicate a bind or unbind generation.

 Return Value:

 Notes:

        Actually for a param node, the expression remains the same whether it
        is being called for a bind or unbind.
----------------------------------------------------------------------------*/
{
    RESOURCE *  pR = pCCB->GetParamResource( GetType()->GetSymName() );

    MIDL_ASSERT( pR != 0 );

    pCCB->SetSourceExpression( pR );

    return ((CG_NDR *)GetChild())->GenBindOrUnBindExpression( pCCB, fBind );
}

long
CG_PARAM::GetStackOffset(
    CCB * pCCB,
    long  PlatformForSizing )
/*++

Routine Description :

        Returns the offset on the stack to the parameter.

--*/
{
    CG_ITERATOR     Iterator;
    CG_PROC *       pProc;
    CG_PARAM *      pParam;
    CG_NDR *        pNdr;
    long            Offset;
    long            Align;

    BOOL  fForIA64  = pCommand->Is64BitEnv() && 
                             (PlatformForSizing & I386_STACK_SIZING);

    pProc = (CG_PROC *) pCCB->GetCGNodeContext();

    //
    // If this is a cs_tag param and there is a tag routine it is not
    // pushed on the stack.
    //

    if ( this->IsSomeCSTag() && pProc->GetCSTagRoutine() )
        return 0;

    pProc->GetMembers( Iterator );

    Offset = 0;

    //
    // Add in size of 'this' pointer for object procs.
    //
    if ( pProc->IsObject() )
        {
        Offset += fForIA64 ? 8 : 4;
        }

    Align = 0x3;

    // Override for ia64.
    if ( fForIA64 )
        Align = 0x7;

    pParam = 0;

    for ( ; ITERATOR_GETNEXT( Iterator, pParam );
            Offset += Align, Offset = Offset & ~ Align )
        {
        if ( pParam->IsSomeCSTag() && pProc->GetCSTagRoutine() )
            continue;

        pNdr = (CG_NDR *) pParam->GetChild();

        //
        // For CG_CSARRAY, the size is the size of the underlying type
        //

        if ( pNdr->GetCGID() == ID_CG_CS_ARRAY )
            pNdr = (CG_NDR *) pNdr->GetChild();

        //
        // If this is a generic handle then re-set the ndr pointer to the
        // handle's child, which is what is actually being pushed on the
        // stack.
        //
        if ( pNdr->GetCGID() == ID_CG_GENERIC_HDL )
            pNdr = (CG_NDR *) pNdr->GetChild();

        // The IA64 stack rules as of Jan 14, 2000.
        // The following is a quote from ver. 2.5 of Intel's doc:
        //
        //     Table 8-1. Rules for Allocating Parameter Slots
        // ---------------------------------------------------------------------
        //     Type            Size(bits)  Slot         How many       Alignment
        // ---------------------------------------------------------------------
        // Integer/Pointer       1-64      next             1             LSB
        // Integer               65-128    next even        2             LSB
        // Single-Precision FP   32        next             1             LSB
        // Double-Precision FP   64        next             1             LSB
        // Double-Extended  FP   80        next even        2             byte 0
        // Quad-Precision FP     128       next even        2             byte 0
        // Aggregates            any       next aligned   (size+63)/64    byte 0
        // ---------------------------------------------------------------------
        //
        // Notes. 
        //  "next aligned" is for aggregates with alignment of 16 (becomes next even).
        //  The padding is always to a single slot boundary, padding is undefined.
        //  As of this writing the C++ compiler does not support any of these:
        //     __int128, float128, float80.
        //

        if ( fForIA64  )
            {
            // Slightly simplified rules as no int or FP is bigger than 64b.

            if ( (pNdr->GetMemoryAlignment() > 8)  &&
                 (pNdr->GetMemorySize() > 8)  &&
                 ! pNdr->IsArray() )
                {
                if (pNdr->IsStruct()  || pNdr->IsUnion()) 
                    {
                    Offset = (Offset + 15) & ~ 0xf;
                    }
                else if ( (pNdr->GetCGID() == ID_CG_TRANSMIT_AS) ||
                          (pNdr->GetCGID() == ID_CG_REPRESENT_AS) ||
                          (pNdr->GetCGID() == ID_CG_USER_MARSHAL) )
                    {
                    node_skl *  pPresented;

                    //
                    // Presented type alignment is 16 and
                    // Since we know the presented type is >= 8 bytes in
                    // size, we just have to make sure it's not an array
                    // (could be a large fixed array of alignment < 8).
                    //

                    if ( pNdr->GetCGID() == ID_CG_TRANSMIT_AS )
                        pPresented = ((CG_TRANSMIT_AS *)pNdr)->GetPresentedType();
                    else if ( (pNdr->GetCGID() == ID_CG_REPRESENT_AS) ||
                         (pNdr->GetCGID() == ID_CG_USER_MARSHAL) )
                        pPresented = ((CG_REPRESENT_AS *)pNdr)->GetRepAsType();

                    //
                    // We could have a null presented type for unknown rep_as.
                    // If it is null then the proc will have been changed
                    // to -Os and the stub won't need the stack sizes anyway.
                    //
                    if ( pPresented &&
                         (pPresented->GetBasicType()->NodeKind() != NODE_ARRAY) )
                        Offset = (Offset + 15) & ~ 0xf;
                    }
                }
            } // ia64

        //
        // Do the exit condition check AFTER the above three alignment checks.
        //

        if ( pParam == this )
            break;

        //
        // Add in the stack size of this parameter.
        //

        // If this is a pipe, then we need to ensure proper alignment and
        // then bump the stack by the size of the pipe structure
        // (four far pointers)

        if ( pNdr->GetCGID() == ID_CG_PIPE )
            {
            // Pipes don't need any special treatment on ia64.
            // For ia64 offset is already aligned to 8.

            Offset += 4 * SIZEOF_MEM_PTR();
            continue;
            }

        if ( pNdr->IsSimpleType() )
            {
            ((CG_BASETYPE *)pNdr)->IncrementStackOffset( &Offset );
            continue;
            }

        if ( pNdr->IsPointer() || pNdr->IsArray() ||
                         (pNdr->IsInterfacePointer() ) )
            {
            Offset += SIZEOF_MEM_PTR();
            continue;
            }

        if ( pNdr->IsStruct() || pNdr->IsUnion() || ID_CG_CS_TAG == pNdr->GetCGID() )
            {
            // Already aligned for the bigger-than-8 rule on ia64.

            Offset += pParam->GetStackSize();
            continue;
            }

        if ( pNdr->IsAHandle() )
            {
            //
            // We only get here for primitive and context handles.  For
            // primitive handles we know the pushed size is always 4.
            //
            // For context handles this is a major hassle and for now we assume
            // that the underlying user defined type is a pointer.
            //

            Offset += SIZEOF_MEM_PTR();
            continue;
            }

        if (pParam->IsAsyncHandleParam())
            {
            Offset += SIZEOF_MEM_PTR();
            continue;
            }

        if ( pNdr->GetCGID() == ID_CG_TRANSMIT_AS )
            {
            Offset += ((CG_TRANSMIT_AS *)pNdr)->GetStackSize();
            continue;
            }

        if ( pNdr->GetCGID() == ID_CG_REPRESENT_AS )
            {
            Offset += ((CG_REPRESENT_AS *)pNdr)->GetStackSize();
            continue;
            }

        if ( pNdr->GetCGID() == ID_CG_USER_MARSHAL )
            {
            Offset += ((CG_USER_MARSHAL *)pNdr)->GetStackSize();
            continue;
            }

        // Should never get here.
        MIDL_ASSERT(0);

        } //for

    return Offset;
}

long
CG_PARAM::GetStackSize()
/*++

Routine Description :

        Returns the size of the parameter.

--*/
{
    CG_NDR* pNdr      = (CG_NDR *) GetChild();

    // if this is a pipe then return the size of the pipe structure
    if ( pNdr->GetCGID() == ID_CG_PIPE )
        return (4 * SIZEOF_MEM_PTR());  // four pointers

    //
    // If this is a generic handle then re-set the ndr pointer to the
    // handle's child, which is what is actually being pushed on the
    // stack.  Same for CsArray's
    //
    if ( pNdr->GetCGID() == ID_CG_GENERIC_HDL 
         || pNdr->GetCGID() == ID_CG_CS_ARRAY )
        {
        pNdr = (CG_NDR *) pNdr->GetChild();
        }

    if ( pNdr->GetCGID() == ID_CG_TYPE_ENCODE )
        pNdr = (CG_NDR *) ((CG_TYPE_ENCODE *) pNdr)->GetChild();

    if ( pNdr->IsPointer() || pNdr->IsArray() ||
            (pNdr->IsInterfacePointer() ) )
        return SIZEOF_MEM_PTR();

    if ( pNdr->IsSimpleType() || pNdr->IsStruct() || pNdr->IsUnion() )
        return pNdr->GetMemorySize();

    if ( pNdr->IsAHandle() )
        {
        //
        // We only get here for primitive and context handles.  For
        // primitive handles we know the pushed size is always 4.
        //
        // For context handles this is a major hassle and for now we assume
        // that the underlying user defined type is a pointer.
        //

        return SIZEOF_MEM_PTR();
        }

    if ( pNdr->GetCGID() == ID_CG_TRANSMIT_AS )
        return ((CG_TRANSMIT_AS *)pNdr)->GetStackSize();

    if ( pNdr->GetCGID() == ID_CG_REPRESENT_AS )
        return ((CG_REPRESENT_AS *)pNdr)->GetStackSize();

    if ( pNdr->GetCGID() == ID_CG_USER_MARSHAL )
        return ((CG_USER_MARSHAL *)pNdr)->GetStackSize();

    if (IsAsyncHandleParam())
        return SIZEOF_MEM_PTR();

    return 0;
}



short CG_PROC::GetFloatArgMask( CCB * pCCB )
/*++
Routine Description:

    On Ia64 floating point types are passed in floating point registers 
    instead of general registers.  Just to make life difficult "homogenous
    floating point aggregates" (structs that only contain floats/doubles or
    other HFA's) are also passed in floating point registers.  Floating point
    registers are allocated sequentially and out of sync with general 
    registers so e.g. if the third paramater was the first floating point
    argument it would go in the first floating point register and a "hole" 
    would be left in the third general register.

    The floating point mask consists of a series of 2-bit nibbles, one for 
    each general register slot.  This nibble contains a 0 if the register slot
    does not have a floating point value, a 1 for single precsion, a 2 for
    double, and a 3 for dual singles.

--*/
{
    MIDL_ASSERT( pCommand->Is64BitEnv() );

    enum FloatType
    {
        NonFloat    = 0,
        Single      = 1,
        Double      = 2,
        DualSingle  = 3
    };

    CG_ITERATOR Iterator;
    CG_PARAM   *pParam;
    unsigned    mask = 0;
    int         floatslot = 0;

    GetMembers( Iterator );

    while ( ITERATOR_GETNEXT( Iterator, pParam ) && floatslot < 8 )
        {
        CG_NDR *pChild = (CG_NDR *) pParam->GetChild();
        if ( pChild->IsArray() )
            continue;

        bool issingle = pChild->IsHomogeneous(FC_FLOAT);
        bool isdouble = pChild->IsHomogeneous(FC_DOUBLE);

        if ( issingle || isdouble )
            {
            long      slot = pParam->GetStackOffset( pCCB, I386_STACK_SIZING );
            long      size = pParam->GetStackSize();
            FloatType type;

            slot /= 8;
            size /= (isdouble ? 8 : 4);

            while (size > 0 && floatslot < 8)
                {
                if (isdouble)
                    type = Double;
                else if (size > 1 && floatslot < 7)
                    type = DualSingle;
                else 
                    type = Single;

                mask |= type << (slot * 2);

                slot      += 1;
                size      -= 1 + (DualSingle == type);
                floatslot += 1 + (DualSingle == type);
                }
            }
        }

    return (short) (mask & 0xffff);
}



char *
CG_PROC::SetCallAsName( char * pName )
        {
        return (pCallAsName = pName);
        }

void
CG_PROC::GetCommAndFaultOffset(
    CCB *   pCCB,
    long &  CommOffset,
    long &  FaultOffset )
{
    CG_ITERATOR Iterator;
    CG_PARAM *  pParam;
    CG_NDR *    pOldCGNodeContext;

    //
    // 0 is of course a valid offset.
    // -1 offset means it is the return value.
    // -2 offset means it was not specified in the proc.
    //

    CommOffset = -2;
    FaultOffset= -2;

    if ( ! HasStatuses() )
        return;

    pOldCGNodeContext = pCCB->SetCGNodeContext( this );

    GetMembers( Iterator );

    while ( ITERATOR_GETNEXT( Iterator, pParam ) )
        {
        if ( (pParam->GetStatuses() == STATUS_COMM) ||
             (pParam->GetStatuses() == STATUS_BOTH) )
            {
            CommOffset = pParam->GetStackOffset( pCCB, I386_STACK_SIZING );
            }

        if ( (pParam->GetStatuses() == STATUS_FAULT) ||
             (pParam->GetStatuses() == STATUS_BOTH) )
            {
            FaultOffset = pParam->GetStackOffset( pCCB, I386_STACK_SIZING );
            }
        }

    if ( ( pParam = GetReturnType() ) != 0 )
        {
        if ( (pParam->GetStatuses() == STATUS_COMM) ||
             (pParam->GetStatuses() == STATUS_BOTH) )
            {
            CommOffset = -1;
            }

        if ( (pParam->GetStatuses() == STATUS_FAULT) ||
             (pParam->GetStatuses() == STATUS_BOTH) )
            {
            FaultOffset = -1;
            }
        }

    pCCB->SetCGNodeContext( pOldCGNodeContext );
}