static bool ArraySubRange( dr_handle tsub, int index, void *_df )
/****************************************************************/
{
array_wlk_wlk *df = _df;
dr_subinfo info;
int_32 low;
int_32 high;
int_32 count;
index = index;
DRGetSubrangeInfo( tsub, &info );
/* DWARF 2.0 specifies lower bound defaults for C/C++ (0) and FORTRAN (1) */
if( info.low.val_class == DR_VAL_NOT ) {
if( IM2MODI( df->ii, df->it->im )->lang == DR_LANG_FORTRAN )
low = 1;
else
low = 0;
} else {
GetDrVal( df, &info.low, &low );
}
if( info.count.val_class == DR_VAL_NOT ){
if( info.high.val_class == DR_VAL_NOT ){
return( FALSE );
}
GetDrVal( df, &info.high, &high );
count = high - low +1;
}else{
GetDrVal( df, &info.count, &count );
}
df->low = low;
df->count *= count;
df->dim++;
return( df->cont );
}
char *DIGENTRY DIPImpModSrcLang( imp_image_handle *ii, imp_mod_handle im )
{
char *ret = NULL;
if( im == IMH_NOMOD ) {
DCStatus( DS_FAIL );
return( NULL );
}
switch( IM2MODI( ii, im )->lang ) {
case DR_LANG_UNKNOWN:
// ret = "unknown";
ret = "c";
break;
case DR_LANG_CPLUSPLUS:
ret = "cpp";
break;
case DR_LANG_FORTRAN:
ret = "fortran";
break;
case DR_LANG_C:
ret = "c";
break;
}
return( ret );
}
void SetModPubNames( imp_image_handle *ii, dr_handle mod_handle )
/****************************************************************/
{
imp_mod_handle im;
im = Dwarf2Mod( ii, mod_handle );
if( im != IMH_NOMOD ) {
IM2MODI( ii, im )->has_pubnames = TRUE;
}
}
unsigned DIGENTRY DIPImpModName( imp_image_handle *ii,
imp_mod_handle im, char *buff, unsigned max )
{
char *name;
unsigned len;
if( im == IMH_NOMOD || (name = IM2MODI( ii, im )->name) == NULL ) {
DCStatus( DS_FAIL );
return( 0 );
}
len = NameCopy( buff, name, max );
return( len );
}
static bool GetStrLen( imp_image_handle *ii,
dr_handle dr_sym,
location_context *lc,
dr_typeinfo *ret ){
// Find value of scalar
uint_32 seg;
location_list src;
location_list dst;
imp_mod_handle im;
union{
long l;
short s;
char c;
}val;
unsigned idx_size;
mod_info *modinfo;
im = DwarfMod( ii, dr_sym );
if( im == IMH_NOMOD ){
return( FALSE );
}
modinfo = IM2MODI( ii, im );
if( modinfo->is_segment == FALSE ){
seg = SEG_DATA; // if flat hoke segment
}else{
EvalSeg( ii, dr_sym, &seg );
}
if( EvalLocation( ii, lc, dr_sym, seg, &src ) != DS_OK ){
return( FALSE );
}
idx_size = ret->size;
if( idx_size == 0 ){
idx_size = modinfo->addr_size;
}
LocationCreate( &dst, LT_INTERNAL, &val );
if( DCAssignLocation( &dst, &src, idx_size ) != DS_OK ){
return( FALSE );
}
switch( idx_size ){
case 1:
ret->size = val.c;
break;
case 2:
ret->size = val.s;
break;
case 4:
ret->size = val.l;
break;
}
return( TRUE );
}
dip_status DIGENTRY DIPImpModInfo( imp_image_handle *ii,
imp_mod_handle im, handle_kind hk )
{
/*
Return DS_OK if the module has the kind of information indicated
by 'hk', DS_FAIL if it does not.
*/
dip_status ret;
dr_handle stmts;
mod_info *modinfo;
ret = DS_FAIL;
if( im == IMH_NOMOD ) {
DCStatus( ret );
return( ret );
}
modinfo = IM2MODI( ii, im );
switch( hk ) {
case HK_IMAGE:
break;
case HK_TYPE:
if( modinfo->stmts != 0 ) {
ret = DS_OK;
}
break;
case HK_CUE:
stmts = modinfo->stmts;
if( stmts != 0 ) { // need to get rid of stmts for file with no cues
l_walk_info walk;
address a;
walk.ii = ii;
walk.im = im;
walk.ret = &a;
DRSetDebug( ii->dwarf->handle ); /* set dwarf to image */
if( !DRWalkLines( stmts, SEG_CODE, ALineCue, &walk ) ) {
ret = DS_OK;
}
}
break;
case HK_SYM: /* if no lang assumed linker generated */
if( modinfo->lang != DR_LANG_UNKNOWN ) {
ret = DS_OK;
}
break;
default:
break;
}
return( ret );
}
walk_result DIGENTRY DIPImpWalkTypeList( imp_image_handle *ii,
imp_mod_handle im, IMP_TYPE_WKR *wk, imp_type_handle *it,
void *d )
{
dr_handle cu_tag;
struct mod_type typ_wlk;
DRSetDebug( ii->dwarf->handle ); /* must do at each interface */
cu_tag = IM2MODI( ii, im )->cu_tag;
typ_wlk.ii = ii;
typ_wlk.im = im;
typ_wlk.wk = wk;
typ_wlk.it = it;
typ_wlk.d = d;
DRWalkModTypes( cu_tag, AType, &typ_wlk );
return( typ_wlk.wr );
}
address DIGENTRY DIPImpModAddr( imp_image_handle *ii, imp_mod_handle im )
{
l_walk_info walk;
address a;
dr_handle stmts;
if( im != IMH_NOMOD && (stmts = IM2MODI( ii, im )->stmts) != 0 ) {
DRSetDebug( ii->dwarf->handle ); /* must do at each call into dwarf */
walk.ii = ii;
walk.im = im;
walk.ret = &a;
if( !DRWalkLines( stmts, SEG_CODE, AModAddr, &walk ) ) {
// found
return( a );
}
}
DCStatus( DS_FAIL );
return( NilAddr );
}
static bool GetSymVal( imp_image_handle *ii,
dr_handle dr_sym, location_context *lc,
int_32 *ret ){
// Find value of scalar
dr_handle dr_type;
dr_typeinfo typeinfo[1];
imp_mod_handle im;
uint_32 seg;
location_list src;
location_list dst;
dr_type = DRGetTypeAT( dr_sym );
if( dr_type == 0 ) {
return( FALSE );
}
DRGetTypeInfo( dr_type, typeinfo );
if( typeinfo->size > sizeof( *ret ) ){
return( FALSE );
}
im = DwarfMod( ii, dr_sym );
if( im == IMH_NOMOD ){
return( FALSE );
}
if( IM2MODI( ii, im )->is_segment == FALSE ){
seg = SEG_DATA; // if flat hoke segment
}else{
EvalSeg( ii, dr_sym, &seg );
}
if( EvalLocation( ii, lc, dr_sym, seg, &src ) != DS_OK ){
return( FALSE );
}
LocationCreate( &dst, LT_INTERNAL, ret );
if( DCAssignLocation( &dst, &src, typeinfo->size ) != DS_OK ){
return( FALSE );
}
return( TRUE );
}
dip_status DIGENTRY DIPImpModDefault( imp_image_handle *ii,
imp_mod_handle im, default_kind dk, dip_type_info *ti )
{
/*
Return the default type information for indicated type. The
client uses this to figure out how big a default 'int', code pointer,
and data pointer should be. The information depends on whether
the 16 or 32-bit compiler was used, and what memory model the
source file was compiled with.
*/
mod_info *modinfo;
//TODO: finish
modinfo = IM2MODI( ii, im );
ti->size = modinfo->addr_size;
switch( dk ) {
case DK_INT:
ti->kind = TK_INTEGER;
ti->modifier = TM_SIGNED;
break;
case DK_DATA_PTR:
case DK_CODE_PTR:
ti->kind = TK_POINTER;
switch( modinfo->model ) {
case DR_MODEL_NONE:
case DR_MODEL_FLAT:
case DR_MODEL_SMALL:
ti->modifier = TM_NEAR;
break;
case DR_MODEL_MEDIUM:
if( dk == DK_CODE_PTR ) {
ti->modifier = TM_FAR;
ti->size += 2;
} else {
ti->modifier = TM_NEAR;
}
break;
case DR_MODEL_COMPACT:
if( dk == DK_CODE_PTR ) {
ti->modifier = TM_NEAR;
} else {
ti->modifier = TM_FAR;
ti->size += 2;
}
break;
case DR_MODEL_LARGE:
ti->modifier = TM_FAR;
ti->size += 2;
break;
case DR_MODEL_HUGE:
if( dk == DK_CODE_PTR ) {
ti->modifier = TM_FAR;
} else {
ti->modifier = TM_HUGE;
}
ti->size += 2;
break;
}
}
return( DS_OK );
}
static void InitTypeHandle( imp_image_handle *ii,
imp_type_handle *it,
location_context *lc ){
/***********************************************************************/
//Set type handle to the base state
//If array poise at first index
imp_type_handle sub;
dr_array_info info;
dr_handle btype;
dr_array_stat stat;
uint_32 base_stride;
uint_32 n_el;
if( it->state == DF_NOT ) {
DRSetDebug( ii->dwarf->handle ); /* must do at each call into dwarf */
DRGetTypeInfo( it->type, &it->typeinfo );
it->state = DF_SET;
it->sub_array = FALSE;
if( it->typeinfo.kind == DR_TYPEK_ARRAY ){
if( it->typeinfo.size == 0 ){
btype = DRSkipTypeChain( it->type ); /* skip modifiers and typedefs */
stat = DRGetArrayInfo( btype, &info );
if( stat & DR_ARRAY_STRIDE_SIZE ){
base_stride = info.stride_size/8;
}else{
btype = DRGetTypeAT( btype ); /* get base type */
sub.type = btype;
sub.im = it->im;
sub.state = DF_NOT;
InitTypeHandle( ii, &sub, lc );
base_stride = sub.typeinfo.size;
}
it->array.base_stride = base_stride;
it->array.column_major = 0; /* 1 for fortran */
if( stat & DR_ARRAY_ORDERING ){
if( info.ordering == DW_ORD_col_major ){
it->array.column_major = 1;
}
}else if( IM2MODI( ii, it->im )->lang == DR_LANG_FORTRAN ){
it->array.column_major = 1;
}
if( info.child == 0 ) { // set info now
it->array.dims = 1;
it->array.low = 0;
it->array.index = 0;
if( stat & DR_ARRAY_COUNT ){
if( info.count == 0 ){ // ie char (*x)[]
info.count = 1;
}
it->typeinfo.size = info.count * it->array.base_stride;
it->array.num_elts= info.count;
}else{
it->typeinfo.size = it->array.base_stride;
}
if( !it->array.column_major ){
base_stride = it->typeinfo.size;
n_el = it->array.num_elts;
base_stride = n_el ? base_stride / n_el : 0;
it->array.base_stride = base_stride;
}
it->array.is_set = TRUE;
it->array.is_based = FALSE;
it->sub_array = FALSE;
}else{
it->sub_array = TRUE;
it->array.is_set = FALSE;
it->array.index = GetArrayDim( info.child, 0 );
}
}
}else if( it->typeinfo.kind == DR_TYPEK_STRING ){
if( DRStringLengthAT( it->type ) ) {
if( !GetStrLen( ii, it->type, lc, &it->typeinfo ) ){
it->typeinfo.size = 1;
}
}
}
}
if( it->typeinfo.kind == DR_TYPEK_ARRAY ){
if( it->array.is_set == FALSE ){
GetArraySize( ii, it, lc );
}else if( it->array.is_based ){
GetArraySubSize( ii, it, lc );
}
}
}
