windows-xp/Source/XPSP1/NT/com/rpc/midl/codegen/ilctxt.cxx

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

 Module Name:
    
    ilctxt.cxx

 Abstract:

    Intermediate Language translator context management routines

 Notes:


 Author:

    GregJen Jun-11-1993 Created.

 Notes:


 ----------------------------------------------------------------------------*/

/****************************************************************************
 *  include files
 ***************************************************************************/

#include "becls.hxx"
#pragma hdrstop

#include "nodeskl.hxx"
#include "ilxlat.hxx"
#include "cmdana.hxx"
#include "optprop.hxx"
#include "ilreg.hxx"
#include "ndrcls.hxx"


/****************************************************************************
 *  externs
 ***************************************************************************/

extern CMD_ARG  * pCommand;

/****************************************************************************
 *  definitions
 ***************************************************************************/




// #define trace_cg
//--------------------------------------------------------------------
//
// XLAT_SIZE_INFO::XLAT_SIZE_INFO
//
// Notes:
//      
//
//
//--------------------------------------------------------------------
XLAT_SIZE_INFO::XLAT_SIZE_INFO(
    CG_NDR * pCG )
    {
    ZeePee      = pCommand->GetZeePee();
    MemAlign    = pCG->GetMemoryAlignment();
    WireAlign   = pCG->GetWireAlignment();
    MemSize     = pCG->GetMemorySize();
    WireSize    = pCG->GetWireSize();
    MemOffset   = 0;
    WireOffset  = 0;
    MustAlign   = false;
    }

//--------------------------------------------------------------------
//
// ::RoundToAlignment
//
// Helper round-up routine
//
// Notes:
//      
//
//
//--------------------------------------------------------------------

inline unsigned long
RoundToAlignment( unsigned long & Offset, unsigned short Alignment )
{
    unsigned long   AlignFactor = Alignment - 1;

    return (Offset = (Offset + AlignFactor) & ~AlignFactor );
}

//--------------------------------------------------------------------
//
// XLAT_SIZE_INFO::BaseTypeSizes
//
// Notes:
//      
// Merges attributes for a base type with the given context.
//
//--------------------------------------------------------------------


void
XLAT_SIZE_INFO::BaseTypeSizes( node_skl * pNode )
{
    unsigned short MS, WS;

    switch( pNode->NodeKind() )
        {
        case NODE_DOUBLE:
        case NODE_HYPER:
        case NODE_INT64:
        case NODE_LONGLONG:
            {
            MS=8; WS=8;
            break;
            };
        case NODE_INT128:
        case NODE_FLOAT80: //BUG, BUG double check this once VC supports
        case NODE_FLOAT128:
            {
            MS=16; WS = 16;
            break;
            }
        case NODE_POINTER:
        case NODE_HANDLE_T:
            {
            MS = (unsigned short) SIZEOF_MEM_PTR();
            WS = (unsigned short) SIZEOF_WIRE_PTR();
            break;
            };
        case NODE_INT3264:
            {
            MS = (unsigned short) SIZEOF_MEM_INT3264();
            WS = (unsigned short) SIZEOF_WIRE_INT3264();
            break;
            };
        case NODE_FLOAT:
        case NODE_LONG:
        case NODE_INT32:
        case NODE_INT:
        case NODE_E_STATUS_T:
            {
            MS=4; WS=4;
            break;
            };
        case NODE_SHORT:
        case NODE_WCHAR_T:
            {
            MS=2; WS=2;
            break;
            };
        case NODE_SMALL:
        case NODE_CHAR:
        case NODE_BOOLEAN:
        case NODE_BYTE:
            {
            MS=1; WS=1;
            break;
            };
        default:
            {
            MS=0; WS=0;
            break;
            }
        }

    GetMemSize()        = MS;
    GetMemAlign()       = __max(MS,GetMemAlign());

    GetWireSize()       = WS;
    GetWireAlign()      = __max(WS,GetWireAlign());

};

//--------------------------------------------------------------------
//
// XLAT_SIZE_INFO::EnumTypeSizes
//
// Notes:
//      
// Merges in the sizes for an enum.
//
//--------------------------------------------------------------------


void
XLAT_SIZE_INFO::EnumTypeSizes( node_skl*, BOOL Enum32 )
/*
    Called when xlating node_enum: Enum32 means [enum_v1] used.
*/
{
    unsigned short MS, WS;

    // note - this needs to check environment
    WS  = unsigned short( ( Enum32 ) ? 4 : 2 );
    MS  = 4;

    GetMemSize()        = MS;
    GetMemAlign()       = __max(MS, GetMemAlign());

    GetWireSize()       = WS;
    GetWireAlign()      = __max(WS, GetWireAlign());

};

//--------------------------------------------------------------------
//
// XLAT_SIZE_INFO::ContextHandleSizes
//
// Notes:
//      
//
//
//--------------------------------------------------------------------


void
XLAT_SIZE_INFO::ContextHandleSizes( node_skl * pNode )
{
    FixMemSizes( pNode );

    GetWireSize()       = 20;
    GetWireAlign()      = 4;

};

//--------------------------------------------------------------------
//
// XLAT_SIZE_INFO::ArraySize
//
// Notes:
//      
//
//
//--------------------------------------------------------------------


void
XLAT_SIZE_INFO::ArraySize( node_skl*, FIELD_ATTR_INFO * pFA )
{
    // if conformant, set sizes to 0 and return

    if ( pFA->Kind & FA_CONFORMANT )
        {
        MemSize     =
        WireSize    = 0;
        return;
        }

    // round up element size to alignment boundary
    // Element is already rounded up.
    // RoundToAlignment( MemSize, MemAlign );
    // RoundToAlignment( WireSize, WireAlign );
    
    // compute number of elements and multiply...

    unsigned long       ElementCount;

    ElementCount = (ulong) pFA->pSizeIsExpr->GetValue();

    MemSize     *= ElementCount;
    WireSize    *= ElementCount;


}

//--------------------------------------------------------------------
//
// XLAT_SIZE_INFO::GetOffset
//
// Notes:
//  For use only by field nodes !!
//  
//  Fetch the offsets from another size info block
//
//--------------------------------------------------------------------


void                
XLAT_SIZE_INFO::GetOffset( XLAT_SIZE_INFO & pInfo )
{
    MemOffset   = pInfo.MemOffset;
    WireOffset  = pInfo.WireOffset;
}

//--------------------------------------------------------------------
//
// XLAT_SIZE_INFO::AlignOffset
//
// Notes:
//  For use only by field and struct/union nodes!!
//  
//  Round the offsets up to the corresponding alignments.
//
//--------------------------------------------------------------------

void
XLAT_SIZE_INFO::AlignOffset()
{
    RoundToAlignment( MemOffset, MemAlign );
    RoundToAlignment( WireOffset, WireAlign );
}


//--------------------------------------------------------------------
//
// XLAT_SIZE_INFO::AlignEmbeddedUnion
//
// Notes:
//  For use only by field and struct/union nodes!!
//  
//  Round the offsets up to the corresponding alignments.
//  don't round up the wire offset
//
//--------------------------------------------------------------------

void
XLAT_SIZE_INFO::AlignEmbeddedUnion()
{
    RoundToAlignment( MemOffset, MemAlign );
    RoundToAlignment( MemSize,   MemAlign );
    // RoundToAlignment( WireOffset, WireAlign );
}

//--------------------------------------------------------------------
//
// XLAT_SIZE_INFO::AlignConfOffset
//
// Notes:
//  For use only by field and struct/union nodes!!
//  
//  Round the offsets up to the corresponding alignments.
//
//  the Mem offset passed down from the parent
//      of the conformant field is aligned
//  the Wire offset passed down from the parent is advanced by
//      the wire size and then aligned
//
//--------------------------------------------------------------------

void
XLAT_SIZE_INFO::AlignConfOffset()
{
    RoundToAlignment( MemOffset, MemAlign );
    //WireSize  += WireOffset;
    WireOffset  +=  WireSize;
    RoundToAlignment( WireOffset, WireAlign );
}

//--------------------------------------------------------------------
//
// XLAT_SIZE_INFO::AdjustForZP
//
// Notes:
//  For use only by field and struct/union nodes!!
//  
//  Round the offsets up to the corresponding alignments.
//
//--------------------------------------------------------------------

void
XLAT_SIZE_INFO::AdjustForZP()
{
    if ( ( MemAlign > ZeePee ) && !MustAlign ) MemAlign = ZeePee;
}

//--------------------------------------------------------------------
//
// XLAT_SIZE_INFO::AdjustSize
//
// Notes:
//  For use only by field and struct nodes!!
//  
//  Add current offsets to current sizes
//  pad MemSize out to ZeePee
//
//--------------------------------------------------------------------

void
XLAT_SIZE_INFO::AdjustSize()
{
    MemSize     += MemOffset;
    MemOffset   = MemSize;

    WireSize    += WireOffset;
    WireOffset  = WireSize;
}

//--------------------------------------------------------------------
//
// XLAT_SIZE_INFO::AdjustConfSize
//
// Notes:
//  For use only by field and struct nodes!!
//  
//  Add current offsets to current sizes
//  pad MemSize out to ZeePee
//
//--------------------------------------------------------------------

void
XLAT_SIZE_INFO::AdjustConfSize()
{
    MemSize     += MemOffset;
    MemOffset   = MemSize;

    // don't count padding before the conformance (in case it has size 0)
    /*****
    WireSize    += WireOffset;
    WireOffset  = WireSize;
     ******/
}

//--------------------------------------------------------------------
//
// XLAT_SIZE_INFO::AdjustTotalSize
//
// Notes:
//  For use only by field and struct/union nodes!!
//  
//  Add current offsets to current sizes
//  pad MemSize out to ZeePee
//
//--------------------------------------------------------------------

void
XLAT_SIZE_INFO::AdjustTotalSize()
{
    RoundToAlignment( MemSize, MemAlign );
}

//--------------------------------------------------------------------
//
// XLAT_SIZE_INFO::Ndr64AdjustTotalStructSize
//
// Notes:
//  For use only by field and struct nodes!!
//  
//  Add current offsets to current sizes
//  pad MemSize and BuffSize out to ZeePee
//
//--------------------------------------------------------------------

void
XLAT_SIZE_INFO::Ndr64AdjustTotalStructSize()
{
    RoundToAlignment( WireSize, WireAlign );
    RoundToAlignment( MemSize, MemAlign );
}

//--------------------------------------------------------------------
//
// XLAT_SIZE_INFO::FixMemSizes
//
// Notes:
//      
// This routine fixes up mem sizes when they are different from what
// the IL translate of children generated
//
//--------------------------------------------------------------------


void
XLAT_SIZE_INFO::FixMemSizes( node_skl * pNode )
{
    FRONT_MEMORY_INFO MemInfo = pNode->GetMemoryInfo();
    MemSize = MemInfo.Size;
    MemAlign = MemInfo.Align;
    MustAlign = MemInfo.IsMustAlign;
}

//--------------------------------------------------------------------
//
// XLAT_SIZE_INFO::IgnoredPointerSizes
//
// Notes:
//      
// This routine fixes up sizes for an ignored pointer
//
//--------------------------------------------------------------------


void
XLAT_SIZE_INFO::IgnoredPtrSizes()
{
    MemSize  =                  SIZEOF_MEM_PTR();
    MemAlign = (unsigned short) SIZEOF_MEM_PTR();
}

//--------------------------------------------------------------------
//
// XLAT_SIZE_INFO::ReturnSize
//
// Notes:
//
//  Copy the size information up into the parent.
//
//--------------------------------------------------------------------



void
XLAT_SIZE_INFO::ReturnSize( XLAT_SIZE_INFO & pCtxt )
{
    if ( pCtxt.MemAlign > MemAlign ) 
        MemAlign = pCtxt.MemAlign;
    MemSize = pCtxt.MemSize;

    if ( pCtxt.WireAlign > WireAlign ) 
        WireAlign = pCtxt.WireAlign;
    WireSize = pCtxt.WireSize;

    MustAlign = MustAlign || pCtxt.MustAlign;

    // note: ZeePee is NOT propogated up, only down
    // note: offsets are propogated up specially
}

//--------------------------------------------------------------------
//
// XLAT_SIZE_INFO::ReturnConfSize
//
// Notes:
//
//  Copy the size information up into the parent.
//  Don't overwrite the wire size the parent already has
//
//--------------------------------------------------------------------



void
XLAT_SIZE_INFO::ReturnConfSize( XLAT_SIZE_INFO & pCtxt )
{
    if ( pCtxt.MemAlign > MemAlign ) 
        MemAlign = pCtxt.MemAlign;
    MemSize = pCtxt.MemSize;

    if ( pCtxt.WireAlign > WireAlign ) 
        WireAlign = pCtxt.WireAlign;
    // WireSize     = pCtxt.WireSize;

    MustAlign = MustAlign || pCtxt.MustAlign;

    // note: ZeePee is NOT propogated up, only down
    // note: offsets are propogated up specially
}

//--------------------------------------------------------------------
//
// XLAT_SIZE_INFO::ReturnUnionSize
//
// Notes:
//
//  Copy the size information up into the parent.
//
//--------------------------------------------------------------------



void
XLAT_SIZE_INFO::ReturnUnionSize( XLAT_SIZE_INFO & pCtxt )
{
    if ( pCtxt.MemAlign > MemAlign )    MemAlign = pCtxt.MemAlign;
    if ( pCtxt.MemSize > MemSize )      MemSize  = pCtxt.MemSize;

    if ( pCtxt.WireAlign > WireAlign )  WireAlign = pCtxt.WireAlign;
    if ( pCtxt.WireSize > WireSize )    WireSize  = pCtxt.WireSize;

    MustAlign = MustAlign || pCtxt.MustAlign;
    
    // note: ZeePee is NOT propogated up, only down
    // note: offsets are propogated up specially
}