// The kernel event notifications
// Here you may take desired actions upon some kernel events
static int notify(processor_t::idp_notify msgid, ...)
{
va_list va;
va_start(va, msgid);
// A well behavior processor module should call invoke_callbacks()
// in his notify() function. If this function returns 0, then
// the processor module should process the notification itself
// Otherwise the code should be returned to the caller:
int code = invoke_callbacks(HT_IDP, msgid, va);
if ( code ) return code;
switch ( msgid ) {
case processor_t::init:
inf.mf = 1;
helper.create("$ fr");
default:
break;
case processor_t::term:
free_ioports(ports, numports);
break;
case processor_t::newfile:
choose_device();
set_device_name(device, IORESP_ALL);
break;
case processor_t::oldfile:
{
char buf[MAXSTR];
if ( helper.supval(-1, buf, sizeof(buf)) > 0 )
set_device_name(buf, IORESP_NONE);
}
break;
case processor_t::closebase:
case processor_t::savebase:
helper.supset(-1, device);
break;
}
va_end(va);
return(1);
}
static int notify(processor_t::idp_notify msgid, ...)
{
va_list va;
va_start(va, msgid);
// A well behaving processor module should call invoke_callbacks()
// in his notify() function. If this function returns 0, then
// the processor module should process the notification itself
// Otherwise the code should be returned to the caller:
int code = invoke_callbacks(HT_IDP, msgid, va);
if ( code ) return code;
switch ( msgid )
{
case processor_t::init:
helper.create("$ tms320c54");
{
char buf[MAXSTR];
if ( helper.supval(0, buf, sizeof(buf)) > 0 )
set_device_name(buf);
}
inf.mf = 1; // MSB first
break;
case processor_t::term:
free_ioports(ports, numports);
default:
break;
case processor_t::newfile: // new file loaded
{
{
SetDefaultRegisterValue(NULL, ARMS, 0);
SetDefaultRegisterValue(NULL, CPL, 1);
for (int i = DP; i <= rVds; i++)
SetDefaultRegisterValue(NULL, i, 0);
}
static const char informations[] =
{
"AUTOHIDE REGISTRY\n"
"Default values of flags and registers:\n"
"\n"
"ARMS bit = 0 (DSP mode operands).\n"
"CPL bit = 1 (SP direct addressing mode).\n"
"DP register = 0 (Data Page register)\n"
"DPH register = 0 (High part of EXTENDED Data Page Register)\n"
"PDP register = 0 (Peripheral Data Page register)\n"
"\n"
"You can change the register values by pressing Alt-G\n"
"(Edit, Segments, Change segment register value)\n"
};
info(informations);
break;
}
case processor_t::oldfile: // old file loaded
idpflags = (ushort)helper.altval(-1);
break;
case processor_t::closebase:
case processor_t::savebase:
helper.altset(-1, idpflags);
helper.supset(0, device);
break;
case processor_t::newprc: // new processor type
{
ptype = ptypes[va_arg(va, int)];
switch ( ptype )
{
case TMS320C55:
break;
default:
error("interr: setprc");
break;
}
device[0] = '\0';
load_symbols();
}
break;
case processor_t::newasm: // new assembler type
break;
case processor_t::newseg: // new segment
break;
case processor_t::get_stkvar_scale_factor:
return 2;
}
va_end(va);
return 1;
}
// The kernel event notifications
// Here you may take desired actions upon some kernel events
static int notify(processor_t::idp_notify msgid, ...)
{
va_list va;
va_start(va, msgid);
// A well behavior processor module should call invoke_callbacks()
// in his notify() function. If this function returns 0, then
// the processor module should process the notification itself
// Otherwise the code should be returned to the caller:
int code = invoke_callbacks(HT_IDP, msgid, va);
if ( code ) return code;
switch ( msgid ) {
case processor_t::newfile:
helper.create("$ m7700");
if ( choose_device() )
set_device_name(device, IORESP_ALL);
// Set the default segment register values :
// -1 (badsel) for DR
// 0 for fM and fX
for ( segment_t *s=get_first_seg(); s != NULL; s=get_next_seg(s->startEA) )
{
SetDefaultRegisterValue(s, rDR, BADSEL);
SetDefaultRegisterValue(s, rfM, 0);
SetDefaultRegisterValue(s, rfX, 0);
}
info(m7700_help_message);
break;
case processor_t::term:
free_ioports(ports, numports);
default:
break;
case processor_t::newprc:
ptype = processor_subtype_t(va_arg(va, int));
break;
case processor_t::setsgr:
{
ea_t ea1 = va_arg(va, ea_t);
ea_t ea2 = va_arg(va, ea_t);
int reg = va_arg(va, int);
sel_t v = va_arg(va, sel_t);
sel_t ov = va_arg(va, sel_t);
if ( (reg == rfM || reg == rfX) && v != ov )
set_sreg_at_next_code(ea1, ea2, reg, ov);
}
break;
case processor_t::oldfile:
helper.create("$ m7700");
{
char buf[MAXSTR];
if ( helper.supval(-1, buf, sizeof(buf)) > 0 )
set_device_name(buf, IORESP_ALL);
}
break;
case processor_t::savebase:
case processor_t::closebase:
helper.supset(-1, device);
break;
}
va_end(va);
return(1);
}
// The kernel event notifications
// Here you may take desired actions upon some kernel events
static int notify(processor_t::idp_notify msgid, ...)
{
va_list va;
va_start(va, msgid);
// A well behavior processor module should call invoke_callbacks()
// in his notify() function. If this function returns 0, then
// the processor module should process the notification itself
// Otherwise the code should be returned to the caller:
int code = invoke_callbacks(HT_IDP, msgid, va);
if ( code ) return code;
switch ( msgid ) {
case processor_t::init:
// this processor is big endian
inf.mf = 1;
default:
break;
case processor_t::term:
free_ioports(ports, numports);
break;
case processor_t::newfile:
if ( choose_ioport_device(cfgname, device, sizeof(device), NULL) )
set_device_name(device, IORESP_ALL);
// default configuration
if ( refresh_idpflags() == 0 ) {
idpflags = 0;
idpflags |= NETNODE_USE_INSN_SYNTHETIC;
idpflags |= NETNODE_USE_REG_ALIASES;
}
// patch register names according to idpflags
patch_regnames();
break;
case processor_t::newprc:
ptype = processor_subtype_t(va_arg(va, int));
// msg("ptype = %s\n", ptype == prc_m32r ? "m32r" : ptype == prc_m32rx ? "m32rx" : "???");
break;
case processor_t::oldfile:
refresh_idpflags();
{
char buf[MAXSTR];
if ( helper.supval(-1, buf, sizeof(buf)) > 0 )
set_device_name(buf, IORESP_NONE);
}
// patch register names according to idpflags
patch_regnames();
break;
case processor_t::savebase:
case processor_t::closebase:
// synchronize the database long variable with the current configuration settings
#ifdef DEBUG
msg("Saving configuration: synthetic insn %s, aliases registers %s\n",
use_synthetic_insn() ? "true " : "false",
use_reg_aliases() ? "true" : "false"
);
#endif
helper.altset(-1, idpflags);
helper.supset(-1, device);
break;
}
va_end(va);
return(1);
}
static int idaapi notify(processor_t::idp_notify msgid, ...)
{
va_list va;
va_start(va, msgid);
// A well behaving processor module should call invoke_callbacks()
// in his notify() function. If this function returns 0, then
// the processor module should process the notification itself
// Otherwise the code should be returned to the caller:
int code = invoke_callbacks(HT_IDP, msgid, va);
if ( code ) return code;
switch ( msgid )
{
case processor_t::init:
// __emit__(0xCC); // debugger trap
helper.create("$ h8");
helper.supval(0, device, sizeof(device));
inf.mf = 1;
default:
break;
/* +++ START TYPEINFO CALLBACKS +++ */
// see module/{i960,hppa}/reg.cpp starting on line 253
// Decorate/undecorate a C symbol name
// Arguments:
// const til_t *ti - pointer to til
// const char *name - name of symbol
// const type_t *type - type of symbol. If NULL then it will try to guess.
// char *outbuf - output buffer
// size_t bufsize - size of the output buffer
// bool mangle - true-mangle, false-unmangle
// cm_t cc - real calling convention for VOIDARG functions
// returns: true if success
case processor_t::decorate_name:
{
const til_t *ti = va_arg(va, const til_t *);
const char *name = va_arg(va, const char *);
const type_t *type = va_arg(va, const type_t *);
char *outbuf = va_arg(va, char *);
size_t bufsize = va_arg(va, size_t);
bool mangle = va_argi(va, bool);
cm_t real_cc = va_argi(va, cm_t);
return gen_decorate_name(ti, name, type, outbuf, bufsize, mangle, real_cc);
}
// Setup default type libraries (called after loading a new file into the database)
// The processor module may load tils, setup memory model and perform other actions
// required to set up the type system.
// args: none
// returns: nothing
case processor_t::setup_til:
{
}
// Purpose: get prefix and size of 'segment based' ptr type (something like
// char _ss *ptr). See description in typeinf.hpp.
// Other modules simply set the pointer to NULL and return 0
// Ilfak confirmed that this approach is correct for the H8.
// Used only for BTMT_CLOSURE types, doubtful you will encounter them for H8.
// Arguments:
// unsigned int ptrt - ...
// const char **ptrname - output arg
// returns: size of type
case processor_t::based_ptr:
{
/*unsigned int ptrt =*/ va_arg(va, unsigned int);
char **ptrname = va_arg(va, char **);
*ptrname = NULL;
return 0;
}
// The H8 supports normal (64KB addressing, 16 bits) and advanced mode
// (16MB addressing, 24 bits). However, according to the Renesas technical
// documentation, certain instructions accept 32-bit pointer values where
// the upper 8 bits are "reserved". Ilfak confirms that "4+1" is fine.
// Used only for BTMT_CLOSURE types, doubtful you will encounter them for H8.
case processor_t::max_ptr_size:
{
return 4+1;
}
// get default enum size
// args: cm_t cm
// returns: sizeof(enum)
case processor_t::get_default_enum_size:
{
// cm_t cm = va_argi(va, cm_t);
return inf.cc.size_e;
}
case processor_t::use_stkarg_type:
{
ea_t ea = va_arg(va, ea_t);
const type_t *type = va_arg(va, const type_t *);
const char *name = va_arg(va, const char *);
return h8_use_stkvar_type(ea, type, name);
}
// calculate number of purged bytes by the given function type
// For cdecl functions, 'purged bytes' is always zero
// See the IDA Pro Book, 2e, at the end of pp. 107 for details
// args: type_t *type - must be function type
// returns: number of bytes purged from the stack + 2
case processor_t::calc_purged_bytes:
{
//e.g. const type_t t_int[] = { BT_INT, 0 };
//const type_t *type = va_arg(va, const type_t *); // must be BT_FUNC
return 0+2;
}
case processor_t::calc_arglocs2:
{
const type_t *type = va_arg(va, const type_t *);
cm_t cc = va_argi(va, cm_t);
varloc_t *arglocs = va_arg(va, varloc_t *);
return h8_calc_arglocs(type, cc, arglocs);
}
/* +++ END TYPEINFO CALLBACKS +++ */
case processor_t::term:
free_ioports(ports, numports);
break;
case processor_t::newfile: // new file loaded
load_symbols();
break;
case processor_t::oldfile: // old file loaded
load_symbols();
break;
case processor_t::closebase:
case processor_t::savebase:
helper.supset(0, device);
break;
case processor_t::newprc: // new processor type
ptype = ptypes[va_arg(va, int)];
setflag(ph.flag, PR_DEFSEG32, ptype & ADV);
break;
case processor_t::newasm: // new assembler type
break;
case processor_t::newseg: // new segment
break;
case processor_t::is_jump_func:
{
const func_t *pfn = va_arg(va, const func_t *);
ea_t *jump_target = va_arg(va, ea_t *);
return is_jump_func(pfn, jump_target);
}
case processor_t::is_sane_insn:
return is_sane_insn(va_arg(va, int));
case processor_t::may_be_func:
// can a function start here?
// arg: none, the instruction is in 'cmd'
// returns: probability 0..100
// 'cmd' structure is filled upon the entrace
// the idp module is allowed to modify 'cmd'
return may_be_func();
}
va_end(va);
return 1;
}
static int notify(processor_t::idp_notify msgid, ...)
{
va_list va;
va_start(va, msgid);
// A well behaving processor module should call invoke_callbacks()
// in his notify() function. If this function returns 0, then
// the processor module should process the notification itself
// Otherwise the code should be returned to the caller:
int code = invoke_callbacks(HT_IDP, msgid, va);
if ( code ) return code;
switch(msgid)
{
case processor_t::init:
helper.create("$ pic");
helper.supval(0, device, sizeof(device));
default:
break;
case processor_t::term:
free_mappings();
free_ioports(ports, numports);
break;
case processor_t::newfile: // new file loaded
{
segment_t *s0 = get_first_seg();
if ( s0 != NULL )
{
set_segm_name(s0, "CODE");
dataseg = AdditionalSegment(0x200, 0, "DATA");
segment_t *s1 = get_next_seg(s0->startEA);
SetDefaultRegisterValue(s0, BANK, 0);
SetDefaultRegisterValue(s1, BANK, 0);
SetDefaultRegisterValue(s0, PCLATH, 0);
SetDefaultRegisterValue(s1, PCLATH, 0);
SetDefaultRegisterValue(s0, PCLATU, 0);
SetDefaultRegisterValue(s1, PCLATU, 0);
setup_device(IORESP_INT);
apply_symbols();
}
}
break;
case processor_t::oldfile: // old file loaded
idpflags = (ushort)helper.altval(-1);
dataseg = helper.altval(0);
create_mappings();
for ( segment_t *s=get_first_seg(); s != NULL; s=get_next_seg(s->startEA) )
{
if ( s->defsr[PCLATH-ph.regFirstSreg] == BADSEL )
s->defsr[PCLATH-ph.regFirstSreg] = 0;
}
break;
case processor_t::closebase:
case processor_t::savebase:
helper.altset(0, dataseg);
helper.altset(-1, idpflags);
helper.supset(0, device);
break;
case processor_t::newprc: // new processor type
{
int n = va_arg(va, int);
static bool set = false;
if ( set )
return 0;
set = true;
if ( ptypes[n] != ptype )
{
ptype = ptypes[n];
ph.cnbits = 12 + 2*n;
}
switch ( ptype )
{
case PIC12:
register_names[PCLATH] = "status";
cfgname = "pic12.cfg";
break;
case PIC14:
cfgname = "pic14.cfg";
break;
case PIC16:
register_names[BANK] = "bsr";
cfgname = "pic16.cfg";
idpflags = 0;
ph.cnbits = 8;
ph.regLastSreg = PCLATU;
break;
default:
error("interr in setprc");
break;
}
}
break;
case processor_t::newasm: // new assembler type
break;
case processor_t::newseg: // new segment
break;
}
va_end(va);
return 1;
}
static int idaapi notify(processor_t::idp_notify msgid, ...)
{
va_list va;
va_start(va, msgid);
// A well behaving processor module should call invoke_callbacks()
// in his notify() function. If this function returns 0, then
// the processor module should process the notification itself
// Otherwise the code should be returned to the caller:
int code = invoke_callbacks(HT_IDP, msgid, va);
if ( code ) return code;
switch ( msgid )
{
case processor_t::init:
helper.create("$ st20");
helper.supval(0, device, sizeof(device));
break;
case processor_t::term:
free_ioports(ports, numports);
default:
break;
case processor_t::newfile: // new file loaded
case processor_t::oldfile: // old file loaded
load_symbols();
break;
case processor_t::savebase:
case processor_t::closebase:
helper.supset(0, device);
break;
case processor_t::newprc: // new processor type
procnum = va_arg(va, int);
if ( isc4() ) ph.retcodes = retcodes4;
break;
case processor_t::is_jump_func:
{
const func_t *pfn = va_arg(va, const func_t *);
ea_t *jump_target = va_arg(va, ea_t *);
return is_jump_func(pfn, jump_target);
}
case processor_t::is_sane_insn:
return is_sane_insn(va_arg(va, int));
case processor_t::may_be_func:
// can a function start here?
// arg: none, the instruction is in 'cmd'
// returns: probability 0..100
// 'cmd' structure is filled upon the entrace
// the idp module is allowed to modify 'cmd'
return may_be_func();
}
va_end(va);
return 1;
}
// The kernel event notifications
// Here you may take desired actions upon some kernel events
static int idaapi notify(processor_t::idp_notify msgid, ...)
{
va_list va;
va_start(va, msgid);
// A well behavior processor module should call invoke_callbacks()
// in his notify() function. If this function returns 0, then
// the processor module should process the notification itself
// Otherwise the code should be returned to the caller:
int code = invoke_callbacks(HT_IDP, msgid, va);
if ( code ) return code;
switch ( msgid )
{
case processor_t::init:
inf.mf = 1;
helper.create("$ fr");
default:
break;
case processor_t::term:
free_ioports(ports, numports);
break;
case processor_t::newfile:
choose_device();
set_device_name(device, IORESP_ALL);
break;
case processor_t::oldfile:
{
char buf[MAXSTR];
if ( helper.supval(-1, buf, sizeof(buf)) > 0 )
set_device_name(buf, IORESP_NONE);
}
break;
case processor_t::closebase:
case processor_t::savebase:
helper.supset(-1, device);
break;
case processor_t::is_basic_block_end:
return is_basic_block_end() ? 2 : 0;
#ifdef FR_TYPEINFO_SUPPORT
// +++ TYPE CALLBACKS
case processor_t::max_ptr_size:
return 4+1;
case processor_t::get_default_enum_size: // get default enum size
// args: cm_t cm
// returns: sizeof(enum)
{
// cm_t cm = va_argi(va, cm_t);
return 1; // inf.cc.size_e;
}
case processor_t::based_ptr:
{
uint ptrt = va_arg(va, unsigned int); qnotused(ptrt);
char **ptrname = va_arg(va, char **);
*ptrname = NULL;
return 0; // returns: size of type
}
case processor_t::get_stkarg_offset2:
// get offset from SP to the first stack argument
// args: none
// returns: the offset+2
return 0x00 + 2;
case processor_t::calc_cdecl_purged_bytes2:
// calculate number of purged bytes after call
{
//ea_t ea = va_arg(va, ea_t);
return 0x00 + 2;
}
#endif // FR_TYPEINFO_SUPPORT
#ifdef FR_TINFO_SUPPORT
case processor_t::decorate_name3:
{
qstring *outbuf = va_arg(va, qstring *);
const char *name = va_arg(va, const char *);
bool mangle = va_argi(va, bool);
cm_t cc = va_argi(va, cm_t);
return gen_decorate_name3(outbuf, name, mangle, cc) ? 2 : 0;
}
case processor_t::calc_retloc3:
//msg("calc_retloc3\n");
{
const tinfo_t *type = va_arg(va, const tinfo_t *);
cm_t cc = va_argi(va, cm_t);
argloc_t *retloc = va_arg(va, argloc_t *);
return calc_fr_retloc(*type, cc, retloc) ? 2 : -1;
}
break;
case processor_t::calc_varglocs3:
return 1; // not implemented
break;
case processor_t::calc_arglocs3:
{
//msg("calc_arglocs3\n");
func_type_data_t *fti = va_arg(va, func_type_data_t *);
return calc_fr_arglocs(fti) ? 2 : -1;
}
case processor_t::use_stkarg_type3:
{
//msg("use_stkarg_type3\n");
ea_t ea = va_arg(va, ea_t);
const funcarg_t *arg = va_arg(va, const funcarg_t* );
}
return false;
break;
case processor_t::use_regarg_type3:
//msg("use_regarg_type3\n");
{
int *used = va_arg(va, int *);
ea_t ea = va_arg(va, ea_t);
const funcargvec_t *rargs = va_arg(va, const funcargvec_t *);
*used = use_fr_regarg_type(ea, *rargs);
return 2;
}
break;
case processor_t::use_arg_types3:
{
ea_t ea = va_arg(va, ea_t);
func_type_data_t *fti = va_arg(va, func_type_data_t *);
funcargvec_t *rargs = va_arg(va, funcargvec_t *);
use_fr_arg_types(ea, fti, rargs);
return 2;
}
#ifdef IDA65
case processor_t::get_fastcall_regs2:
case processor_t::get_varcall_regs2:
{
const int **regs = va_arg(va, const int **);
return get_fr_fastcall_regs(regs) + 2;
}
case processor_t::get_thiscall_regs2:
{
const int **regs = va_arg(va, const int **);
*regs = NULL;
return 2;
}
#else
case processor_t::get_fastcall_regs3:
case processor_t::get_varcall_regs3:
{
const int *regs;
get_fr_fastcall_regs(®s);
callregs_t *callregs = va_arg(va, callregs_t *);
callregs->set(ARGREGS_INDEPENDENT, regs, NULL);
return callregs->nregs + 2;
}
case processor_t::get_thiscall_regs3:
{
callregs_t *callregs = va_arg(va, callregs_t *);
callregs->reset();
return 2;
}
#endif IDA65
#endif // FR_TINFO_SUPPORT
}
va_end(va);
return(1);
}
// The kernel event notifications
// Here you may take desired actions upon some kernel events
static int notify(processor_t::idp_notify msgid, ...)
{
va_list va;
va_start(va, msgid);
// A well behavior processor module should call invoke_callbacks()
// in his notify() function. If this function returns 0, then
// the processor module should process the notification itself
// Otherwise the code should be returned to the caller:
int code = invoke_callbacks(HT_IDP, msgid, va);
if ( code ) return code;
switch ( msgid ) {
case processor_t::init:
// this processor is big endian
inf.mf = 1;
refresh_idpflags();
{
char buf[MAXSTR];
if ( helper.supval(-1, buf, sizeof(buf)) > 0 )
set_device_name(buf, IORESP_ALL);
}
break;
case processor_t::term:
free_reg_names();
default:
break;
case processor_t::newfile:
// default configuration
idpflags = CONF_GR_DEC;
// patch general registers names
patch_general_registers(true);
break;
case processor_t::newseg:
{
segment_t *s = va_arg(va, segment_t *);
// set RW/RP segment registers initial values
s->defsr[rRW-ph.regFirstSreg] = 0;
s->defsr[rRP-ph.regFirstSreg] = BADSEL;
}
break;
case processor_t::oldfile:
patch_general_registers();
break;
case processor_t::closebase:
case processor_t::savebase:
helper.altset(-1, idpflags);
helper.supset(-1, device);
break;
}
va_end(va);
return(1);
}
//Save the user options bits into our netnode
bool setUserOpts(Options &user) {
return cnn.supset(OPTIONS_SUPVAL, &user, sizeof(Options));
}
//localize writes to LASTUPDATE_SUPVAL to a single function
void writeUpdateValue(uint64_t uid) {
cnn.supset(LASTUPDATE_SUPVAL, &uid, sizeof(uid));
}
//----------------------------------------------------------------------
int upgrade_db_format(int ver, netnode constnode)
{
if(askyn_c(1, "AUTOHIDE REGISTRY\nHIDECANCEL\n"
"The database has an old java data format.\n"
"Do you want to upgrade it?") <= 0) qexit(1);
switch ( ver ) {
default:
INTERNAL("upgrade::ver");
case IDP_JDK12:
break;
}
// change format: jdk-version
if ( curClass.MinVers > 0x8000u ) {
badbase:
return(0);
}
curClass.MajVers = JDK_MIN_MAJOR;
if ( curClass.MinVers >= 0x8000 ) {
curClass.MinVers &= ~0;
++curClass.MajVers;
curClass.JDKsubver = 2;
} else if ( curClass.MinVers >= JDK_1_1_MINOR ) ++curClass.JDKsubver;
// change format: This
#ifdef __BORLANDC__
#if offsetof(ClassInfo, This.Ref) != offsetof(ClassInfo, This.Name) || \
offsetof(ClassInfo, This.Dscr) != offsetof(ClassInfo, This.Name) + 2
#error
#endif
#endif
curClass.This.Ref = (curClass.This.Ref << 16) | curClass.This.Dscr;
if ( !curClass.This.Name ) goto badbase;
// change format: Super
#ifdef __BORLANDC__
#if offsetof(ClassInfo, super.Ref) != offsetof(ClassInfo, super.Name) || \
offsetof(ClassInfo, super.Dscr) != offsetof(ClassInfo, super.Name) + 2
#error
#endif
#endif
switch ( curClass.super.Name ) {
case 0: // absent
curClass.super.Ref &= 0;
break;
case 0xFFFF: // bad index
++curClass.super.Name;
break;
default: // reverse order
curClass.super.Ref = (curClass.super.Ref << 16) | curClass.super.Dscr;
break;
}
// validate: impNode
if ( curClass.impNode && !netnode(curClass.impNode).altval(0) ) goto badbase;
// change variable 'errload' in previous version
if ( curClass.maxSMsize ) {
curClass.extflg |= XFL_C_ERRLOAD;
curClass.maxSMsize &= 0;
}
// set segments type type for special segments
segment_t *S;
if ( (S = getseg(curClass.startEA)) == NULL ) goto badbase;
S->set_hidden_segtype(true);
S->update();
if ( curClass.xtrnCnt ) {
if ( (S = getseg(curClass.xtrnEA)) == NULL ) goto badbase;
S->set_hidden_segtype(true);
S->update();
}
curClass.extflg |= XFL_C_DONE; // do not repeat datalabel destroyer :)
// change: method/fields format
#define SGEXPSZ (sizeof(SegInfo) - offsetof(SegInfo, varNode))
#define FMEXPSZ (sizeof(_FMid_) - offsetof(_FMid_, _UNUSED_ALING))
#define FLEXPSZ (sizeof(FieldInfo) - offsetof(FieldInfo, annNodes))
uval_t oldsize = sizeof(SegInfo) - FMEXPSZ - SGEXPSZ;
for(int pos=-(int)curClass.MethodCnt; pos<=(int)curClass.FieldCnt; pos++) {
union {
SegInfo s;
FieldInfo f;
_FMid_ id;
uchar _space[qmax(sizeof(SegInfo), sizeof(FieldInfo)) + 1];
}u;
if ( !pos ) { // class node
oldsize += (sizeof(FieldInfo) - FLEXPSZ) - (sizeof(SegInfo) - SGEXPSZ);
continue;
}
if ( ClassNode.supval(pos, &u, sizeof(u)) != oldsize ) goto badbase;
memmove((uchar *)&u.id + sizeof(u.id), &u.id._UNUSED_ALING,
(size_t)oldsize - offsetof(_FMid_, _UNUSED_ALING));
u.id._UNUSED_ALING = 0;
u.id.utsign = 0;
if ( u.id.extflg & ~EFL__MASK ) goto badbase;
u.id.extflg &= (EFL_NAMETYPE);
if ( pos > 0 ) { // fields
memset(&u.f.annNodes, 0, sizeof(u.f)-offsetof(FieldInfo, annNodes));
ClassNode.supset(pos, &u.f, sizeof(u.f));
continue;
}
// segments
memset(&u.s.varNode, 0, sizeof(u.s) - offsetof(SegInfo, varNode));
if ( u.s.thrNode && !netnode(u.s.thrNode).altval(0) ) {
netnode(u.s.thrNode).kill(); // empty node (old format)
u.s.thrNode = 0;
}
// have locvars?
if ( u.s.DataSize ) {
if ( (S = getseg(u.s.DataBase)) == NULL ) goto badbase;
S->type = SEG_BSS;
S->set_hidden_segtype(true);
S->update();
}
// change: Exception format
if ( u.s.excNode ) {
register ushort i, j;
netnode enode(u.s.excNode);
if ( (j = (ushort)enode.altval(0)) == 0 ) goto badbase;
ea_t ea = u.s.startEA + u.s.CodeSize;
i = 1;
do {
Exception exc;
if ( enode.supval(i, &exc, sizeof(exc)) != sizeof(exc) ) goto badbase;
#ifdef __BORLANDC__
#if offsetof(Exception, filter.Ref) != offsetof(Exception, filter.Name) || \
offsetof(Exception, filter.Dscr) != offsetof(Exception, filter.Name) + 2
#error
#endif
#endif
if ( !exc.filter.Name != !exc.filter.Dscr ) goto badbase;
exc.filter.Ref = (exc.filter.Ref << 16) | exc.filter.Dscr; // was reverse order
if ( exc.filter.Name == 0xFFFF ) ++exc.filter.Name;
enode.supset(i, &exc, sizeof(exc));
set_exception_xref(&u.s, exc, ea);
}while ( ++i <= j );
}
ClassNode.supset(pos, &u.s, sizeof(u.s));
//rename local variables (for references)
if ( u.s.DataSize ) {
int i = u.s.DataSize;
ea_t ea = u.s.DataBase + i;
do {
char str[MAXNAMELEN];
qsnprintf(str, sizeof(str), "met%03u_slot%03u", u.s.id.Number, --i);
--ea;
if ( do_name_anyway(ea, str)) make_name_auto(ea );
else hide_name(ea);
}while ( i );
coagulate_unused_data(&u.s);
}
} // for
//change format of string presentation in constant pool
for(int pos = 0; (ushort)pos <= curClass.maxCPindex; pos++) {
ConstOpis co;
if ( constnode.supval(pos, &co, sizeof(co)) != sizeof(co) ) goto badbase;
switch ( co.type ) {
default:
continue;
case CONSTANT_Unicode:
error("Base contain CONSTANT_Unicode, but it is removed from "
"the standard in 1996 year and never normal loaded in IDA");
case CONSTANT_Utf8:
break;
}
uint32 v, n, i = pos << 16;
if( ((n = (uint32)constnode.altval(i)) & UPG12_BADMASK)
|| (v = n & ~UPG12_CLRMASK) == 0) goto badbase;
if ( n & UPG12_EXTMASK ) v |= UPG12_EXTSET;
if ( (n = (ushort)v) != 0 ) {
register uchar *po = (uchar*)append_tmp_buffer(v);
n *= sizeof(ushort);
uint32 pos = 0;
do {
uint32 sz = n - pos;
if ( sz > MAXSPECSIZE ) sz = MAXSPECSIZE;
if ( constnode.supval(++i, &po[pos], sz) != sz ) goto badbase;
constnode.supdel(i);
pos += sz;
}while ( pos < n );
constnode.setblob(po, n, i & ~0xFFFF, BLOB_TAG);
if ( !(v & UPG12_EXTSET) ) do {
#ifdef __BORLANDC__
#if ( sizeof(ushort) % 2) || (MAXSPECSIZE % 2 )
#error
#endif
#endif
ushort cw = *(ushort *)&po[pos];
if ( cw >= CHP_MAX ) {
if ( !javaIdent(cw) ) goto extchar;
} else if ( (uchar)cw <= CHP_MIN ) {
extchar:
v |= UPG12_EXTSET;
break;
}
}while ( (pos -= sizeof(ushort)) != 0 );
v = upgrade_ResW(v);
}
constnode.altset(i, v);
co._Sopstr = v; // my be not needed? (next also)
constnode.supset(pos, &co, sizeof(co));
}
// rename 'import' variables for refernces
for(unsigned ip = 1; (ushort)ip <= curClass.xtrnCnt; ip++) {
ConstOpis co;
{
register unsigned j;
if( (j = (unsigned)XtrnNode.altval(ip)) == 0
|| !LoadOpis((ushort)j, 0, &co)) goto badbase;
}
switch ( co.type ) {
default:
goto badbase;
case CONSTANT_Class:
if ( !(co.flag & HAS_CLSNAME) ) continue;
break;
case CONSTANT_InterfaceMethodref:
case CONSTANT_Methodref:
if ( (co.flag & NORM_METOD) != NORM_METOD ) continue;
break;
case CONSTANT_Fieldref:
if ( (co.flag & NORM_FIELD) != NORM_FIELD ) continue;
break;
}
make_new_name(co._name, co._subnam, co.type != CONSTANT_Class, ip);
}
if ( curClass.This.Dscr )
make_new_name(curClass.This.Name, 0, (uchar)-1, (unsigned)curClass.startEA);
return(_TO_VERSION);
}
