bool DRConstValAT( dr_handle var, uint_32 *ret )
/**********************************************/
{
dr_handle abbrev;
unsigned form;
uint_32 val;
dwr_formcl formcl;
abbrev = DWRGetAbbrev( &var );
if( DWRScanForAttrib( &abbrev, &var, DW_AT_const_value ) ) {
form = DWRVMReadULEB128( &abbrev );
for( ;; ) {
formcl = DWRFormClass( form );
switch( formcl ) {
case DWR_FORMCL_indirect:
form = DWRVMReadULEB128( &var );
break;
case DWR_FORMCL_data:
val = ReadConst( form, var );
*ret = val;
goto found;
default:
goto not_found;
}
}
}
not_found:
return( FALSE );
found:
return( TRUE );
}
static size_t GetNameBuffAttr( drmem_hdl entry, char *buff, size_t length, dw_atnum attrib )
/******************************************************************************************/
{
drmem_hdl abbrev;
dw_formnum form;
abbrev = DWRSkipTag( &entry ) + 1;
if( DWRScanForAttrib( &abbrev, &entry, attrib ) ) {
form = DWRVMReadULEB128( &abbrev );
switch( form ) {
case DW_FORM_string:
length = DWRVMGetStrBuff( entry, buff, length );
break;
case DW_FORM_strp:
{
unsigned_32 offset;
drmem_hdl dbgsec_str;
offset = ReadConst( DW_FORM_data4, entry );
dbgsec_str = DWRCurrNode->sections[DR_DEBUG_STR].base + offset;
length = DWRVMGetStrBuff( dbgsec_str, buff, length );
}
break;
default:
DWREXCEPT( DREXCEP_BAD_DBG_INFO );
length = 0;
}
} else {
length = 0;
}
return( length );
}
extern dr_handle DRSkipTypeChain( dr_handle tref )
/************************************************/
// skip modifiers and typedefs
{
dr_handle abbrev;
dr_handle entry;
uint_32 tag;
for( ;; ) {
entry = tref;
abbrev = DWRVMReadULEB128( &entry );
abbrev = DWRLookupAbbrev( entry, abbrev );
tag = DWRVMReadULEB128( &abbrev );
++abbrev; /* skip child flag */
switch( tag ) {
case DW_TAG_const_type:
case DW_TAG_volatile_type:
case DW_TAG_packed_type:
case DW_TAG_typedef:
break;
default:
goto end_loop;
}
if( DWRScanForAttrib( &abbrev, &entry, DW_AT_type ) ) {
entry = DWRReadReference( abbrev, entry );
tref = entry;
} else {
tref = 0;
goto end_loop;
}
} end_loop:;
return( tref );
}
static dr_language GetLanguage( drmem_hdl abbrev, drmem_hdl mod )
/***************************************************************/
{
dr_language result;
dw_langnum lang;
result = DR_LANG_UNKNOWN;
if( DWRScanForAttrib( &abbrev, &mod, DW_AT_language ) ) {
lang = (dw_langnum)DWRReadConstant( abbrev, mod );
switch( lang ) {
case DW_LANG_C89:
case DW_LANG_C:
result = DR_LANG_C;
break;
case DW_LANG_C_plus_plus:
result = DR_LANG_CPLUSPLUS;
break;
case DW_LANG_Fortran77:
case DW_LANG_Fortran90:
result = DR_LANG_FORTRAN;
break;
}
}
return( result );
}
bool DRIsSymDefined( drmem_hdl entry )
/************************************/
{
drmem_hdl abbrev;
abbrev = DWRSkipTag( &entry ) + 1;
return( !DWRScanForAttrib( &abbrev, &entry, DW_AT_declaration ) );
}
dr_virtuality DRGetVirtuality( drmem_hdl entry )
/**********************************************/
{
drmem_hdl abbrev;
abbrev = DWRSkipTag( &entry ) + 1;
if( DWRScanForAttrib( &abbrev, &entry, DW_AT_virtuality ) ) {
return( (dr_virtuality)DWRReadConstant( abbrev, entry ) );
}
return( DR_VIRTUALITY_NONE );
}
bool DRIsStatic( drmem_hdl entry )
/********************************/
{
drmem_hdl abbrev;
abbrev = DWRSkipTag( &entry ) + 1;
if( DWRScanForAttrib( &abbrev, &entry, DW_AT_external ) ) {
return( DWRReadFlag( abbrev, entry ) == 0 );
}
return( false );
}
dr_access DRGetAccess( drmem_hdl entry )
/**************************************/
{
drmem_hdl abbrev;
abbrev = DWRSkipTag( &entry ) + 1;
if( DWRScanForAttrib( &abbrev, &entry, DW_AT_accessibility ) ) {
return( (dr_access)DWRReadConstant( abbrev, entry ) );
}
return( DR_ACCESS_PUBLIC );
}
unsigned DRGetByteSize( drmem_hdl entry )
/***************************************/
{
drmem_hdl abbrev;
abbrev = DWRSkipTag( &entry ) + 1;
if( DWRScanForAttrib( &abbrev, &entry, DW_AT_byte_size ) ) {
return( DWRReadConstant( abbrev, entry ) );
}
return( 0 );
}
bool DRIsArtificial( drmem_hdl entry )
/************************************/
{
drmem_hdl abbrev;
abbrev = DWRSkipTag( &entry ) + 1;
if( DWRScanForAttrib( &abbrev, &entry, DW_AT_artificial ) ) {
return( DWRReadFlag( abbrev, entry ) != 0 );
}
return( false );
}
static bool GrabLineAddr( drmem_hdl abbrev, drmem_hdl mod, mod_scan_info *x, void *data )
/***************************************************************************************/
/* this is called by ScanCompileUnit with abbrevptr and dataptr pointing at
* the start of a compile unit die. This picks out the line number info.
* offset, and stores it in data */
{
x = x; // to avoid a warning
if( DWRScanForAttrib( &abbrev, &mod, DW_AT_stmt_list ) ) {
*((unsigned_32 *)data) = DWRReadConstant( abbrev, mod );
}
return( false ); // do not continue with the search.
}
extern dr_handle DRGetTypeAT( dr_handle entry )
/*********************************************/
{
dr_handle abbrev;
dr_handle type;
abbrev = DWRGetAbbrev( &entry );
type = 0;
if( DWRScanForAttrib( &abbrev, &entry, DW_AT_type ) ) {
type = DWRReadReference( abbrev, entry );
}
return( type );
}
long DRGetLine( drmem_hdl entry )
/**************************************/
// NYI: this is not going to work for macros.
{
long retval;
drmem_hdl abbrev;
retval = -1; // signifies no column available
abbrev = DWRSkipTag( &entry ) + 1;
if( DWRScanForAttrib( &abbrev, &entry, DW_AT_decl_line ) ) {
retval = DWRReadConstant( abbrev, entry );
}
return( retval );
}
char *DRGetProducer( drmem_hdl entry )
/************************************/
{
drmem_hdl abbrev;
char *name;
abbrev = DWRSkipTag( &entry ) + 1;
if( DWRScanForAttrib( &abbrev, &entry, DW_AT_producer ) ) {
name = DWRReadString( abbrev, entry );
} else {
name = NULL;
}
return( name );
}
drmem_hdl DRDebugPCHDef( drmem_hdl entry )
/****************************************/
{
drmem_hdl abbrev;
drmem_hdl ret;
abbrev = DWRSkipTag( &entry ) + 1;
if( DWRScanForAttrib( &abbrev, &entry, DW_AT_base_types ) ) {
ret = DWRReadReference( abbrev, entry );
} else {
ret = DRMEM_HDL_NULL;
}
return( ret );
}
dr_model DRGetMemModelAT( drmem_hdl entry )
/*****************************************/
{
drmem_hdl abbrev;
dr_model retval;
abbrev = DWRSkipTag( &entry ) + 1;
if( DWRScanForAttrib( &abbrev, &entry, DW_AT_WATCOM_memory_model ) ) {
retval = (dr_model)DWRReadConstant( abbrev, entry );
} else {
retval = DR_MODEL_NONE;
}
return( retval );
}
drmem_hdl DRGetContaining( drmem_hdl entry )
/******************************************/
{
drmem_hdl abbrev;
drmem_hdl ret;
abbrev = DWRSkipTag( &entry ) + 1;
if( DWRScanForAttrib( &abbrev, &entry, DW_AT_containing_type ) ) {
ret = DWRReadReference( abbrev, entry );
} else {
ret = DRMEM_HDL_NULL;
}
return( ret );
}
extern char *DRGetFileName( drmem_hdl entry )
/*******************************************/
{
drmem_hdl abbrev;
char * name;
dr_fileidx fileidx;
name = NULL;
abbrev = DWRSkipTag( &entry ) + 1;
if( DWRScanForAttrib( &abbrev, &entry, DW_AT_decl_file ) ) {
fileidx = (dr_fileidx)DWRReadConstant( abbrev, entry );
name = DWRFindFileName( fileidx, entry );
}
return( name );
}
bool DRStartScopeAT( drmem_hdl entry, uint_32 *num )
/**************************************************/
{
drmem_hdl abbrev;
uint_32 offset;
bool ret;
abbrev = DWRSkipTag( &entry ) + 1;
if( DWRScanForAttrib( &abbrev, &entry, DW_AT_start_scope ) ) {
offset = DWRReadConstant( abbrev, entry );
*num = offset;
ret = true;
} else {
ret = false;
}
return( ret );
}
bool DRGetHighPc( drmem_hdl entry, uint_32 *num )
/***********************************************/
{
drmem_hdl abbrev;
uint_32 offset;
bool ret;
abbrev = DWRSkipTag( &entry ) + 1;
if( DWRScanForAttrib( &abbrev, &entry, DW_AT_high_pc ) ) {
offset = DWRReadAddr( abbrev, entry );
*num = offset;
ret = true;
} else {
ret = false;
}
return( ret );
}
extern dr_ptr DRGetAddrClass( dr_handle entry )
/*********************************************/
{
dr_handle abbrev;
dr_ptr ret;
int value;
abbrev = DWRGetAbbrev( &entry );
if( DWRScanForAttrib( &abbrev, &entry, DW_AT_address_class ) ) {
value = DWRReadConstant( abbrev, entry );
} else {
value = DW_ADDR_none;
}
switch( value ) {
case DW_ADDR_none:
ret = DR_PTR_none;
break;
case DW_ADDR_near16:
ret = DR_PTR_near16;
break;
case DW_ADDR_far16:
ret = DR_PTR_far16;
break;
case DW_ADDR_huge16:
ret = DR_PTR_huge16;
break;
case DW_ADDR_near32:
ret = DR_PTR_near32;
break;
case DW_ADDR_far32:
ret = DR_PTR_far32;
break;
default:
ret = 0;
break;
}
return( ret );
}
extern bool DRGetTypeInfo( dr_handle entry, dr_typeinfo *info )
/**************************************************************/
// Assume entry is pointing at start of a type
{
dr_handle curr_ab;
dr_handle abbrev;
dr_handle curr_ent;
dw_tagnum tag;
uint_32 value;
dr_typek kind;
info->acc = DR_STORE_NONE;
info->mclass = DR_MOD_NONE;
kind = 0;
for( ;; ) {
if( entry == DR_HANDLE_VOID ) {
info->kind = DR_TYPEK_VOID;
info->mclass = DR_MOD_BASE;
info->size = 0;
info->modifier.sign = FALSE;
return( TRUE );
}
abbrev = DWRVMReadULEB128( &entry );
abbrev = DWRLookupAbbrev( entry, abbrev );
tag = DWRVMReadULEB128( &abbrev );
++abbrev; /* skip child flag */
switch( tag ) {
case DW_TAG_array_type:
kind = DR_TYPEK_ARRAY;
goto end_loop;
case DW_TAG_enumeration_type:
kind = DR_TYPEK_ENUM;
info->mclass = DR_MOD_BASE;
goto end_loop;
case DW_TAG_pointer_type:
kind = DR_TYPEK_POINTER;
info->mclass = DR_MOD_ADDR;
goto end_loop;
case DW_TAG_string_type:
kind = DR_TYPEK_STRING;
goto end_loop;
case DW_TAG_structure_type:
kind = DR_TYPEK_STRUCT;
goto end_loop;
case DW_TAG_union_type:
kind = DR_TYPEK_UNION;
goto end_loop;
case DW_TAG_class_type:
kind = DR_TYPEK_CLASS;
goto end_loop;
case DW_TAG_subprogram:
case DW_TAG_subroutine_type:
kind = DR_TYPEK_FUNCTION;
goto end_loop;
case DW_TAG_reference_type:
kind = DR_TYPEK_REF;
info->mclass = DR_MOD_ADDR;
goto end_loop;
case DW_TAG_ptr_to_member_type:
kind = DR_TYPEK_ADDRESS;
goto end_loop;
case DW_TAG_set_type:
kind = DR_TYPEK_DATA;
goto end_loop;
case DW_TAG_subrange_type:
kind = DR_TYPEK_DATA;
info->mclass = DR_MOD_BASE;
goto end_loop;
break;
case DW_TAG_base_type:
info->mclass = DR_MOD_BASE;
goto end_loop;
case DW_TAG_file_type:
kind = DR_TYPEK_DATA;
goto end_loop;
case DW_TAG_thrown_type:
kind = DR_TYPEK_CODE;
goto end_loop;
/*** goes for loop ***/
case DW_TAG_const_type:
info->acc |= DR_STORE_CONST;
break;
case DW_TAG_volatile_type:
info->acc |= DR_STORE_VOLATILE;
break;
case DW_TAG_packed_type:
info->acc |= DR_STORE_PACKED;
break;
case DW_TAG_typedef:
break;
default:
goto error;
}
curr_ab = abbrev;
curr_ent = entry;
if( DWRScanForAttrib( &curr_ab, &curr_ent, DW_AT_type ) ) {
entry = DWRReadReference( curr_ab, curr_ent );
} else {
goto error;
}
}end_loop:;
info->kind = kind;
if( info->mclass != DR_MOD_ADDR ) {
if( DWRGetConstAT( abbrev, entry, DW_AT_byte_size, &value ) ) {
info->size = value;
} else {
info->size = 0;
}
}
switch( info->mclass ) {
case DR_MOD_BASE:
if( DWRGetConstAT( abbrev, entry, DW_AT_encoding, &value ) ) {
switch( value ) {
case DW_ATE_address:
info->kind = DR_TYPEK_ADDRESS;
info->modifier.sign = FALSE;
break;
case DW_ATE_boolean:
info->kind = DR_TYPEK_BOOL;
info->modifier.sign = FALSE;
break;
case DW_ATE_complex_float:
info->kind = DR_TYPEK_COMPLEX;
break;
case DW_ATE_float:
info->kind = DR_TYPEK_REAL;
break;
case DW_ATE_signed:
info->kind = DR_TYPEK_INTEGER;
info->modifier.sign = TRUE;
break;
case DW_ATE_signed_char:
info->kind = DR_TYPEK_CHAR;
info->modifier.sign = TRUE;
break;
case DW_ATE_unsigned:
info->kind = DR_TYPEK_INTEGER;
info->modifier.sign = FALSE;
break;
case DW_ATE_unsigned_char:
info->kind = DR_TYPEK_CHAR;
info->modifier.sign = FALSE;
break;
default:
goto error;
}
} else {
info->modifier.sign = FALSE;
}
break;
case DR_MOD_ADDR:
if( !DWRGetConstAT( abbrev, entry, DW_AT_address_class, &value ) ) {
value = DW_ADDR_none;
}
switch( value ) {
case DW_ADDR_none:
info->size = DWRGetAddrSize( DWRFindCompileUnit( entry ) );
info->modifier.ptr = DR_PTR_none;
break;
case DW_ADDR_near16:
info->size = 2;
info->modifier.ptr = DR_PTR_near16;
break;
case DW_ADDR_far16:
info->size = 4;
info->modifier.ptr = DR_PTR_far16;
break;
case DW_ADDR_huge16:
info->size = 4;
info->modifier.ptr = DR_PTR_huge16;
break;
case DW_ADDR_near32:
info->size = 4;
info->modifier.ptr = DR_PTR_near32;
break;
case DW_ADDR_far32:
info->size = 6;
info->modifier.ptr = DR_PTR_far32;
break;
default:
goto error;
}
break;
}
return( TRUE );
error:
return( FALSE );
}
