static const char *get_proc_type( const struct asym *sym )
/********************************************************/
{
/* if there's no segment associated with the symbol,
add the symbol's offset size to the distance */
switch( sym->mem_type ) {
case MT_NEAR:
if ( sym->segment == NULL ) {
return( strings[LS_NEAR16 + GetSymOfssize( sym )] );
}
return( strings[LS_NEAR] );
case MT_FAR:
if ( sym->segment == NULL ) {
return( strings[LS_FAR16 + GetSymOfssize( sym )] );
}
return( strings[LS_FAR] );
}
return( " " );
}
static uint_8 * cv_write_symbol( struct dsym *symbols, struct asym *sym, uint_8 *ps, uint_8 *sbuffer )
/****************************************************************************************************/
{
int len;
int ofs;
short rectype;
uint_8 Ofssize;
struct fixup *fixup;
Ofssize = GetSymOfssize( sym );
len = GetCVStructLen( sym, Ofssize );
ps = checkflush( symbols, sbuffer, ps, 1 + sym->name_size + len );
switch ( sym->state ) {
case SYM_TYPE:
((struct cv_symrec_udt *)ps)->sr.size = sizeof( struct cv_symrec_udt ) - sizeof(uint_16) + 1 + sym->name_size;
((struct cv_symrec_udt *)ps)->sr.type = S_UDT;
if ( sym->typekind != TYPE_TYPEDEF ) {
((struct cv_symrec_udt *)ps)->typeref = sym->cv_typeref;
} else {
((struct cv_symrec_udt *)ps)->typeref = GetTyperef( sym, Ofssize );
}
/* Some typedefs won't get a valid type (<name> TYPEDEF PROTO ...).
* In such cases just skip the type!
*/
if ( ((struct cv_symrec_udt *)ps)->typeref == 0 )
return( ps );
DebugMsg(( "cv_write_symbol: TYPE=%s typeref=%Xh\n", sym->name, ((struct cv_symrec_udt *)ps)->typeref ));
rectype = FIX_VOID; /* types have no fixup */
break;
default: /* is SYM_INTERNAL */
if ( sym->isproc ) {
DebugMsg(( "cv_write_symbol: PROC=%s\n", sym->name ));
if ( Ofssize == USE16 ) {
((struct cv_symrec_lproc16 *)ps)->sr.size = sizeof( struct cv_symrec_lproc16 ) - sizeof(uint_16) + 1 + sym->name_size;
((struct cv_symrec_lproc16 *)ps)->sr.type = (sym->public ? S_GPROC16 : S_LPROC16);
((struct cv_symrec_lproc16 *)ps)->pParent = 0; /* filled by CVPACK */
((struct cv_symrec_lproc16 *)ps)->pEnd = 0; /* filled by CVPACK */
((struct cv_symrec_lproc16 *)ps)->pNext = 0; /* filled by CVPACK */
((struct cv_symrec_lproc16 *)ps)->proc_length = sym->total_size;
((struct cv_symrec_lproc16 *)ps)->debug_start = 0;
((struct cv_symrec_lproc16 *)ps)->debug_end = sym->total_size;
((struct cv_symrec_lproc16 *)ps)->offset = 0;
((struct cv_symrec_lproc16 *)ps)->segment = 0;
((struct cv_symrec_lproc16 *)ps)->proctype = 0; /* typeref */
((struct cv_symrec_lproc16 *)ps)->flags = ((sym->mem_type == MT_FAR) ? CV_TYPE_LABEL_FAR : CV_TYPE_LABEL_NEAR);
rectype = FIX_PTR16;
ofs = offsetof( struct cv_symrec_lproc16, offset );
} else {
static void log_proc( const struct asym *sym )
/********************************************/
{
struct dsym *f;
struct dsym *l;
const char *p;
struct dsym *dir = (struct dsym *)sym;
int i = sym->name_size;
char Ofssize = GetSymOfssize( sym );
const char *pdots;
pdots = (( i >= DOTSMAX ) ? "" : dots + i + 1 );
if ( Ofssize )
p = "%s %s P %-6s %08" I32_SPEC "X %-8s ";
else
p = "%s %s P %-6s %04" I32_SPEC "X %-8s ";
LstPrintf( p,
sym->name,
pdots,
get_proc_type( sym ),
sym->offset,
get_sym_seg_name( sym ));
/* externals (PROTO) don't have a size. Masm always prints 0000 or 00000000 */
LstPrintf( "%0*" I32_SPEC "X ", Ofssize > USE16 ? 8 : 4, sym->state == SYM_INTERNAL ? sym->total_size : 0 );
#ifdef DEBUG_OUT
if ( sym->fwdref )
LstPrintf( "(F) " );
#endif
if( sym->ispublic ) {
LstPrintf( "%-9s", strings[LS_PUBLIC] );
} else if ( sym->state == SYM_INTERNAL ) {
LstPrintf( "%-9s", strings[LS_PRIVATE] );
} else {
LstPrintf( sym->weak ? "*%-8s " : "%-9s ", strings[LS_EXTERNAL] );
#if DLLIMPORT
if ( sym->dll )
LstPrintf( "(%.8s) ", sym->dll->name );
#endif
}
LstPrintf( "%s", GetLanguage( sym ) );
LstNL();
/* for PROTOs, list optional altname */
if ( sym->state == SYM_EXTERNAL && sym->altname ) {
struct asym *sym2 = sym->altname;
LstPrintf( " ");
LstPrintf( p,
sym2->name,
pdots+2,
get_proc_type( sym2 ),
sym2->offset,
get_sym_seg_name( sym2 ));
LstNL();
}
/* for PROCs, list parameters and locals */
if ( sym->state == SYM_INTERNAL ) {
/* print the procedure's parameters */
if ( sym->langtype == LANG_C ||
sym->langtype == LANG_SYSCALL ||
sym->langtype == LANG_STDCALL ||
sym->langtype == LANG_FASTCALL ) {
int cnt;
/* position f2 to last param */
for ( cnt = 0, f = dir->e.procinfo->paralist; f; f = f->nextparam )
cnt++;
for ( ; cnt; cnt-- ) {
int curr;
for ( curr = 1,f = dir->e.procinfo->paralist; curr < cnt;f = f->nextparam, curr++ );
i = f->sym.name_size;
pdots = (( i >= DOTSMAX-2 ) ? "" : dots + i + 1 + 2 );
/* FASTCALL: parameter may be a text macro (=register name) */
if ( f->sym.state == SYM_TMACRO )
LstPrintf( " %s %s %-17s %s", f->sym.name, pdots, GetMemtypeString( &f->sym, NULL ), f->sym.string_ptr );
else
LstPrintf( szFmtProcStk, f->sym.name, pdots,
f->sym.is_vararg ? strings[LS_VARARG] : GetMemtypeString( &f->sym, NULL ),
#if STACKBASESUPP
GetResWName( dir->e.procinfo->basereg, NULL ),
#else
GetResWName( basereg[Ofssize], NULL ),
#endif
'+', f->sym.offset );
LstNL();
}
} else {
for ( f = dir->e.procinfo->paralist; f; f = f->nextparam ) {
i = f->sym.name_size;
pdots = (( i >= DOTSMAX-2 ) ? "" : dots + i + 1 + 2 );
LstPrintf( szFmtProcStk, f->sym.name, pdots, GetMemtypeString( &f->sym, NULL ),
#if STACKBASESUPP
GetResWName( dir->e.procinfo->basereg, NULL ),
#else
GetResWName( basereg[Ofssize], NULL ),
#endif
'+', f->sym.offset );
LstNL();
}
}
/* print the procedure's locals */
for ( l = dir->e.procinfo->locallist; l; l = l->nextlocal ) {
char buffer[32];
i = l->sym.name_size;
pdots = (( i >= DOTSMAX-2 ) ? "" : dots + i + 1 + 2);
if ( l->sym.isarray )
sprintf( buffer, "%s[%" I32_SPEC "u]", GetMemtypeString(&l->sym, NULL), l->sym.total_length );
else
strcpy( buffer, GetMemtypeString( &l->sym, NULL ) );
LstPrintf( szFmtProcStk, l->sym.name, pdots, buffer,
#if STACKBASESUPP
GetResWName( dir->e.procinfo->basereg, NULL ),
l->sym.offset >= 0 ? '+' : '-', l->sym.offset >= 0 ? l->sym.offset : - l->sym.offset );
#else
GetResWName( basereg[Ofssize], NULL ),
'-', - l->sym.offset );
#endif
LstNL();
}
for ( l = dir->e.procinfo->labellist; l ; l = l->e.nextll ) {
struct dsym *l2;
for ( l2 = l; l2; l2 = (struct dsym *)l2->sym.nextitem ) {
/* filter params and locals! */
if ( l2->sym.state == SYM_STACK || l2->sym.state == SYM_TMACRO )
continue;
i = l2->sym.name_size;
pdots = (( i >= DOTSMAX-2 ) ? "" : dots + i + 1 + 2);
if ( Ofssize )
p = " %s %s L %-6s %08" I32_SPEC "X %s";
else
p = " %s %s L %-6s %04" I32_SPEC "X %s";
LstPrintf( p,
l2->sym.name,
pdots,
get_proc_type( &l2->sym ),
l2->sym.offset,
get_sym_seg_name( &l2->sym ));
#ifdef DEBUG_OUT
if ( l2->sym.fwdref )
LstPrintf( " (F)" );
#endif
LstNL();
}
}
}
}
static const char *GetMemtypeString( const struct asym *sym, char *buffer )
/*************************************************************************/
{
const char *p;
enum memtype mem_type;
if ( (sym->mem_type & MT_SPECIAL) == 0 )
return( SimpleTypeString( sym->mem_type ) );
/* v2.05: improve display of stack vars */
mem_type = sym->mem_type;
if ( sym->state == SYM_STACK && sym->is_ptr )
mem_type = MT_PTR;
switch ( mem_type ) {
case MT_PTR:
#if AMD64_SUPPORT
if ( sym->Ofssize == USE64 )
p = strings[LS_NEAR];
else
#endif
if ( sym->isfar )
p = strings[LS_FAR16 + sym->Ofssize];
else
p = strings[LS_NEAR16 + sym->Ofssize];
if ( buffer ) { /* Currently, 'buffer' is only != NULL for typedefs */
int i;
char *b2 = buffer;
/* v2.10: improved pointer TYPEDEF display */
for ( i = sym->is_ptr; i; i-- ) {
b2 += sprintf( b2, "%s %s ", p, strings[LS_PTR] );
}
/* v2.05: added. */
if ( sym->state == SYM_TYPE && sym->typekind == TYPE_TYPEDEF ) {
//strcat( buffer, " ");
if ( sym->target_type )
strcpy( b2, sym->target_type->name );
else if ( ( sym->ptr_memtype & MT_SPECIAL ) == 0 )
strcpy( b2, SimpleTypeString( sym->ptr_memtype ) );
}
return( buffer );
}
return( p );
case MT_FAR:
if ( sym->segment )
return( strings[LS_LFAR] );
return( strings[LS_LFAR16 + GetSymOfssize( sym )] );
case MT_NEAR:
if ( sym->segment )
return( strings[LS_LNEAR] );
return( strings[LS_LNEAR16 + GetSymOfssize( sym )] );
case MT_TYPE:
if ( *(sym->type->name) ) /* there are a lot of unnamed types */
return( sym->type->name );
/* v2.04: changed */
//return( strings[LS_PTR] );
return( GetMemtypeString( sym->type, buffer ) );
//case MT_ABS: /* v2.07: MT_ABS is obsolete */
case MT_EMPTY: /* number, via EQU or = directive */
return( strings[LS_NUMBER] );
#ifdef DEBUG_OUT /* v2.11: obsolete */
case MT_PROC:
printf("GetMemtypeString: found mem_type=MT_PROC for sym=%s\n", sym->name );
break;
#endif
}
return("?");
}
