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:
// __emit__(0xCC); // debugger trap
helper.create("$ h8/500");
inf.mf = 1;
default:
break;
case processor_t::term:
free_syms();
break;
case processor_t::oldfile: // old file loaded
idpflags = ushort(helper.altval(-1) + 1);
create_segment_registers();
// no break
case processor_t::newfile: // new file loaded
load_symbols("h8500.cfg");
inf.mf = 1;
break;
case processor_t::closebase:
case processor_t::savebase:
helper.altset(-1, idpflags - 1);
break;
case processor_t::newseg: // new segment
{
segment_t *sptr = va_arg(va, segment_t *);
sptr->defsr[BR-ph.regFirstSreg] = 0;
sptr->defsr[DP-ph.regFirstSreg] = 0;
}
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 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;
}
