mirror of https://github.com/lianthony/NT4.0
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
526 lines
11 KiB
526 lines
11 KiB
/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
Copyright (c) 1989 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 = 8;
|
|
MemAlign = pCG->GetMemoryAlignment();
|
|
WireAlign = CvtAlignPropertyToAlign(pCG->GetWireAlignment());
|
|
MemSize = pCG->GetMemorySize();
|
|
WireSize = pCG->GetWireSize();
|
|
MemOffset = 0;
|
|
WireOffset = 0;
|
|
}
|
|
|
|
//--------------------------------------------------------------------
|
|
//
|
|
// ::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:
|
|
//
|
|
//
|
|
//
|
|
//--------------------------------------------------------------------
|
|
|
|
|
|
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_FLOAT:
|
|
case NODE_LONG:
|
|
case NODE_INT:
|
|
case NODE_POINTER:
|
|
case NODE_HANDLE_T:
|
|
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() = MS;
|
|
|
|
GetWireSize() = WS;
|
|
GetWireAlign() = WS;
|
|
|
|
};
|
|
|
|
//--------------------------------------------------------------------
|
|
//
|
|
// XLAT_SIZE_INFO::EnumTypeSizes
|
|
//
|
|
// Notes:
|
|
//
|
|
//
|
|
//
|
|
//--------------------------------------------------------------------
|
|
|
|
|
|
void
|
|
XLAT_SIZE_INFO::EnumTypeSizes( node_skl * pNode, BOOL Enum32 )
|
|
{
|
|
unsigned short MS, WS;
|
|
|
|
// note - this needs to check environment
|
|
WS = ( Enum32 ) ? 4 : 2;
|
|
MS = ( ( pCommand->GetEnv() == ENV_DOS ) ||
|
|
( pCommand->GetEnv() == ENV_WIN16) ) ? 2 : 4;
|
|
|
|
GetMemSize() = MS;
|
|
GetMemAlign() = MS;
|
|
|
|
GetWireSize() = WS;
|
|
GetWireAlign() = WS;
|
|
|
|
};
|
|
|
|
//--------------------------------------------------------------------
|
|
//
|
|
// 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 * pNode, 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
|
|
|
|
RoundToAlignment( MemSize, MemAlign );
|
|
RoundToAlignment( WireSize, WireAlign );
|
|
|
|
// compute number of elements and multiply...
|
|
|
|
unsigned long ElementCount;
|
|
|
|
ElementCount = 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 ) 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::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 )
|
|
{
|
|
MemSize = pNode->GetSize( 0, ZeePee );
|
|
MemAlign = pNode->GetMscAlign( ZeePee );
|
|
RoundToAlignment( MemSize, MemAlign );
|
|
}
|
|
|
|
//--------------------------------------------------------------------
|
|
//
|
|
// XLAT_SIZE_INFO::IgnoredPointerSizes
|
|
//
|
|
// Notes:
|
|
//
|
|
// This routine fixes up sizes for an ignored pointer
|
|
//
|
|
//--------------------------------------------------------------------
|
|
|
|
|
|
void
|
|
XLAT_SIZE_INFO::IgnoredPtrSizes()
|
|
{
|
|
MemSize = 4;
|
|
MemAlign = 4;
|
|
}
|
|
|
|
//--------------------------------------------------------------------
|
|
//
|
|
// 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;
|
|
|
|
// 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;
|
|
|
|
// 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;
|
|
|
|
// note: ZeePee is NOT propogated up, only down
|
|
// note: offsets are propogated up specially
|
|
}
|