static void do_out_equ(const char *name, const char *equ, uchar off)
{
char buf[MAXSTR];
char *ptr = buf;
char *const end = buf + sizeof(buf);
gl_name = 0;
if (ash.uflag & UAS_PSAM)
{
ptr = tag_addstr(ptr, end, COLOR_KEYWORD, equ);
APPCHAR(ptr, end, ' ');
APPEND(ptr, end, name);
ptr = tag_addchr(ptr, end, COLOR_SYMBOL, ',');
}
else
{
APPEND(ptr, end, name);
if(ash.uflag & UAS_EQCLN)
ptr = tag_addchr(ptr, end, COLOR_SYMBOL, ':');
APPCHAR(ptr, end, ' ');
ptr = tag_addstr(ptr, end, COLOR_KEYWORD, equ);
APPCHAR(ptr, end, ' ');
}
ptr = tag_on(ptr, end, COLOR_NUMBER);
ptr += btoa32(ptr, end-ptr, off);
tag_off(ptr, end, COLOR_NUMBER);
MakeLine(buf, 0);
}
static int out_equ(ea_t ea)
{
char buf[MAXSTR];
char *const end = buf + sizeof(buf);
segment_t *s = getseg(ea);
if ( s != NULL && s->type == SEG_IMEM && ash.a_equ != NULL)
{
char nbuf[MAXSTR];
char *name = get_name(BADADDR, ea, nbuf, sizeof(nbuf));
if ( name != NULL
&& ((ash.uflag & UAS_PBYTNODEF) == 0 || !IsPredefined(name)) )
{
get_colored_name(BADADDR, ea, buf, sizeof(buf));
uchar off = uchar(ea - get_segm_base(s));
do_out_equ(buf, ash.a_equ, off);
if ( (ash.uflag & UAS_AUBIT) == 0 && (off & 0xF8) == off )
{
char *ptr = tag_on(tail(buf), end, COLOR_SYMBOL);
APPCHAR(ptr, end, ash.uflag & UAS_NOBIT ? '_' : '.');
APPCHAR(ptr, end, '0');
tag_off(ptr, end, COLOR_SYMBOL);
for ( int i=0; i < 8; i++ )
{
const ioport_bit_t *b = find_bit(off, i);
char *p2 = ptr;
if ( b == NULL || b->name == NULL )
ptr[-1] = '0' + i;
else
p2 = tag_addstr(ptr-1, end, COLOR_HIDNAME, b->name);
tag_off(p2, end, COLOR_SYMBOL);
do_out_equ(buf, ash.a_equ, off+i);
}
MakeNull();
}
}
else
{
gl_name = 0;
MakeLine("");
}
return 1;
}
if ( ash.uflag & UAS_NODS )
{
if ( !isLoaded(ea) && s->type == SEG_CODE )
{
adiff_t org = ea - get_segm_base(s) + get_item_size(ea);
btoa(buf, sizeof(buf), org);
printf_line(inf.indent, COLSTR("%s %s", SCOLOR_ASMDIR), ash.origin, buf);
return 1;
}
}
return 0;
}
//--------------------------------------------------------------------------
static void out_equ(const char *name, const char *equ, uchar off)
{
char buf[MAXSTR];
char *const end = buf + sizeof(buf);
char *p = tag_addstr(buf, end, COLOR_DNAME, name);
APPCHAR(p, end, ' ');
p = tag_addstr(p, end, COLOR_KEYWORD, equ);
APPCHAR(p, end, ' ');
p = tag_on(p, end, COLOR_NUMBER);
p += btoa(p, end-p, off);
tag_off(p, end, COLOR_NUMBER);
MakeLine(buf, 0);
}
//--------------------------------------------------------------------------
void assume(ea_t ea)
{
segreg_t *Darea = getSRarea(ea);
segment_t *Sarea = getseg(ea);
char buf[MAXSTR];
char *const end = buf + sizeof(buf);
if ( Sarea == NULL || Darea == NULL || !inf.s_assume ) return;
bool show = (ea == Sarea->startEA);
if ( show || Darea->startEA == ea )
{
bool used = false;
segreg_t our = *Darea;
segreg_t *prev = show ? NULL : getSRarea(ea-1);
char *ptr = NULL;
for ( int i=ph.regFirstSreg; i <= ph.regLastSreg; i++ )
{
if ( i == ph.regCodeSreg ) continue;
if ( prev == NULL || prev->reg(i) != our.reg(i) )
{
if ( !used )
{
ptr = tag_on(buf, end, COLOR_AUTOCMT);
APPEND(ptr, end, ash.cmnt);
APPEND(ptr, end, " assume ");
}
else
{
APPCHAR(ptr, end, ',');
APPCHAR(ptr, end, ' ');
}
used = true;
APPEND (ptr, end, ph.regNames[i]);
APPCHAR(ptr, end, ':');
if ( our.reg(i) == BADSEL )
APPEND(ptr, end, "nothing");
else
ptr += btoa(ptr, end-ptr, our.reg(i), 16);
}
}
if ( used )
{
tag_off(ptr, end, COLOR_AUTOCMT);
MakeLine(buf, inf.indent);
}
}
}
//--------------------------------------------------------------------------
// конец текста
void N78K_footer(void)
{
char buf[MAXSTR];
char *const end = buf + sizeof(buf);
if (ash.end != NULL){
MakeNull();
#if IDP_INTERFACE_VERSION > 37
char *ptr = tag_addstr(buf, end, COLOR_ASMDIR, ash.end);
char name[MAXSTR];
if (get_colored_name(BADADDR, inf.beginEA, name, sizeof(name)) != NULL){
register int i = strlen(ash.end);
do APPCHAR(ptr, end, ' '); while(++i < 8);
APPEND(ptr, end, name);
}
MakeLine(buf,inf.indent);
#else
register char *p = tag_addstr(buf, COLOR_ASMDIR, ash.end);
const char *start = get_colored_name(inf.beginEA);
if(start != NULL) {
*p++ = ' ';
strcpy(p, start);
}
MakeLine(buf);
#endif
} else gen_cmt_line("end of file");
}
static char append_char(mode_t mode)
{
if ( !(list_fmt & LIST_FILETYPE))
return '\0';
if ((list_fmt & LIST_EXEC) && S_ISREG(mode)
&& (mode & (S_IXUSR | S_IXGRP | S_IXOTH))) return '*';
return APPCHAR(mode);
}
//--------------------------------------------------------------------------
static char *get_thr_events_str(const td_thr_events_t &set)
{
static char buf[MAXSTR];
char *ptr = buf;
char *end = buf + sizeof(buf);
for ( int i=TD_MIN_EVENT_NUM; i <= TD_MAX_EVENT_NUM; i++ )
{
if ( td_eventismember(&set, i) )
{
if ( ptr != buf )
APPCHAR(ptr, end, ' ');
APPEND(ptr, end, tdb_event_name(i));
}
}
return buf;
}
//--------------------------------------------------------------------------
static const char *get_sigset_str(const sigset_t &set)
{
static char buf[MAXSTR];
char *ptr = buf;
char *end = buf + sizeof(buf);
for ( int i=0; i <= 32; i++ )
{
if ( sigismember(&set, i) )
{
if ( ptr != buf )
APPCHAR(ptr, end, ' ');
ptr += qsnprintf(ptr, end-ptr, "%d", i);
}
}
return buf;
}
// Generate disassembly footer
void footer(void) {
char buf[MAXSTR];
char *const end = buf + sizeof(buf);
if ( ash.end != NULL ) {
MakeNull();
register char *p = tag_addstr(buf, end, COLOR_ASMDIR, ash.end);
char name[MAXSTR];
if ( get_colored_name(BADADDR, inf.beginEA, name, sizeof(name)) != NULL ) {
APPCHAR(p, end, ' ');
APPEND(p, end, name);
}
MakeLine(buf, inf.indent);
}
else {
gen_cmt_line("end of file");
}
}
//--------------------------------------------------------------------------
char *debmod_t::debug_event_str(const debug_event_t *ev, char *buf, size_t bufsize)
{
char *ptr = buf;
char *end = buf + bufsize;
ptr += qsnprintf(ptr, end-ptr, "%s ea=%a",
get_event_name(ev->eid),
ev->ea);
switch ( ev->eid )
{
case PROCESS_START: // New process started
case PROCESS_ATTACH: // Attached to running process
case LIBRARY_LOAD: // New library loaded
ptr += qsnprintf(ptr, end-ptr, " base=%a size=%a rebase=%a name=%s",
ev->modinfo.base,
ev->modinfo.size,
ev->modinfo.rebase_to,
ev->modinfo.name);
break;
case PROCESS_EXIT: // Process stopped
case THREAD_EXIT: // Thread stopped
ptr += qsnprintf(ptr, end-ptr, " exit_code=%d", ev->exit_code);
break;
case BREAKPOINT: // Breakpoint reached
ptr += qsnprintf(ptr, end-ptr, " hea=%a kea=%a", ev->bpt.hea, ev->bpt.kea);
break;
case EXCEPTION: // Exception
ptr += qsnprintf(ptr, end-ptr, " code=%x can_cont=%d ea=%a info=%s",
ev->exc.code,
ev->exc.can_cont,
ev->exc.ea,
ev->exc.info);
break;
case LIBRARY_UNLOAD: // Library unloaded
case INFORMATION: // User-defined information
APPCHAR(ptr, end, ' ');
APPEND(ptr, end, ev->info);
break;
default:
break;
}
qsnprintf(ptr, end-ptr, " pid=%d tid=%d handled=%d",
ev->pid,
ev->tid,
ev->handled);
return buf;
}
//-------------------------------------------------------------------------
static bool sockaddr_to_name(
const struct sockaddr *addr,
socklen_t len,
char *buf,
size_t bufsize,
bool lookupname)
{
char *ptr = buf;
char *end = buf + bufsize;
// get dns name
if ( lookupname && getnameinfo(addr, len,
ptr, end-ptr,
NULL, 0,
NI_NAMEREQD) == 0 )
{
ptr = tail(ptr);
APPCHAR(ptr, end, '(');
}
// get ip address
if ( getnameinfo(addr, len,
ptr, end-ptr,
NULL, 0,
NI_NUMERICHOST) == 0 )
{
bool app = ptr > buf;
ptr = tail(ptr);
if ( app )
APPEND(ptr, end, ")");
}
else
{
if ( ptr > buf )
*--ptr = '\0';
}
return ptr > buf;
}
char * ctree_dumper_t::parse_ctree_item(citem_t *item, char *buf, int bufsize) const
{
char *ptr = buf;
char *endp = buf + bufsize;
// Each node will have the element type at the first line
APPEND(ptr, endp, get_ctype_name(item->op));
const cexpr_t *e = (const cexpr_t *)item;
const cinsn_t *i = (const cinsn_t *)item;
// For some item types, display additional information
switch (item->op)
{
case cot_call:
char buf[MAXSTR];
if (e->x->op == cot_obj) {
if (get_func_name(e->x->obj_ea, buf, sizeof(buf)) == NULL)
ptr += qsnprintf(ptr, endp - ptr, " sub_%a", e->x->obj_ea);
else
ptr += qsnprintf(ptr, endp - ptr, " %s", buf);
}
break;
case cot_ptr: // *x
case cot_memptr: // x->m
// Display access size for pointers
ptr += qsnprintf(ptr, endp - ptr, ".%d", e->ptrsize);
if (item->op == cot_ptr)
break;
case cot_memref: // x.m
// Display member offset for structure fields
ptr += qsnprintf(ptr, endp - ptr, " (m=%d)", e->m);
break;
case cot_obj: // v
case cot_var: // l
// Display object size for local variables and global data
ptr += qsnprintf(ptr, endp - ptr, ".%d", e->refwidth);
case cot_num: // n
case cot_helper: // arbitrary name
case cot_str: // string constant
// Display helper names and number values
APPCHAR(ptr, endp, ' ');
e->print1(ptr, endp - ptr, NULL);
tag_remove(ptr, ptr, 0);
ptr = tail(ptr);
break;
case cit_goto:
// Display target label number for gotos
ptr += qsnprintf(ptr, endp - ptr, " LABEL_%d", i->cgoto->label_num);
break;
case cit_asm:
// Display instruction block address and size for asm-statements
ptr += qsnprintf(ptr, endp - ptr, " %a.%" FMT_Z, *i->casm->begin(), i->casm->size());
break;
default:
break;
}
// The second line of the node contains the item address
ptr += qsnprintf(ptr, endp - ptr, ";ea->%a", item->ea);
if ( item->is_expr() && !e->type.empty() )
{
// For typed expressions, the third line will have
// the expression type in human readable form
APPCHAR(ptr, endp, ';');
qstring out;
if (e->type.print(&out))
{
APPEND(ptr, endp, out.c_str());
}
else
{ // could not print the type?
APPCHAR(ptr, endp, '?');
APPZERO(ptr, endp);
}
if(e->type.is_ptr())
{
tinfo_t ptr_rem = ::remove_pointer(e->type);
if(ptr_rem.is_struct())
{
qstring typenm;
ptr_rem.print(&typenm, "prefix ", 0, 0, PRTYPE_MULTI | PRTYPE_TYPE | PRTYPE_SEMI);
}
}
}
return buf;
}
char * callgraph_t::get_node_label(int n, char *buf, int bufsize) const
{
int_ea_map_t::const_iterator it = node2ea.find(n);
if ( it != node2ea.end() )
{
const citem_t *item = it->second;
char *ptr = buf;
char *endp = buf + bufsize;
// Each node will have the element type at the first line
APPEND(ptr, endp, get_ctype_name(item->op));
const cexpr_t *e = (const cexpr_t *)item;
const cinsn_t *i = (const cinsn_t *)item;
// For some item types, display additional information
switch ( item->op )
{
case cot_ptr : // *x
case cot_memptr : // x->m
// Display access size for pointers
ptr += qsnprintf(ptr, endp-ptr, ".%d", e->ptrsize);
if ( item->op == cot_ptr )
break;
case cot_memref : // x.m
// Display member offset for structure fields
ptr += qsnprintf(ptr, endp-ptr, " (m=%d)", e->m);
break;
case cot_obj : // v
case cot_var : // l
// Display object size for local variables and global data
ptr += qsnprintf(ptr, endp-ptr, ".%d", e->refwidth);
case cot_num : // n
case cot_helper : // arbitrary name
case cot_str : // string constant
// Display helper names and number values
APPCHAR(ptr, endp, ' ');
e->print1(ptr, endp-ptr, NULL);
tag_remove(ptr, ptr, 0);
ptr = tail(ptr);
break;
case cit_goto:
// Display target label number for gotos
ptr += qsnprintf(ptr, endp-ptr, " LABEL_%d", i->cgoto->label_num);
break;
case cit_asm:
// Display instruction block address and size for asm-statements
ptr += qsnprintf(ptr, endp-ptr, " %a.%"FMT_Z, *i->casm->begin(), i->casm->size());
break;
default:
break;
}
// The second line of the node contains the item address
ptr += qsnprintf(ptr, endp-ptr, "\nea: %a", item->ea);
if ( item->is_expr() && !e->type.empty() )
{
// For typed expressions, the third line will have
// the expression type in human readable form
APPCHAR(ptr, endp, '\n');
if ( print_type_to_one_line(ptr, endp-ptr, idati, e->type.u_str()) != T_NORMAL )
{ // could not print the type?
APPCHAR(ptr, endp, '?');
APPZERO(ptr, endp);
}
if(e->type.is_ptr())
{
typestring ptr_rem = remove_pointer(e->type);
if(ptr_rem.is_struct())
{
qstring typenm;
print_type_to_qstring(&typenm, "prefix ", 0,0, PRTYPE_MULTI | PRTYPE_TYPE | PRTYPE_SEMI, idati, ptr_rem.u_str());
}
}
}
}
return buf;
}
//--------------------------------------------------------------------------
void segstart(ea_t ea)
{
char buf[MAXSTR];
char *const end = buf + sizeof(buf);
segment_t *Sarea = getseg(ea);
if ( is_spec_segm(Sarea->type) ) return;
const char *align;
switch ( Sarea->align )
{
case saAbs: align = "at: "; break;
case saRelByte: align = "byte"; break;
case saRelWord: align = "word"; break;
case saRelPara: align = "para"; break;
case saRelPage: align = "page"; break;
case saRel4K: align = "4k"; break;
case saRel64Bytes: align = "64"; break;
default: align = NULL; break;
}
if ( align == NULL )
{
gen_cmt_line("Segment alignment '%s' can not be represented in assembly",
get_segment_alignment(Sarea->align));
align = "";
}
char sname[MAXNAMELEN];
char sclas[MAXNAMELEN];
get_true_segm_name(Sarea, sname, sizeof(sname));
get_segm_class(Sarea, sclas, sizeof(sclas));
char *ptr = buf + qsnprintf(buf, sizeof(buf),
SCOLOR_ON SCOLOR_ASMDIR "%-*s segment %s ",
inf.indent-1,
sname,
align);
if ( Sarea->align == saAbs )
{
ea_t absbase = get_segm_base(Sarea);
ptr += btoa(ptr, end-ptr, absbase);
APPCHAR(ptr, end, ' ');
}
const char *comb;
switch ( Sarea->comb )
{
case scPub:
case scPub2:
case scPub3: comb = ""; break;
case scCommon: comb = "common"; break;
default: comb = NULL; break;
}
if ( comb == NULL )
{
gen_cmt_line("Segment combination '%s' can not be represented in assembly",
get_segment_combination(Sarea->comb));
comb = "";
}
ptr += qsnprintf(ptr, end-ptr, "%s '%s'", comb, sclas);
tag_off(ptr, end, COLOR_ASMDIR);
MakeLine(buf, 0);
}
