int Imp_Dlls::get_dlls(void)
{
tMPORT_DIRECTORY_ENTRY ImpDir;
ea_t dir_va;
if ( 0 == (dir_va = m_imp) )
return(-1); // no import
segment_t *seg = getseg(m_imp);
if ( !seg )
{
warning("Bad import structure");
return -2;
}
while(dir_va < seg->endEA)
{
ImpDir.ImportLookUp = get_long(dir_va+0x00);
ImpDir.TimeDateStamp = get_long(dir_va+0x04);
ImpDir.ForwardChain = get_long(dir_va+0x08);
ImpDir.NameRVA = get_long(dir_va+0x0C);
ImpDir.AddressTableRVA = get_long(dir_va+0x10);
if ( 0 == ImpDir.NameRVA )
break; // all done
add_import(ImpDir.NameRVA + loaded_base);
dir_va += 0x14; // next dir
}
return(0); // all ok
}
//----------------------------------------------------------------------
static void fixup(uint32 ea, uint32 delta, int extdef)
{
fixup_data_t fd;
fd.type = FIXUP_OFF32;
if ( extdef ) fd.type |= FIXUP_EXTDEF;
segment_t *s = getseg(delta);
fd.displacement = get_long(ea);
if ( s == NULL ) {
fd.sel = 0;
fd.off = delta;
} else {
fd.sel = (ushort)s->sel;
fd.off = delta - get_segm_base(s);
}
set_fixup(ea, &fd);
uint32 target = get_long(ea) + delta;
put_long(ea, target);
set_offset(ea, 0, 0);
cmd.ea = ea; ua_add_dref(0, target, dr_O); cmd.ea = BADADDR;
if ( target != toc_ea
&& !has_name(get_flags_novalue(ea))
&& has_name(get_flags_novalue(target)) )
{
char buf[MAXSTR];
if ( get_true_name(BADADDR, target, &buf[3], sizeof(buf)-3) != NULL )
{
buf[0] = 'T';
buf[1] = 'C';
buf[2] = '_';
do_name_anyway(ea, buf);
make_name_auto(ea);
}
}
// toc.charset(ea,XMC_TC+1,1);
}
//--------------------------------------------------------------------------
void segend(ea_t) {
#if 0
segment_t *s = getseg(ea-1);
if ( is_spec_segm(s->type) ) return;
printf_line(0,COLSTR(";%-*s ends",SCOLOR_AUTOCMT),inf.indent-2,get_segm_name(s));
#endif
}
char *get_codebuf_from_filepath(const char *filepath) {
FILE *fp = NULL;
char *codebuf = NULL;
long fsize = 0;
if (filepath == NULL) {
return NULL;
}
fp = fopen(filepath, "rb");
if (fp == NULL) {
return NULL;
}
fsize = get_filesize(fp);
if (fsize == 0) {
fclose(fp);
return NULL;
}
codebuf = (char *) getseg(fsize + 1);
memset(codebuf, 0, fsize + 1);
if (fread(codebuf, 1, fsize, fp) == -1) {
free(codebuf);
fclose(fp);
}
fclose(fp);
return codebuf;
}
//--------------------------------------------------------------------------
void segstart(ea_t ea)
{
segment_t *Sarea = getseg(ea);
if ( is_spec_segm(Sarea->type) ) return;
char sname[MAXNAMELEN];
char sclas[MAXNAMELEN];
get_segm_name(Sarea, sname, sizeof(sname));
get_segm_class(Sarea, sclas, sizeof(sclas));
printf_line(0, COLSTR("%s", SCOLOR_ASMDIR)
" "
COLSTR("%s %s", SCOLOR_AUTOCMT),
strcmp(sclas,"CODE") == 0
? ".CSEG"
: strcmp(sclas,"DATA") == 0
? ".DSEG"
: ".ESEG",
ash.cmnt,
sname);
if ( Sarea->orgbase != 0 )
{
char buf[MAX_NUMBUF];
btoa(buf, sizeof(buf), Sarea->orgbase);
printf_line(inf.indent, COLSTR("%s %s", SCOLOR_ASMDIR), ash.origin, buf);
}
}
// Generate a segment header
void idaapi gen_segm_header(ea_t ea) {
segment_t *Sarea = getseg(ea);
char sname[MAXNAMELEN];
get_segm_name(Sarea, sname, sizeof(sname));
char *segname = sname;
if ( *segname == '_' )
segname++;
if ( ash.uflag & UAS_ASW ) {
printf_line(inf.indent, COLSTR("SEGMENT %s", SCOLOR_ASMDIR),
segname);
}
else {
printf_line(inf.indent, COLSTR(".section .%s", SCOLOR_ASMDIR),
segname);
}
ea_t orgbase = ea - get_segm_para(Sarea);
if ( orgbase != 0 )
{
char buf[MAX_NUMBUF];
btoa(buf, sizeof(buf), orgbase);
printf_line(inf.indent, COLSTR("%s %s", SCOLOR_ASMDIR), ash.origin, buf);
}
}
//----------------------------------------------------------------------
//
// creates an EXPANSION ROM segment, I don't know when it is used
//
static void create_exprom_segment( void )
{
bool success = add_segm( 0, EXPROM_START_ADDRESS, EXPROM_START_ADDRESS + EXPROM_SIZE, "EXP_ROM", NULL ) == 1;
msg("creating EXP_ROM segment..%s", success ? "ok!\n" : "failure!\n");
if(!success)
return;
set_segm_addressing( getseg( EXPROM_START_ADDRESS ), 0 );
}
//----------------------------------------------------------------------
//
// creates a ROM segment where all the code is being loaded to
//
static void create_rom_segment( void )
{
bool success = add_segm( 0, ROM_START_ADDRESS, ROM_START_ADDRESS + ROM_SIZE, "ROM", CLASS_CODE ) == 1;
msg("creating ROM segment..%s", success ? "ok!\n" : "failure!\n");
if(!success)
return;
set_segm_addressing( getseg( ROM_START_ADDRESS ), 0 );
}
//----------------------------------------------------------------------
//
// creates an SRAM segment, if available on cartridge
//
static void create_sram_segment( void )
{
bool success = add_segm( 0, SRAM_START_ADDRESS, SRAM_START_ADDRESS + SRAM_SIZE, "SRAM", NULL ) == 1;
msg("creating SRAM segment..%s", success ? "ok!\n" : "failure!\n");
if(!success)
return;
set_segm_addressing( getseg( SRAM_START_ADDRESS ), 0 );
}
static void create_ext_ram_seg(ea_t &v)
{
if ( (v & 0xFF0000L) >= 0x80000L ) // these are references to code
{
v = v & 0x7FFFFL;
return;
}
if ( v && getseg(v) == NULL )
{
ea_t start = v & 0xFFFF0000L;
segment_t *sreg;
add_segm(start>>4, start, start+0x10000L, NULL, "DATA");
sreg = getseg(start);
set_segm_name(sreg, "RAM%02x", int((start&0xFF0000L)>>16));
}
//----------------------------------------------------------------------
//
// loads a 512 byte trainer (located at file offset INES_HDR_SIZE)
// to TRAINER_START_ADDRESS
//
static void load_trainer( linput_t *li )
{
if( !INES_MASK_SRAM( hdr.rom_control_byte_0 ) )
{
bool success = add_segm( 0, TRAINER_START_ADDRESS, TRAINER_START_ADDRESS + TRAINER_SIZE, "TRAINER", CLASS_CODE ) == 1;
msg("creating TRAINER segment..%s", success ? "ok!\n" : "failure!\n");
set_segm_addressing( getseg( TRAINER_START_ADDRESS ), 0 );
}
file2base(li, INES_HDR_SIZE, TRAINER_START_ADDRESS, TRAINER_START_ADDRESS + TRAINER_SIZE, FILEREG_PATCHABLE);
}
//--------------------------------------------------------------------------
// Create a section.
static void create_section(ushort sel, ea_t startEA, ea_t endEA,
const char *name, const char *classname)
{
set_selector(sel, 0);
if( !add_segm(sel, startEA, endEA, name, classname) )
loader_failure();
segment_t *s = getseg(startEA);
set_arm_segm_flags(startEA, 2 << 10); // alignment
s->update();
}
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;
}
int main() {
struct databuf *buf1, *buf2;
int semid = getsem();
getseg(&buf1, &buf2);
reader(semid, buf1, buf2);
writer(semid, buf1, buf2);
rmobj();
}
//----------------------------------------------------------------------
//
// creates a RAM segment
//
static void create_ram_segment( void )
{
bool success = add_segm( 0, RAM_START_ADDRESS, RAM_START_ADDRESS + RAM_SIZE, "RAM", NULL ) == 1;
msg("creating RAM segment..%s", success ? "ok!\n" : "failure!\n");
if(!success)
return;
set_segm_addressing( getseg( RAM_START_ADDRESS ), 0 );
// how do I properly initialize a segment ?
//for( unsigned int ea = SRAM_START_ADDRESS; ea<= SRAM_START_ADDRESS + SRAM_SIZE; ea++ )
// put_byte( ea, 0 );
}
//--------------------------------------------------------------------------
void segend(ea_t ea)
{
segment_t *Sarea = getseg(ea-1);
if ( is_spec_segm(Sarea->type) ) return;
if ( (ash.uflag & UAS_GNU) == 0 )
{
char sname[MAXNAMELEN];
get_true_segm_name(Sarea, sname, sizeof(sname));
if ( strcmp(sname, "XMEM") != 0 )
printf_line(inf.indent, "endsec");
}
}
//----------------------------------------------------------------------
static void out_address(ea_t ea, op_t &x)
{
segment_t *s = getseg(ea);
ea_t value = s != NULL ? ea - get_segm_base(s) : ea;
if ( !out_name_expr(x, ea, value) )
{
out_tagon(COLOR_ERROR);
out_snprintf("%a", ea);
out_tagoff(COLOR_ERROR);
QueueSet(Q_noName, cmd.ea);
}
}
//--------------------------------------------------------------------------
void segstart(ea_t ea)
{
segment_t *Sarea = getseg(ea);
if ( is_spec_segm(Sarea->type) ) return;
char sname[MAXNAMELEN];
char sclas[MAXNAMELEN];
get_true_segm_name(Sarea, sname, sizeof(sname));
get_segm_class(Sarea, sclas, sizeof(sclas));
if ( ash.uflag & UAS_GNU )
{
const char *const predefined[] =
{
".text", // Text section
".data", // Data sections
".rdata",
".comm",
};
int i;
for ( i=0; i < qnumber(predefined); i++ )
if ( strcmp(sname, predefined[i]) == 0 )
break;
if ( i != qnumber(predefined) )
printf_line(inf.indent, COLSTR("%s", SCOLOR_ASMDIR), sname);
else
printf_line(inf.indent, COLSTR(".section %s", SCOLOR_ASMDIR) " " COLSTR("%s %s", SCOLOR_AUTOCMT),
sname,
ash.cmnt,
sclas);
}
else
{
if ( strcmp(sname, "XMEM") == 0 )
{
char buf[MAX_NUMBUF];
btoa(buf, sizeof(buf), ea-get_segm_base(Sarea));
printf_line(inf.indent, COLSTR("%s %c:%s", SCOLOR_ASMDIR),
ash.origin,
tolower(sname[0]),
buf);
}
else
{
printf_line(inf.indent, COLSTR("section %s", SCOLOR_ASMDIR) " "
COLSTR("%s %s", SCOLOR_AUTOCMT),
sname,
ash.cmnt,
sclas);
}
}
}
ea_t
get_next_code(ea_t start)
{
segment_t *cs = getseg(start);
if ( NULL == cs )
return NULL;
for ( ; start < cs->endEA; start = get_item_end(start) )
if ( isCode(start) )
return start;
return cs->endEA;
}
//----------------------------------------------------------------------
//
// creates an I/O registers segment and names all io registers
//
static void create_ioreg_segment( void )
{
bool success = add_segm( 0, IOREGS_START_ADDRESS, IOREGS_START_ADDRESS + IOREGS_SIZE, "IO_REGS", NULL ) == 1;
msg("creating IO_REGS segment..%s", success ? "ok!\n" : "failure!\n");
if(!success)
return;
set_segm_addressing( getseg( IOREGS_START_ADDRESS ), 0 );
define_item( PPU_CR_1_ADDRESS, PPU_CR_1_SIZE, PPU_CR_1_SHORT_DESCRIPTION, PPU_CR_1_COMMENT );
define_item( PPU_CR_2_ADDRESS, PPU_CR_2_SIZE, PPU_CR_2_SHORT_DESCRIPTION, PPU_CR_2_COMMENT );
define_item( PPU_SR_ADDRESS, PPU_SR_SIZE, PPU_SR_SHORT_DESCRIPTION, PPU_SR_COMMENT );
define_item( SPR_RAM_AR_ADDRESS, SPR_RAM_AR_SIZE, SPR_RAM_AR_SHORT_DESCRIPTION, SPR_RAM_AR_COMMENT );
define_item( SPR_RAM_IOR_ADDRESS, SPR_RAM_IOR_SIZE, SPR_RAM_IOR_SHORT_DESCRIPTION, SPR_RAM_IOR_COMMENT );
define_item( VRAM_AR_1_ADDRESS, VRAM_AR_1_SIZE, VRAM_AR_1_SHORT_DESCRIPTION, VRAM_AR_1_COMMENT );
define_item( VRAM_AR_2_ADDRESS, VRAM_AR_2_SIZE, VRAM_AR_2_SHORT_DESCRIPTION, VRAM_AR_2_COMMENT );
define_item( VRAM_IOR_ADDRESS, VRAM_IOR_SIZE, VRAM_IOR_SHORT_DESCRIPTION, VRAM_IOR_COMMENT );
define_item( PAPU_PULSE_1_CR_ADDRESS, PAPU_PULSE_1_CR_SIZE, PAPU_PULSE_1_CR_SHORT_DESCRIPTION, PAPU_PULSE_1_CR_COMMENT );
define_item( PAPU_PULSE_1_RCR_ADDRESS, PAPU_PULSE_1_RCR_SIZE, PAPU_PULSE_1_RCR_SHORT_DESCRIPTION, PAPU_PULSE_1_RCR_COMMENT );
define_item( PAPU_PULSE_1_FTR_ADDRESS, PAPU_PULSE_1_FTR_SIZE, PAPU_PULSE_1_FTR_SHORT_DESCRIPTION, PAPU_PULSE_1_FTR_COMMENT );
define_item( PAPU_PULSE_1_CTR_ADDRESS, PAPU_PULSE_1_CTR_SIZE, PAPU_PULSE_1_CTR_SHORT_DESCRIPTION, PAPU_PULSE_1_CTR_COMMENT );
define_item( PAPU_PULSE_2_CR_ADDRESS, PAPU_PULSE_2_CR_SIZE, PAPU_PULSE_2_CR_SHORT_DESCRIPTION, PAPU_PULSE_2_CR_COMMENT );
define_item( PAPU_PULSE_2_RCR_ADDRESS, PAPU_PULSE_2_RCR_SIZE, PAPU_PULSE_2_RCR_SHORT_DESCRIPTION, PAPU_PULSE_2_RCR_COMMENT );
define_item( PAPU_PULSE_2_FTR_ADDRESS, PAPU_PULSE_2_FTR_SIZE, PAPU_PULSE_2_FTR_SHORT_DESCRIPTION, PAPU_PULSE_2_FTR_COMMENT );
define_item( PAPU_PULSE_2_CTR_ADDRESS, PAPU_PULSE_2_CTR_SIZE, PAPU_PULSE_2_CTR_SHORT_DESCRIPTION, PAPU_PULSE_2_CTR_COMMENT );
define_item( PAPU_TRIANGLE_CR_1_ADDRESS, PAPU_TRIANGLE_CR_1_SIZE, PAPU_TRIANGLE_CR_1_SHORT_DESCRIPTION, PAPU_TRIANGLE_CR_1_COMMENT );
define_item( PAPU_TRIANGLE_CR_2_ADDRESS, PAPU_TRIANGLE_CR_2_SIZE, PAPU_TRIANGLE_CR_2_SHORT_DESCRIPTION, PAPU_TRIANGLE_CR_2_COMMENT );
define_item( PAPU_TRIANGLE_FR_1_ADDRESS, PAPU_TRIANGLE_FR_1_SIZE, PAPU_TRIANGLE_FR_1_SHORT_DESCRIPTION, PAPU_TRIANGLE_FR_1_COMMENT );
define_item( PAPU_TRIANGLE_FR_2_ADDRESS, PAPU_TRIANGLE_FR_2_SIZE, PAPU_TRIANGLE_FR_2_SHORT_DESCRIPTION, PAPU_TRIANGLE_FR_2_COMMENT );
define_item( PAPU_NOISE_CR_1_ADDRESS, PAPU_NOISE_CR_1_SIZE, PAPU_NOISE_CR_1_SHORT_DESCRIPTION, PAPU_NOISE_CR_1_COMMENT );
define_item( PAPU_NOISE_CR_2_ADDRESS, PAPU_NOISE_CR_2_SIZE, PAPU_NOISE_CR_2_SHORT_DESCRIPTION, PAPU_NOISE_CR_2_COMMENT );
define_item( PAPU_NOISE_FR_1_ADDRESS, PAPU_NOISE_FR_1_SIZE, PAPU_NOISE_FR_1_SHORT_DESCRIPTION, PAPU_NOISE_FR_1_COMMENT );
define_item( PAPU_NOISE_FR_2_ADDRESS, PAPU_NOISE_FR_2_SIZE, PAPU_NOISE_FR_2_SHORT_DESCRIPTION, PAPU_NOISE_FR_2_COMMENT );
define_item( PAPU_DM_CR_ADDRESS, PAPU_DM_CR_SIZE, PAPU_DM_CR_SHORT_DESCRIPTION, PAPU_DM_CR_COMMENT );
define_item( PAPU_DM_DAR_ADDRESS, PAPU_DM_DAR_SIZE, PAPU_DM_DAR_SHORT_DESCRIPTION, PAPU_DM_DAR_COMMENT );
define_item( PAPU_DM_AR_ADDRESS, PAPU_DM_AR_SIZE, PAPU_DM_AR_SHORT_DESCRIPTION, PAPU_DM_AR_COMMENT );
define_item( PAPU_DM_DLR_ADDRESS, PAPU_DM_DLR_SIZE, PAPU_DM_DLR_SHORT_DESCRIPTION, PAPU_DM_DLR_COMMENT );
define_item( PAPU_SV_CSR_ADDRESS, PAPU_SV_CSR_SIZE, PAPU_SV_CSR_SHORT_DESCRIPTION, PAPU_SV_CSR_COMMENT );
define_item( SPRITE_DMAR_ADDRESS, SPRITE_DMAR_SIZE, SPRITE_DMAR_SHORT_DESCRIPTION, SPRITE_DMAR_COMMENT );
define_item( JOYPAD_1_ADDRESS, JOYPAD_1_SIZE, JOYPAD_1_SHORT_DESCRIPTION, JOYPAD_1_COMMENT );
define_item( JOYPAD_2_ADDRESS, JOYPAD_2_SIZE, JOYPAD_2_SHORT_DESCRIPTION, JOYPAD_2_COMMENT );
}
bool checkHeapSize(unsigned int base, unsigned int newaddr, unsigned int max) {
//msg("checkHeapSize: base: %x, newsize: %x, max: %x\n", base, newsize, max);
if (newaddr > max) {
return false;
}
segment_t *h = getseg(base);
if (newaddr > h->endEA) {
//need to grow our heap segment
unsigned int newsize = ((newaddr - base) + 0xFFF) & ~0xFFF;
set_segm_end(base, base + newsize, 0);
}
return true;
}
bool EmuHeap::checkHeapSize(unsigned int newsize) {
//msg("checkHeapSize: base: %x, newsize: %x, max: %x\n", base, newsize, max);
if ((base + newsize) > max) {
return false;
}
if (newsize > size) {
//need to grow our heap segment
segment_t *h = getseg(base);
unsigned int newend = (newsize + 0xFFF) & ~0xFFF; //round up to 4k boundary
set_segm_end(base, base + newend, 0);
}
return true;
}
// generate segment header
void idaapi gen_segm_header(ea_t ea)
{
segment_t *Sarea = getseg(ea);
char sname[MAXNAMELEN];
get_segm_name(Sarea, sname, sizeof(sname));
char *segname = sname;
if ( *segname == '_' )
*segname = '.';
printf_line(0, COLSTR(".section %s", SCOLOR_ASMDIR), segname);
}
//--------------------------------------------------------------------------
// For ARM processors the low bit means 1-thumb, 0-arm mode.
// The following function goes over the address list and sets the mode
// in IDA database according to bit0. It also resets bit0 for all addresses.
void set_arm_thumb_modes(ea_t *addrs, int qty)
{
for ( int i=0; i < qty; i++ )
{
ea_t ea = addrs[i];
segment_t *s = getseg(ea);
if ( s == NULL )
pending_addresses.insert(ea);
else
handle_arm_thumb_modes(ea);
addrs[i] = ea & ~1;
}
}
//--------------------------------------------------------------------------
void idaapi z8_data(ea_t ea)
{
segment_t *s = getseg(ea);
if ( s != NULL && s->type == SEG_IMEM )
{
char nbuf[MAXSTR];
char *name = get_name(BADADDR, ea, nbuf, sizeof(nbuf));
if ( name != NULL )
out_equ(name, ash.a_equ, uint16(ea - get_segm_base(s)));
}
else
intel_data(ea);
}
//----------------------------------------------------------------------
static void apply_symbols(void)
{
free_mappings();
if ( dataseg != BADADDR )
{
for ( int i=0; i < numports; i++ )
{
ea_t ea = calc_data_mem(ports[i].address);
segment_t *s = getseg(ea);
if ( s == NULL || s->type != SEG_IMEM )
continue;
doByte(ea, 1);
const char *name = ports[i].name;
if ( !set_name(ea, name, SN_NOWARN) )
set_cmt(ea, name, 0);
}
for ( segment_t *d = getseg(dataseg); d != NULL; d = get_next_seg(d->startEA) )
{
if ( d->type != SEG_IMEM )
continue;
ea_t ea = d->startEA;
ea_t dataend = d->endEA;
while ( 1 )
{
ea = next_unknown(ea, dataend);
if ( ea == BADADDR )
break;
ea_t end = nextthat(ea, dataend, f_isHead, NULL);
if ( end == BADADDR )
end = dataend;
doByte(ea, end-ea);
}
}
create_mappings();
}
}
//--------------------------------------------------------------------------
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 segstart( ea_t ea )
{
segment_t *Sarea = getseg( ea );
char name[MAXNAMELEN];
get_segm_name(Sarea, name, sizeof(name));
gen_cmt_line( COLSTR("segment %s", SCOLOR_AUTOCMT), name );
ea_t org = ea - get_segm_base( Sarea );
if ( org != 0 )
{
char buf[MAX_NUMBUF];
btoa(buf, sizeof(buf), org);
gen_cmt_line("%s %s", ash.origin, buf);
}
}
//----------------------------------------------------------------------
static void destroy_if_unnamed_array(ea_t ea)
{
flags_t F = get_flags_novalue(ea);
if ( isTail(F) && segtype(ea) == SEG_IMEM )
{
ea_t head = prev_not_tail(ea);
if ( !has_user_name(get_flags_novalue(head)) )
{
do_unknown(head, DOUNK_SIMPLE);
doByte(head, ea-head);
ea_t end = nextthat(ea, inf.maxEA, f_isHead, NULL);
if ( end == BADADDR ) end = getseg(ea)->endEA;
doByte(ea+1, end-ea-1);
}
}
}
// --------------------------------------------------------------------------
// generate start of segment
void idaapi segstart(ea_t ea) {
// generate ORG directive if necessary
if (inf.s_org)
{
// get segment data
segment_t *Sarea = getseg(ea);
size_t org = size_t(ea - get_segm_base(Sarea));
// generate line
if ( org != 0 )
{
char buf[MAX_NUMBUF];
btoa(buf, sizeof(buf), org);
printf_line(inf.indent, COLSTR("%s %s", SCOLOR_ASMDIR), ash.origin, buf);
}
}
}
