void pdp8_device::device_start()
{
m_program = &space(AS_PROGRAM);
// register our state for the debugger
state_add(STATE_GENPC, "GENPC", m_pc).noshow();
state_add(STATE_GENFLAGS, "GENFLAGS", m_l).callimport().callexport().formatstr("%1s").noshow();
state_add(PDP8_PC, "PC", m_pc).mask(0xfff);
state_add(PDP8_AC, "AC", m_ac).mask(0xfff);
state_add(PDP8_MB, "MB", m_mb).mask(0xfff);
state_add(PDP8_MA, "MA", m_ma).mask(0xfff);
state_add(PDP8_SR, "SR", m_sr).mask(0xfff);
state_add(PDP8_L, "L", m_l).mask(0xf);
state_add(PDP8_IR, "IR", m_ir).mask(0xff);
state_add(PDP8_HALT, "HLT", m_halt).mask(0xf);
// setup regtable
save_item(NAME(m_pc));
save_item(NAME(m_ac));
save_item(NAME(m_mb));
save_item(NAME(m_ma));
save_item(NAME(m_sr));
save_item(NAME(m_l));
save_item(NAME(m_ir));
save_item(NAME(m_halt));
// set our instruction counter
m_icountptr = &m_icount;
}
void ti990_10_device::device_start()
{
m_prgspace = &space(AS_PROGRAM);
m_cru = &space(AS_IO);
// set our instruction counter
m_icountptr = &m_icount;
state_add(STATE_GENPC, "curpc", PC).formatstr("%4s").noshow();
state_add(STATE_GENFLAGS, "status", m_state_any).callimport().callexport().formatstr("%16s").noshow();
}
void m65ce02_device::init()
{
m65c02_device::init();
state_add(M65CE02_Z, "Z", Z);
state_add(M65CE02_B, "B", B).callimport().formatstr("%2s");
save_item(NAME(B));
save_item(NAME(Z));
save_item(NAME(TMP3));
Z = 0x00;
B = 0x0000;
TMP3 = 0x0000;
}
void m6509_device::device_start()
{
if(direct_disabled)
mintf = new mi_6509_nd(this);
else
mintf = new mi_6509_normal(this);
init();
state_add(STATE_GENPC, "GENPC", XPC).callexport().noshow();
state_add(M6509_BI, "BI", bank_i);
state_add(M6509_BY, "BY", bank_y);
}
void arc_device::device_start()
{
m_pc = 0;
m_debugger_temp = 0;
m_program = &space(AS_PROGRAM);
state_add( 0, "PC", m_debugger_temp).callimport().callexport().formatstr("%08X");
state_add(STATE_GENPC, "GENPC", m_debugger_temp).callexport().noshow();
state_add(STATE_GENPCBASE, "CURPC", m_debugger_temp).callexport().noshow();
m_icountptr = &m_icount;
}
void mb86235_cpu_device::device_start()
{
m_program = &space(AS_PROGRAM);
save_item(NAME(m_pc));
save_item(NAME(m_flags));
// Register state for debugger
//state_add( CP1610_R0, "PC", m_pc ).formatstr("%02X");
state_add( STATE_GENPC, "curpc", m_pc ).noshow();
state_add( STATE_GENFLAGS, "GENFLAGS", m_flags ).noshow();
m_icountptr = &m_icount;
}
void m6805_base_device::device_start()
{
m_program = &space(AS_PROGRAM);
m_direct = &m_program->direct();
// set our instruction counter
m_icountptr = &m_icount;
// register our state for the debugger
state_add(STATE_GENPC, "GENPC", m_pc.w.l).noshow();
state_add(STATE_GENPCBASE, "CURPC", m_pc.w.l).noshow();
state_add(STATE_GENFLAGS, "GENFLAGS", m_cc).callimport().callexport().formatstr("%8s").noshow();
state_add(M6805_A, "A", m_a).mask(0xff);
state_add(M6805_PC, "PC", m_pc.w.l).mask(0xffff);
state_add(M6805_S, "S", m_s.w.l).mask(0xff);
state_add(M6805_X, "X", m_x).mask(0xff);
state_add(M6805_CC, "CC", m_cc).mask(0xff);
// register for savestates
save_item(NAME(EA));
save_item(NAME(A));
save_item(NAME(PC));
save_item(NAME(S));
save_item(NAME(X));
save_item(NAME(CC));
save_item(NAME(m_pending_interrupts));
save_item(NAME(m_irq_state));
save_item(NAME(m_nmi_state));
std::fill(std::begin(m_irq_state), std::end(m_irq_state), CLEAR_LINE);
}
void xxx_cpu_device::device_start()
{
m_program = &space(AS_PROGRAM);
m_data = &space(AS_DATA);
save_item(NAME(m_pc));
save_item(NAME(m_flags));
// Register state for debugger
state_add( CP1610_R0, "PC", m_pc ).formatstr("%02X");
state_add( STATE_GENPC, "GENPC", m_r[7] ).noshow();
state_add( STATE_GENPCBASE, "CURPC", m_r[7] ).noshow();
state_add( STATE_GENFLAGS, "GENFLAGS", m_flags ).noshow();
m_icountptr = &m_icount;
}
void take( SUser* user, std::vector< S3UInt32 > coins, uint32 path, uint32 flag/* = 0 */ )
{
if ( coins.empty() )
return;
coins = merge_coins( coins );
//优先通知客户端
if ( state_not( flag, kCoinFlagQuiet ) )
{
PRNotifyCoin msg;
bccopy( msg, user->ext );
msg.coins = coins;
msg.set_type = kObjectDel;
msg.path = path;
local::write( local::access, msg );
}
//扣除货币
for ( std::vector< S3UInt32 >::iterator i = coins.begin();
i != coins.end();
++i )
{
take( user, *i, path, state_add( flag, kCoinFlagQuiet ) );
}
}
void tms32082_pp_device::device_start()
{
m_program = &space(AS_PROGRAM);
save_item(NAME(m_pc));
save_item(NAME(m_fetchpc));
// Register state for debugger
state_add(PP_PC, "pc", m_pc).formatstr("%08X");
state_add(STATE_GENPC, "curpc", m_pc).noshow();
m_program = &space(AS_PROGRAM);
m_direct = &m_program->direct();
m_icountptr = &m_icount;
}
void xavix_device::device_start()
{
if(cache_disabled)
mintf = std::make_unique<mi_xavix_nd>(this);
else
mintf = std::make_unique<mi_xavix_normal>(this);
// bind delegates
m_vector_callback.bind_relative_to(*owner());
init();
m_lowbus_space = &space(5);
m_extbus_space = &space(6);
state_add(XAVIX_DATABANK, "DATBNK", m_databank).callimport().formatstr("%2s");;
state_add(XAVIX_CODEBANK, "CODBNK", m_codebank).callimport().formatstr("%2s");
}
void alpha_device::device_start()
{
set_icountptr(m_icount);
save_item(NAME(m_pc));
save_item(NAME(m_r));
save_item(NAME(m_f));
state_add(STATE_GENPC, "GENPC", m_pc).noshow();
state_add(STATE_GENPCBASE, "CURPC", m_pc).noshow();
state_add(64, "PC", m_pc);
// integer registers
for (unsigned i = 0; i < 32; i++)
state_add(i, util::string_format("R%d", i).c_str(), m_r[i]);
// floating point registers
for (unsigned i = 0; i < 32; i++)
state_add(i + 32, util::string_format("F%d", i).c_str(), m_f[i]);
}
void arcompact_device::device_start()
{
m_pc = 0;
m_debugger_temp = 0;
m_program = &space(AS_PROGRAM);
m_io = &space(AS_IO);
state_add( 0, "PC", m_debugger_temp).callimport().callexport().formatstr("%08X");
state_add( 0x10, "STATUS32", m_debugger_temp).callimport().callexport().formatstr("%08X");
state_add( 0x11, "LP_START", m_debugger_temp).callimport().callexport().formatstr("%08X");
state_add( 0x12, "LP_END", m_debugger_temp).callimport().callexport().formatstr("%08X");
state_add(STATE_GENPC, "GENPC", m_debugger_temp).callexport().noshow();
for (int i = 0x100; i < 0x140; i++)
{
state_add(i, regnames[i-0x100], m_debugger_temp).callimport().callexport().formatstr("%08X");
}
m_icountptr = &m_icount;
}
void arcompact_device::device_start()
{
m_pc = 0;
m_debugger_temp = 0;
m_program = &space(AS_PROGRAM);
m_io = &space(AS_IO);
state_add( ARCOMPACT_PC, "PC", m_debugger_temp).callimport().callexport().formatstr("%08X");
state_add( ARCOMPACT_STATUS32, "STATUS32", m_debugger_temp).callimport().callexport().formatstr("%08X");
state_add( ARCOMPACT_LP_START, "LP_START", m_debugger_temp).callimport().callexport().formatstr("%08X");
state_add( ARCOMPACT_LP_END, "LP_END", m_debugger_temp).callimport().callexport().formatstr("%08X");
state_add(STATE_GENPCBASE, "CURPC", m_debugger_temp).callimport().callexport().noshow();
for (int i = 0x100; i < 0x140; i++)
{
state_add(i, arcompact_disassembler::regnames[i-0x100], m_debugger_temp).callimport().callexport().formatstr("%08X");
}
set_icountptr(m_icount);
}
void dsp16_device::device_start()
{
// get our address spaces
m_program = space(AS_PROGRAM);
m_direct = &m_program->direct();
save_item(NAME(m_pc));
// register state with the debugger
state_add(DSP16_PC, "PC", m_pc);
// set our instruction counter
m_icountptr = &m_icount;
}
SC_FUNC constvalue *automaton_add(const char *name)
{
constvalue *ptr;
int last;
assert(strlen(name)<sizeof(ptr->name));
ptr=find_automaton(name,&last);
if (ptr==NULL) {
assert(last+1 <= SHRT_MAX);
ptr=append_constval(&sc_automaton_tab,name,(cell)0,(short)(last+1));
/* for every new automaton, create an anonymous (invalid) state */
state_add("",last+1);
} /* if */
return ptr;
}
void xavix2000_device::device_start()
{
xavix_device::device_start();
state_add(SXAVIX_J, "J", m_j).callimport().formatstr("%8s");;
state_add(SXAVIX_K, "K", m_k).callimport().formatstr("%8s");;
state_add(SXAVIX_L, "L", m_l).callimport().formatstr("%8s");;
state_add(SXAVIX_M, "M", m_m).callimport().formatstr("%8s");;
state_add(SXAVIX_PA, "PA", m_pa).callimport().formatstr("%8s");
state_add(SXAVIX_PB, "PB", m_pb).callimport().formatstr("%8s");
}
void mcs96_device::device_start()
{
program = &space(AS_PROGRAM);
direct = &program->direct();
m_icountptr = &icount;
state_add(STATE_GENPC, "GENPC", PC).noshow();
state_add(STATE_GENPCBASE, "GENPCBASE", PPC).noshow();
state_add(STATE_GENSP, "GENSP", R[0]).noshow();
state_add(STATE_GENFLAGS, "GENFLAGS", PSW).formatstr("%16s").noshow();
state_add(MCS96_PC, "PC", PC);
state_add(MCS96_PSW, "PSW", PSW);
state_add(MCS96_R, "SP", R[0]);
for(int i=1; i<0x74; i++) {
char buf[10];
sprintf(buf, "R%02x", i*2+0x18);
state_add(MCS96_R+i, buf, R[i]);
}
memset(R, 0, sizeof(R));
}
void sm510_base_device::device_start()
{
m_program = &space(AS_PROGRAM);
m_data = &space(AS_DATA);
m_prgmask = (1 << m_prgwidth) - 1;
m_datamask = (1 << m_datawidth) - 1;
// resolve callbacks
//..
// zerofill
memset(m_stack, 0, sizeof(m_stack));
m_pc = 0;
m_prev_pc = 0;
m_op = 0;
m_prev_op = 0;
m_param = 0;
m_acc = 0;
m_bl = 0;
m_bm = 0;
// register for savestates
save_item(NAME(m_stack));
save_item(NAME(m_pc));
save_item(NAME(m_prev_pc));
save_item(NAME(m_op));
save_item(NAME(m_prev_op));
save_item(NAME(m_param));
save_item(NAME(m_acc));
save_item(NAME(m_bl));
save_item(NAME(m_bm));
// register state for debugger
state_add(SM510_PC, "PC", m_pc).formatstr("%04X");
state_add(SM510_ACC, "ACC", m_acc).formatstr("%01X");
state_add(SM510_BL, "BL", m_bl).formatstr("%01X");
state_add(SM510_BM, "BM", m_bm).formatstr("%01X");
state_add(STATE_GENPC, "curpc", m_pc).formatstr("%04X").noshow();
state_add(STATE_GENFLAGS, "GENFLAGS", m_pc).formatstr("%2s").noshow();
m_icountptr = &m_icount;
}
int nfs4_op_lock(struct nfs_argop4 *op, compound_data_t * data, struct nfs_resop4 *resp)
{
char __attribute__ ((__unused__)) funcname[] = "nfs4_op_lock";
#ifndef _WITH_NFSV4_LOCKS
/* Lock are not supported */
resp->resop = NFS4_OP_LOCK;
res_LOCK4.status = NFS4ERR_LOCK_NOTSUPP;
return res_LOCK4.status;
#else
state_status_t state_status;
state_data_t candidate_data;
state_type_t candidate_type;
int rc = 0;
seqid4 seqid;
state_t * plock_state; /* state for the lock */
state_t * pstate_open; /* state for the open owner */
state_owner_t * plock_owner;
state_owner_t * popen_owner;
state_owner_t * presp_owner; /* Owner to store response in */
state_owner_t * conflict_owner = NULL;
state_nfs4_owner_name_t owner_name;
nfs_client_id_t nfs_client_id;
state_lock_desc_t lock_desc, conflict_desc;
state_blocking_t blocking = STATE_NON_BLOCKING;
const char * tag = "LOCK";
LogDebug(COMPONENT_NFS_V4_LOCK,
"Entering NFS v4 LOCK handler -----------------------------------------------------");
/* Initialize to sane starting values */
resp->resop = NFS4_OP_LOCK;
/* If there is no FH */
if(nfs4_Is_Fh_Empty(&(data->currentFH)))
{
res_LOCK4.status = NFS4ERR_NOFILEHANDLE;
LogDebug(COMPONENT_NFS_V4_LOCK,
"LOCK failed nfs4_Is_Fh_Empty");
return res_LOCK4.status;
}
/* If the filehandle is invalid */
if(nfs4_Is_Fh_Invalid(&(data->currentFH)))
{
res_LOCK4.status = NFS4ERR_BADHANDLE;
LogDebug(COMPONENT_NFS_V4_LOCK,
"LOCK failed nfs4_Is_Fh_Invalid");
return res_LOCK4.status;
}
/* Tests if the Filehandle is expired (for volatile filehandle) */
if(nfs4_Is_Fh_Expired(&(data->currentFH)))
{
res_LOCK4.status = NFS4ERR_FHEXPIRED;
LogDebug(COMPONENT_NFS_V4_LOCK,
"LOCK failed nfs4_Is_Fh_Expired");
return res_LOCK4.status;
}
/* Lock is done only on a file */
if(data->current_filetype != REGULAR_FILE)
{
/* Type of the entry is not correct */
switch (data->current_filetype)
{
case DIRECTORY:
res_LOCK4.status = NFS4ERR_ISDIR;
break;
default:
res_LOCK4.status = NFS4ERR_INVAL;
break;
}
LogDebug(COMPONENT_NFS_V4_LOCK,
"LOCK failed wrong file type");
return res_LOCK4.status;
}
/* Convert lock parameters to internal types */
switch(arg_LOCK4.locktype)
{
case READ_LT:
lock_desc.sld_type = STATE_LOCK_R;
blocking = STATE_NON_BLOCKING;
break;
case WRITE_LT:
lock_desc.sld_type = STATE_LOCK_W;
blocking = STATE_NON_BLOCKING;
break;
case READW_LT:
lock_desc.sld_type = STATE_LOCK_R;
blocking = STATE_NFSV4_BLOCKING;
break;
case WRITEW_LT:
lock_desc.sld_type = STATE_LOCK_W;
blocking = STATE_NFSV4_BLOCKING;
break;
}
lock_desc.sld_offset = arg_LOCK4.offset;
if(arg_LOCK4.length != STATE_LOCK_OFFSET_EOF)
lock_desc.sld_length = arg_LOCK4.length;
else
lock_desc.sld_length = 0;
if(arg_LOCK4.locker.new_lock_owner)
{
/* New lock owner, Find the open owner */
tag = "LOCK (new owner)";
/* Check stateid correctness and get pointer to state */
if((rc = nfs4_Check_Stateid(&arg_LOCK4.locker.locker4_u.open_owner.open_stateid,
data->current_entry,
0LL,
&pstate_open,
data,
STATEID_SPECIAL_FOR_LOCK,
tag)) != NFS4_OK)
{
res_LOCK4.status = rc;
LogDebug(COMPONENT_NFS_V4_LOCK,
"LOCK failed nfs4_Check_Stateid for open owner");
return res_LOCK4.status;
}
popen_owner = pstate_open->state_powner;
plock_state = NULL;
plock_owner = NULL;
presp_owner = popen_owner;
seqid = arg_LOCK4.locker.locker4_u.open_owner.open_seqid;
LogLock(COMPONENT_NFS_V4_LOCK, NIV_FULL_DEBUG,
"LOCK New lock owner from open owner",
data->current_entry,
data->pcontext,
popen_owner,
&lock_desc);
/* Check is the clientid is known or not */
if(nfs_client_id_get(arg_LOCK4.locker.locker4_u.open_owner.lock_owner.clientid,
&nfs_client_id) == CLIENT_ID_NOT_FOUND)
{
res_LOCK4.status = NFS4ERR_STALE_CLIENTID;
LogDebug(COMPONENT_NFS_V4_LOCK,
"LOCK failed nfs_client_id_get");
return res_LOCK4.status;
}
/* The related stateid is already stored in pstate_open */
/* An open state has been found. Check its type */
if(pstate_open->state_type != STATE_TYPE_SHARE)
{
res_LOCK4.status = NFS4ERR_BAD_STATEID;
LogDebug(COMPONENT_NFS_V4_LOCK,
"LOCK failed open stateid is not a SHARE");
return res_LOCK4.status;
}
/* Lock seqid (seqid wanted for new lock) should be 0 (see newpynfs test LOCK8c) */
if(arg_LOCK4.locker.locker4_u.open_owner.lock_seqid != 0)
{
res_LOCK4.status = NFS4ERR_BAD_SEQID;
LogDebug(COMPONENT_NFS_V4_LOCK,
"LOCK failed new lock stateid is not 0");
return res_LOCK4.status;
}
/* Is this lock_owner known ? */
convert_nfs4_lock_owner(&arg_LOCK4.locker.locker4_u.open_owner.lock_owner,
&owner_name);
}
else
{
/* Existing lock owner
* Find the lock stateid
* From that, get the open_owner
*/
tag = "LOCK (existing owner)";
/* There was code here before to handle all-0 stateid, but that
* really doesn't apply - when we handle temporary locks for
* I/O operations (which is where we will see all-0 or all-1
* stateid, those will not come in through nfs4_op_lock.
*/
/* Check stateid correctness and get pointer to state */
if((rc = nfs4_Check_Stateid(&arg_LOCK4.locker.locker4_u.lock_owner.lock_stateid,
data->current_entry,
0LL,
&plock_state,
data,
STATEID_SPECIAL_FOR_LOCK,
tag)) != NFS4_OK)
{
res_LOCK4.status = rc;
LogDebug(COMPONENT_NFS_V4_LOCK,
"LOCK failed nfs4_Check_Stateid for existing lock owner");
return res_LOCK4.status;
}
/* An lock state has been found. Check its type */
if(plock_state->state_type != STATE_TYPE_LOCK)
{
res_LOCK4.status = NFS4ERR_BAD_STATEID;
LogDebug(COMPONENT_NFS_V4_LOCK,
"LOCK failed existing lock owner, state type is not LOCK");
return res_LOCK4.status;
}
/* Get the old lockowner. We can do the following 'cast', in NFSv4 lock_owner4 and open_owner4
* are different types but with the same definition*/
plock_owner = plock_state->state_powner;
popen_owner = plock_owner->so_owner.so_nfs4_owner.so_related_owner;
pstate_open = plock_state->state_data.lock.popenstate;
presp_owner = plock_owner;
seqid = arg_LOCK4.locker.locker4_u.lock_owner.lock_seqid;
LogLock(COMPONENT_NFS_V4_LOCK, NIV_FULL_DEBUG,
"LOCK Existing lock owner",
data->current_entry,
data->pcontext,
plock_owner,
&lock_desc);
#ifdef _CONFORM_TO_TEST_LOCK8c
/* Check validity of the seqid */
if(arg_LOCK4.locker.locker4_u.lock_owner.lock_seqid != 0)
{
res_LOCK4.status = NFS4ERR_BAD_SEQID;
LogDebug(COMPONENT_NFS_V4_LOCK,
"LOCK failed existing lock owner, lock seqid != 0");
return res_LOCK4.status;
}
#endif
} /* if( arg_LOCK4.locker.new_lock_owner ) */
/* Check seqid (lock_seqid or open_seqid) */
if(!Check_nfs4_seqid(presp_owner, seqid, op, data, resp, tag))
{
/* Response is all setup for us and LogDebug told what was wrong */
return res_LOCK4.status;
}
/* Lock length should not be 0 */
if(arg_LOCK4.length == 0LL)
{
res_LOCK4.status = NFS4ERR_INVAL;
LogDebug(COMPONENT_NFS_V4_LOCK,
"LOCK failed length == 0");
/* Save the response in the lock or open owner */
Copy_nfs4_state_req(presp_owner, seqid, op, data, resp, tag);
return res_LOCK4.status;
}
/* Check for range overflow.
* Comparing beyond 2^64 is not possible int 64 bits precision,
* but off+len > 2^64-1 is equivalent to len > 2^64-1 - off
*/
if(lock_desc.sld_length > (STATE_LOCK_OFFSET_EOF - lock_desc.sld_offset))
{
res_LOCK4.status = NFS4ERR_INVAL;
LogDebug(COMPONENT_NFS_V4_LOCK,
"LOCK failed length overflow");
/* Save the response in the lock or open owner */
Copy_nfs4_state_req(presp_owner, seqid, op, data, resp, tag);
return res_LOCK4.status;
}
/* check if open state has correct access for type of lock.
* Don't need to check for conflicting states since this open
* state assures there are no conflicting states.
*/
if(((arg_LOCK4.locktype == WRITE_LT || arg_LOCK4.locktype == WRITEW_LT) &&
((pstate_open->state_data.share.share_access & OPEN4_SHARE_ACCESS_WRITE) == 0)) ||
((arg_LOCK4.locktype == READ_LT || arg_LOCK4.locktype == READW_LT) &&
((pstate_open->state_data.share.share_access & OPEN4_SHARE_ACCESS_READ) == 0)))
{
/* The open state doesn't allow access based on the type of lock */
LogLock(COMPONENT_NFS_V4_LOCK, NIV_DEBUG,
"LOCK failed, SHARE doesn't allow access",
data->current_entry,
data->pcontext,
plock_owner,
&lock_desc);
res_LOCK4.status = NFS4ERR_OPENMODE;
/* Save the response in the lock or open owner */
Copy_nfs4_state_req(presp_owner, seqid, op, data, resp, tag);
return res_LOCK4.status;
}
if(arg_LOCK4.locker.new_lock_owner)
{
/* A lock owner is always associated with a previously made open
* which has itself a previously made stateid
*/
/* Get reference to open owner */
inc_state_owner_ref(popen_owner);
if(nfs4_owner_Get_Pointer(&owner_name, &plock_owner))
{
/* Lock owner already existsc, check lock_seqid if it's not 0 */
if(!Check_nfs4_seqid(plock_owner,
arg_LOCK4.locker.locker4_u.open_owner.lock_seqid,
op,
data,
resp,
"LOCK (new owner but owner exists)"))
{
/* Response is all setup for us and LogDebug told what was wrong */
return res_LOCK4.status;
}
}
else
{
/* This lock owner is not known yet, allocated and set up a new one */
plock_owner = create_nfs4_owner(data->pclient,
&owner_name,
STATE_LOCK_OWNER_NFSV4,
popen_owner,
0);
if(plock_owner == NULL)
{
res_LOCK4.status = NFS4ERR_RESOURCE;
LogLock(COMPONENT_NFS_V4_LOCK, NIV_DEBUG,
"LOCK failed to create new lock owner",
data->current_entry,
data->pcontext,
popen_owner,
&lock_desc);
return res_LOCK4.status;
}
}
/* Prepare state management structure */
memset(&candidate_type, 0, sizeof(candidate_type));
candidate_type = STATE_TYPE_LOCK;
candidate_data.lock.popenstate = pstate_open;
/* Add the lock state to the lock table */
if(state_add(data->current_entry,
candidate_type,
&candidate_data,
plock_owner,
data->pclient,
data->pcontext,
&plock_state, &state_status) != STATE_SUCCESS)
{
res_LOCK4.status = NFS4ERR_RESOURCE;
LogLock(COMPONENT_NFS_V4_LOCK, NIV_DEBUG,
"LOCK failed to add new stateid",
data->current_entry,
data->pcontext,
plock_owner,
&lock_desc);
dec_state_owner_ref(plock_owner, data->pclient);
return res_LOCK4.status;
}
init_glist(&plock_state->state_data.lock.state_locklist);
/* Add lock state to the list of lock states belonging to the open state */
glist_add_tail(&pstate_open->state_data.share.share_lockstates,
&plock_state->state_data.lock.state_sharelist);
} /* if( arg_LOCK4.locker.new_lock_owner ) */
/* Now we have a lock owner and a stateid.
* Go ahead and push lock into SAL (and FSAL).
*/
if(state_lock(data->current_entry,
data->pcontext,
plock_owner,
plock_state,
blocking,
NULL, /* No block data for now */
&lock_desc,
&conflict_owner,
&conflict_desc,
data->pclient,
&state_status) != STATE_SUCCESS)
{
if(state_status == STATE_LOCK_CONFLICT)
{
/* A conflicting lock from a different lock_owner, returns NFS4ERR_DENIED */
Process_nfs4_conflict(&res_LOCK4.LOCK4res_u.denied,
conflict_owner,
&conflict_desc,
data->pclient);
}
LogDebug(COMPONENT_NFS_V4_LOCK,
"LOCK failed with status %s",
state_err_str(state_status));
res_LOCK4.status = nfs4_Errno_state(state_status);
/* Save the response in the lock or open owner */
if(res_LOCK4.status != NFS4ERR_RESOURCE &&
res_LOCK4.status != NFS4ERR_BAD_STATEID)
Copy_nfs4_state_req(presp_owner, seqid, op, data, resp, tag);
if(arg_LOCK4.locker.new_lock_owner)
{
/* Need to destroy lock owner and state */
if(state_del(plock_state,
data->pclient,
&state_status) != STATE_SUCCESS)
LogDebug(COMPONENT_NFS_V4_LOCK,
"state_del failed with status %s",
state_err_str(state_status));
}
return res_LOCK4.status;
}
res_LOCK4.status = NFS4_OK;
/* Handle stateid/seqid for success */
update_stateid(plock_state,
&res_LOCK4.LOCK4res_u.resok4.lock_stateid,
data,
tag);
LogFullDebug(COMPONENT_NFS_V4_LOCK,
"LOCK state_seqid = %u, plock_state = %p",
plock_state->state_seqid,
plock_state);
/* Save the response in the lock or open owner */
Copy_nfs4_state_req(presp_owner, seqid, op, data, resp, tag);
LogLock(COMPONENT_NFS_V4_LOCK, NIV_FULL_DEBUG,
"LOCK applied",
data->current_entry,
data->pcontext,
plock_owner,
&lock_desc);
return res_LOCK4.status;
#endif
} /* nfs4_op_lock */
void lr35902_cpu_device::device_start()
{
m_device = this;
m_program = &space(AS_PROGRAM);
save_item(NAME(m_A));
save_item(NAME(m_F));
save_item(NAME(m_B));
save_item(NAME(m_C));
save_item(NAME(m_D));
save_item(NAME(m_E));
save_item(NAME(m_H));
save_item(NAME(m_L));
save_item(NAME(m_PC));
save_item(NAME(m_SP));
save_item(NAME(m_IE));
save_item(NAME(m_IF));
save_item(NAME(m_irq_state));
save_item(NAME(m_ei_delay));
save_item(NAME(m_execution_state));
save_item(NAME(m_op));
save_item(NAME(m_gb_speed));
save_item(NAME(m_gb_speed_change_pending));
save_item(NAME(m_enable));
save_item(NAME(m_doHALTbug));
// Register state for debugger
state_add( LR35902_PC, "PC", m_PC ).callimport().callexport().formatstr("%04X");
state_add( LR35902_SP, "SP", m_SP ).callimport().callexport().formatstr("%04X");
state_add( LR35902_A, "A", m_A ).callimport().callexport().formatstr("%02X");
state_add( LR35902_F, "F", m_F ).callimport().callexport().formatstr("%02X");
state_add( LR35902_B, "B", m_B ).callimport().callexport().formatstr("%02X");
state_add( LR35902_C, "C", m_C ).callimport().callexport().formatstr("%02X");
state_add( LR35902_D, "D", m_D ).callimport().callexport().formatstr("%02X");
state_add( LR35902_E, "E", m_E ).callimport().callexport().formatstr("%02X");
state_add( LR35902_H, "H", m_H ).callimport().callexport().formatstr("%02X");
state_add( LR35902_L, "L", m_L ).callimport().callexport().formatstr("%02X");
state_add( LR35902_IRQ_STATE, "IRQ", m_enable ).callimport().callexport().formatstr("%02X");
state_add( LR35902_IE, "IE", m_IE ).callimport().callexport().formatstr("%02X");
state_add( LR35902_IF, "IF", m_IF ).callimport().callexport().formatstr("%02X");
state_add(STATE_GENPC, "curpc", m_PC).callimport().callexport().formatstr("%8s").noshow();
state_add(STATE_GENFLAGS, "GENFLAGS", m_F).mask(0xf0).formatstr("%8s").noshow();
m_icountptr = &m_icount;
}
void arm_cpu_device::device_start()
{
m_program = &space(AS_PROGRAM);
m_direct = &m_program->direct();
save_item(NAME(m_sArmRegister));
save_item(NAME(m_coproRegister));
save_item(NAME(m_pendingIrq));
save_item(NAME(m_pendingFiq));
state_add( ARM32_PC, "PC", m_sArmRegister[15] ).mask(ADDRESS_MASK).formatstr("%08X");
state_add( ARM32_R0, "R0", m_sArmRegister[ 0] ).formatstr("%08X");
state_add( ARM32_R1, "R1", m_sArmRegister[ 1] ).formatstr("%08X");
state_add( ARM32_R2, "R2", m_sArmRegister[ 2] ).formatstr("%08X");
state_add( ARM32_R3, "R3", m_sArmRegister[ 3] ).formatstr("%08X");
state_add( ARM32_R4, "R4", m_sArmRegister[ 4] ).formatstr("%08X");
state_add( ARM32_R5, "R5", m_sArmRegister[ 5] ).formatstr("%08X");
state_add( ARM32_R6, "R6", m_sArmRegister[ 6] ).formatstr("%08X");
state_add( ARM32_R7, "R7", m_sArmRegister[ 7] ).formatstr("%08X");
state_add( ARM32_R8, "R8", m_sArmRegister[ 8] ).formatstr("%08X");
state_add( ARM32_R9, "R9", m_sArmRegister[ 9] ).formatstr("%08X");
state_add( ARM32_R10, "R10", m_sArmRegister[10] ).formatstr("%08X");
state_add( ARM32_R11, "R11", m_sArmRegister[11] ).formatstr("%08X");
state_add( ARM32_R12, "R12", m_sArmRegister[12] ).formatstr("%08X");
state_add( ARM32_R13, "R13", m_sArmRegister[13] ).formatstr("%08X");
state_add( ARM32_R14, "R14", m_sArmRegister[14] ).formatstr("%08X");
state_add( ARM32_R15, "R15", m_sArmRegister[15] ).formatstr("%08X");
state_add( ARM32_FR8, "FR8", m_sArmRegister[eR8_FIQ] ).formatstr("%08X");
state_add( ARM32_FR9, "FR9", m_sArmRegister[eR9_FIQ] ).formatstr("%08X");
state_add( ARM32_FR10, "FR10", m_sArmRegister[eR10_FIQ] ).formatstr("%08X");
state_add( ARM32_FR11, "FR11", m_sArmRegister[eR11_FIQ] ).formatstr("%08X");
state_add( ARM32_FR12, "FR12", m_sArmRegister[eR12_FIQ] ).formatstr("%08X");
state_add( ARM32_FR13, "FR13", m_sArmRegister[eR13_FIQ] ).formatstr("%08X");
state_add( ARM32_FR14, "FR14", m_sArmRegister[eR14_FIQ] ).formatstr("%08X");
state_add( ARM32_IR13, "IR13", m_sArmRegister[eR13_IRQ] ).formatstr("%08X");
state_add( ARM32_IR14, "IR14", m_sArmRegister[eR14_IRQ] ).formatstr("%08X");
state_add( ARM32_SR13, "SR13", m_sArmRegister[eR13_SVC] ).formatstr("%08X");
state_add( ARM32_SR14, "SR14", m_sArmRegister[eR14_SVC] ).formatstr("%08X");
state_add(STATE_GENPC, "curpc", m_sArmRegister[15]).mask(ADDRESS_MASK).callimport().callexport().formatstr("%8s").noshow();
state_add(STATE_GENFLAGS, "GENFLAGS", m_sArmRegister[15]).formatstr("%11s").noshow();
m_icountptr = &m_icount;
}
/****************************************************************************
* Initialize emulation
****************************************************************************/
void alpha8201_cpu_device::device_start()
{
m_program = &space(AS_PROGRAM);
m_direct = &m_program->direct();
state_add( ALPHA8201_PC, "PC", m_pc.w.l ).mask(0x3ff).formatstr("%03X");
state_add( ALPHA8201_SP, "SP", m_sp ).callimport().callexport().formatstr("%02X");
state_add( ALPHA8201_RB, "RB", m_regPtr ).mask(0x7);
state_add( ALPHA8201_MB, "MB", m_mb ).mask(0x3);
state_add( ALPHA8201_CF, "CF", m_cf ).mask(0x1);
state_add( ALPHA8201_ZF, "ZF", m_zf ).mask(0x1);
state_add( ALPHA8201_IX0, "IX0", m_ix0.b.l );
state_add( ALPHA8201_IX1, "IX1", m_ix1.b.l );
state_add( ALPHA8201_IX2, "IX2", m_ix2.b.l );
state_add( ALPHA8201_LP0, "LP0", m_lp0 );
state_add( ALPHA8201_LP1, "LP1", m_lp1 );
state_add( ALPHA8201_LP2, "LP2", m_lp2 );
state_add( ALPHA8201_A, "A", m_A );
state_add( ALPHA8201_B, "B", m_B );
state_add( ALPHA8201_R0, "R0", m_R[0] ).callimport().callexport().formatstr("%02X");
state_add( ALPHA8201_R1, "R1", m_R[1] ).callimport().callexport().formatstr("%02X");
state_add( ALPHA8201_R2, "R2", m_R[2] ).callimport().callexport().formatstr("%02X");
state_add( ALPHA8201_R3, "R3", m_R[3] ).callimport().callexport().formatstr("%02X");
state_add( ALPHA8201_R4, "R4", m_R[4] ).callimport().callexport().formatstr("%02X");
state_add( ALPHA8201_R5, "R5", m_R[5] ).callimport().callexport().formatstr("%02X");
state_add( ALPHA8201_R6, "R6", m_R[6] ).callimport().callexport().formatstr("%02X");
state_add( ALPHA8201_R7, "R7", m_R[7] ).callimport().callexport().formatstr("%02X");
save_item(NAME(m_RAM));
save_item(NAME(m_PREVPC));
save_item(NAME(m_pc.w.l));
save_item(NAME(m_regPtr));
save_item(NAME(m_zf));
save_item(NAME(m_cf));
save_item(NAME(m_mb));
save_item(NAME(m_halt));
save_item(NAME(m_ix0.b.l));
save_item(NAME(m_ix1.b.l));
save_item(NAME(m_ix2.b.l));
save_item(NAME(m_lp0));
save_item(NAME(m_lp1));
save_item(NAME(m_lp2));
save_item(NAME(m_A));
save_item(NAME(m_B));
save_item(NAME(m_retptr));
save_item(NAME(m_savec));
save_item(NAME(m_savez));
m_icountptr = &m_icount;
}
void lh5801_cpu_device::device_start()
{
m_program = &space(AS_PROGRAM);
m_io = &space(AS_IO);
m_direct = &m_program->direct();
m_in_func.resolve_safe(0);
m_s.w.l = 0;
m_p.w.l = 0;
m_u.w.l = 0;
m_x.w.l = 0;
m_y.w.l = 0;
m_tm = 0;
m_t = 0;
m_a = 0;
m_bf = 0;
m_dp = 0;
m_pu = 0;
m_pv = 0;
m_oldpc = 0;
m_irq_state = 0;
memset(m_ir_flipflop, 0, sizeof(m_ir_flipflop));
memset(m_lines_status, 0, sizeof(m_lines_status));
m_idle = 0;
save_item(NAME(m_s.w.l));
save_item(NAME(m_p.w.l));
save_item(NAME(m_u.w.l));
save_item(NAME(m_x.w.l));
save_item(NAME(m_y.w.l));
save_item(NAME(m_tm));
save_item(NAME(m_t));
save_item(NAME(m_a));
save_item(NAME(m_bf));
save_item(NAME(m_dp));
save_item(NAME(m_pu));
save_item(NAME(m_pv));
save_item(NAME(m_oldpc));
save_item(NAME(m_irq_state));
save_item(NAME(m_ir_flipflop));
save_item(NAME(m_lines_status));
save_item(NAME(m_idle));
state_add( LH5801_P, "P", m_p.w.l ).formatstr("%04X");
state_add( LH5801_S, "S", m_s.w.l ).formatstr("%04X");
state_add( LH5801_U, "U", m_u.w.l ).formatstr("%04X");
state_add( LH5801_X, "X", m_x.w.l ).formatstr("%04X");
state_add( LH5801_Y, "Y", m_y.w.l ).formatstr("%04X");
state_add( LH5801_T, "T", m_t ).formatstr("%02X");
state_add( LH5801_A, "A", m_a ).formatstr("%02X");
state_add( LH5801_TM, "TM", m_tm ).formatstr("%03X");
state_add( LH5801_PV, "PV", m_pv ).formatstr("%04X");
state_add( LH5801_PU, "PU", m_pu ).formatstr("%04X");
state_add( LH5801_BF, "BF", m_bf ).formatstr("%04X");
state_add( LH5801_DP, "DP", m_dp ).formatstr("%04X");
state_add(STATE_GENPC, "GENPC", m_p.w.l).noshow();
state_add(STATE_GENFLAGS, "GENFLAGS", m_t).noshow().formatstr("%8s");
m_icountptr = &m_icount;
}
void melps4_cpu_device::device_start()
{
m_program = &space(AS_PROGRAM);
m_data = &space(AS_DATA);
m_prgmask = (1 << m_prgwidth) - 1;
m_datamask = (1 << m_datawidth) - 1;
m_d_mask = (1 << m_d_pins) - 1;
// resolve callbacks
m_read_k.resolve_safe(0);
m_read_d.resolve_safe(0);
m_read_s.resolve_safe(0);
m_read_f.resolve_safe(0);
m_write_d.resolve_safe();
m_write_s.resolve_safe();
m_write_f.resolve_safe();
m_write_g.resolve_safe();
m_write_u.resolve_safe();
m_write_t.resolve_safe();
// zerofill
m_pc = 0;
m_prev_pc = 0;
memset(m_stack, 0, sizeof(m_stack));
m_op = 0;
m_prev_op = 0;
m_bitmask = 0;
m_port_d = 0;
m_port_s = 0;
m_port_f = 0;
m_port_t = 0;
m_sm = m_sms = false;
m_ba_flag = false;
m_sp_param = 0;
m_cps = 0;
m_skip = false;
m_inte = 0;
m_intp = 1;
m_irqflag[0] = m_irqflag[1] = m_irqflag[2] = false;
m_int_state = 0;
m_t_in_state = 0;
m_prohibit_irq = false;
m_possible_irq = false;
memset(m_tmr_count, 0, sizeof(m_tmr_count));
m_tmr_reload = 0;
m_tmr_irq_enabled[0] = m_tmr_irq_enabled[1] = false;
m_a = 0;
m_b = 0;
m_e = 0;
m_y = m_y2 = 0;
m_x = m_x2 = 0;
m_z = m_z2 = 0;
m_cy = m_cy2 = 0;
m_h = 0;
m_l = 0;
m_c = 7;
m_v = 0;
m_w = 0;
// register for savestates
save_item(NAME(m_pc));
save_item(NAME(m_prev_pc));
save_item(NAME(m_stack));
save_item(NAME(m_op));
save_item(NAME(m_prev_op));
save_item(NAME(m_bitmask));
save_item(NAME(m_port_d));
save_item(NAME(m_port_s));
save_item(NAME(m_port_f));
save_item(NAME(m_port_t));
save_item(NAME(m_sm));
save_item(NAME(m_sms));
save_item(NAME(m_ba_flag));
save_item(NAME(m_sp_param));
save_item(NAME(m_cps));
save_item(NAME(m_skip));
save_item(NAME(m_inte));
save_item(NAME(m_intp));
save_item(NAME(m_irqflag));
save_item(NAME(m_int_state));
save_item(NAME(m_t_in_state));
save_item(NAME(m_prohibit_irq));
save_item(NAME(m_possible_irq));
save_item(NAME(m_tmr_count));
save_item(NAME(m_tmr_reload));
save_item(NAME(m_tmr_irq_enabled));
save_item(NAME(m_a));
save_item(NAME(m_b));
save_item(NAME(m_e));
save_item(NAME(m_y)); save_item(NAME(m_y2));
save_item(NAME(m_x)); save_item(NAME(m_x2));
save_item(NAME(m_z)); save_item(NAME(m_z2));
save_item(NAME(m_cy)); save_item(NAME(m_cy2));
save_item(NAME(m_h));
save_item(NAME(m_l));
save_item(NAME(m_c));
save_item(NAME(m_v));
save_item(NAME(m_w));
// register state for debugger
state_add(STATE_GENPC, "curpc", m_pc).formatstr("%04X").noshow();
state_add(STATE_GENFLAGS, "GENFLAGS", m_cy).formatstr("%9s").noshow();
state_add(MELPS4_PC, "PC", m_pc).formatstr("%04X");
state_add(MELPS4_A, "A", m_a).formatstr("%2d"); // show in decimal
state_add(MELPS4_B, "B", m_b).formatstr("%2d"); // "
state_add(MELPS4_E, "E", m_e).formatstr("%02X");
state_add(MELPS4_Y, "Y", m_y).formatstr("%1X");
state_add(MELPS4_X, "X", m_x).formatstr("%1d");
state_add(MELPS4_Z, "Z", m_z).formatstr("%1d");
state_add(MELPS4_H, "H", m_h).formatstr("%1X");
state_add(MELPS4_L, "L", m_l).formatstr("%1X");
state_add(MELPS4_C, "C", m_c).formatstr("%1X");
state_add(MELPS4_V, "V", m_v).formatstr("%1X");
state_add(MELPS4_W, "W", m_w).formatstr("%1X");
m_icountptr = &m_icount;
}
void pic16c62x_device::device_start()
{
m_program = &space(AS_PROGRAM);
m_direct = &m_program->direct();
m_data = &space(AS_DATA);
m_io = &space(AS_IO);
m_CONFIG = 0x3fff;
/* ensure the internal ram pointers are set before get_info is called */
update_internalram_ptr();
build_opcode_table();
save_item(NAME(m_W));
save_item(NAME(m_ALU));
save_item(NAME(m_OPTION));
save_item(NAME(m_PCLATH));
save_item(NAME(TMR0));
save_item(NAME(PCL));
save_item(NAME(STATUS));
save_item(NAME(FSR));
save_item(NAME(PORTA));
save_item(NAME(PORTB));
save_item(NAME(m_TRISA));
save_item(NAME(m_TRISB));
save_item(NAME(m_old_T0));
save_item(NAME(m_old_data));
save_item(NAME(m_picRAMmask));
save_item(NAME(m_WDT));
save_item(NAME(m_prescaler));
save_item(NAME(m_STACK[0]));
save_item(NAME(m_STACK[1]));
save_item(NAME(m_STACK[2]));
save_item(NAME(m_STACK[3]));
save_item(NAME(m_STACK[4]));
save_item(NAME(m_STACK[5]));
save_item(NAME(m_STACK[6]));
save_item(NAME(m_STACK[7]));
save_item(NAME(m_PC));
save_item(NAME(m_PREVPC));
save_item(NAME(m_CONFIG));
save_item(NAME(m_opcode.d));
save_item(NAME(m_delay_timer));
save_item(NAME(m_picmodel));
save_item(NAME(m_reset_vector));
save_item(NAME(m_temp_config));
save_item(NAME(m_inst_cycles));
state_add( PIC16C62x_PC, "PC", m_PC).mask(0xfff).formatstr("%03X");
state_add( PIC16C62x_W, "W", m_W).formatstr("%02X");
state_add( PIC16C62x_ALU, "ALU", m_ALU).formatstr("%02X");
state_add( PIC16C62x_STR, "STR", m_debugger_temp).mask(0xff).callimport().callexport().formatstr("%02X");
state_add( PIC16C62x_TMR0, "TMR", m_debugger_temp).mask(0xff).callimport().callexport().formatstr("%02X");
state_add( PIC16C62x_WDT, "WDT", m_WDT).formatstr("%04X");
state_add( PIC16C62x_OPT, "OPT", m_OPTION).formatstr("%02X");
state_add( PIC16C62x_STK0, "STK0", m_STACK[0]).mask(0xfff).formatstr("%03X");
state_add( PIC16C62x_STK1, "STK1", m_STACK[1]).mask(0xfff).formatstr("%03X");
state_add( PIC16C62x_STK2, "STK2", m_STACK[2]).mask(0xfff).formatstr("%03X");
state_add( PIC16C62x_STK3, "STK3", m_STACK[3]).mask(0xfff).formatstr("%03X");
state_add( PIC16C62x_STK4, "STK4", m_STACK[4]).mask(0xfff).formatstr("%03X");
state_add( PIC16C62x_STK5, "STK5", m_STACK[5]).mask(0xfff).formatstr("%03X");
state_add( PIC16C62x_STK6, "STK6", m_STACK[6]).mask(0xfff).formatstr("%03X");
state_add( PIC16C62x_STK7, "STK7", m_STACK[7]).mask(0xfff).formatstr("%03X");
state_add( PIC16C62x_PRTA, "PRTA", m_debugger_temp).mask(0x1f).callimport().callexport().formatstr("%02X");
state_add( PIC16C62x_PRTB, "PRTB", m_debugger_temp).mask(0xff).callimport().callexport().formatstr("%02X");
state_add( PIC16C62x_TRSA, "TRSA", m_TRISA).mask(0x1f).formatstr("%02X");
state_add( PIC16C62x_TRSB, "TRSB", m_TRISB).formatstr("%02X");
state_add( PIC16C62x_FSR, "FSR", m_debugger_temp).mask(0xff).callimport().callexport().formatstr("%02X");
state_add( PIC16C62x_PSCL, "PSCL", m_debugger_temp).callimport().formatstr("%3s");
state_add( STATE_GENPC, "GENPC", m_PC).noshow();
state_add( STATE_GENFLAGS, "GENFLAGS", m_OPTION).formatstr("%13s").noshow();
state_add( STATE_GENPCBASE, "PREVPC", m_PREVPC).noshow();
m_icountptr = &m_icount;
}
void cosmac_device::device_start()
{
// resolve callbacks
m_read_wait.resolve_safe(0);
m_read_clear.resolve_safe(0);
m_read_ef1.resolve();
m_read_ef2.resolve();
m_read_ef3.resolve();
m_read_ef4.resolve();
m_write_q.resolve_safe();
m_read_dma.resolve_safe(0);
m_write_dma.resolve_safe();
m_write_sc.resolve_safe();
// get our address spaces
m_program = &space(AS_PROGRAM);
m_direct = &m_program->direct();
m_io = &space(AS_IO);
// register our state for the debugger
state_add(STATE_GENPC, "GENPC", m_pc).callimport().callexport().noshow();
state_add(STATE_GENFLAGS, "GENFLAGS", m_flagsio).mask(0x7).callimport().callexport().noshow().formatstr("%3s");
state_add(COSMAC_P, "P", m_p).mask(0xf);
state_add(COSMAC_X, "X", m_x).mask(0xf);
state_add(COSMAC_D, "D", m_d);
state_add(COSMAC_B, "B", m_b);
state_add(COSMAC_T, "T", m_t);
state_add(COSMAC_I, "I", m_i).mask(0xf);
state_add(COSMAC_N, "N", m_n).mask(0xf);
std::string tempstr;
for (int regnum = 0; regnum < 16; regnum++)
state_add(COSMAC_R0 + regnum, strformat(tempstr, "R%x", regnum).c_str(), m_r[regnum]);
state_add(COSMAC_DF, "DF", m_df).mask(0x1).noshow();
state_add(COSMAC_IE, "IE", m_ie).mask(0x1).noshow();
state_add(COSMAC_Q, "Q", m_q).mask(0x1).noshow();
// register our state for saving
save_item(NAME(m_op));
save_item(NAME(m_flagsio));
save_item(NAME(m_state));
save_item(NAME(m_mode));
save_item(NAME(m_pmode));
save_item(NAME(m_irq));
save_item(NAME(m_dmain));
save_item(NAME(m_dmaout));
save_item(NAME(m_ef));
save_item(NAME(m_d));
save_item(NAME(m_b));
save_item(NAME(m_r));
save_item(NAME(m_p));
save_item(NAME(m_x));
save_item(NAME(m_n));
save_item(NAME(m_i));
save_item(NAME(m_t));
save_item(NAME(m_df));
save_item(NAME(m_ie));
save_item(NAME(m_q));
// set our instruction counter
m_icountptr = &m_icount;
}
void amis2000_base_device::device_start()
{
m_program = &space(AS_PROGRAM);
m_data = &space(AS_DATA);
m_read_k.resolve_safe(0xf);
m_read_i.resolve_safe(0xf);
m_read_d.resolve_safe(0);
m_write_d.resolve_safe();
m_write_a.resolve_safe();
m_write_f.resolve_safe();
m_bu_mask = (1 << m_bu_bits) - 1;
m_callstack_mask = (1 << m_callstack_bits) - 1;
// zerofill
memset(m_callstack, 0, sizeof(m_callstack));
m_pc = 0;
m_ppr = 0;
m_pbr = 0;
m_skip = false;
m_op = 0;
m_prev_op = 0;
m_f = 0;
m_carry = 0;
m_bl = 0;
m_bu = 0;
m_acc = 0;
m_e = 0;
m_ki_mask = 0;
m_d = 0;
m_d_active = false;
m_d_polarity = 0;
m_a = 0;
// register for savestates
save_item(NAME(m_callstack));
save_item(NAME(m_pc));
save_item(NAME(m_ppr));
save_item(NAME(m_pbr));
save_item(NAME(m_skip));
save_item(NAME(m_op));
save_item(NAME(m_prev_op));
save_item(NAME(m_f));
save_item(NAME(m_carry));
save_item(NAME(m_bl));
save_item(NAME(m_bu));
save_item(NAME(m_acc));
save_item(NAME(m_e));
save_item(NAME(m_ki_mask));
save_item(NAME(m_d));
save_item(NAME(m_d_active));
save_item(NAME(m_d_polarity));
save_item(NAME(m_a));
// register state for debugger
state_add(S2000_PC, "PC", m_pc ).formatstr("%04X");
state_add(S2000_BL, "BL", m_bl ).formatstr("%01X");
state_add(S2000_BU, "BU", m_bu ).formatstr("%01X");
state_add(S2000_ACC, "ACC", m_acc ).formatstr("%01X");
state_add(S2000_E, "E", m_e ).formatstr("%01X");
state_add(S2000_CY, "CY", m_carry ).formatstr("%01X");
state_add(STATE_GENPCBASE, "CURPC", m_pc).noshow();
state_add(STATE_GENFLAGS, "CURFLAGS", m_f).formatstr("%6s").noshow();
m_icountptr = &m_icount;
}
void i860_cpu_device::device_start()
{
m_program = &space(AS_PROGRAM);
reset_i860();
i860_set_pin(DEC_PIN_BUS_HOLD, 0);
i860_set_pin(DEC_PIN_RESET, 0);
m_single_stepping = 0;
save_item(NAME(m_iregs));
save_item(NAME(m_cregs));
save_item(NAME(m_frg));
save_item(NAME(m_pc));
state_add( I860_PC, "PC", m_pc).formatstr("%08X");
state_add( I860_FIR, "FIR", m_cregs[CR_FIR]).formatstr("%08X");
state_add( I860_PSR, "PSR", m_cregs[CR_PSR]).formatstr("%08X");
state_add( I860_DIRBASE, "DIRBASE", m_cregs[CR_DIRBASE]).formatstr("%08X");
state_add( I860_DB, "DB", m_cregs[CR_DB]).formatstr("%08X");
state_add( I860_FSR, "FSR", m_cregs[CR_FSR]).formatstr("%08X");
state_add( I860_EPSR, "EPSR", m_cregs[CR_EPSR]).formatstr("%08X");
state_add( I860_R0, "R0", m_iregs[0]).formatstr("%08X");
state_add( I860_R1, "R1", m_iregs[1]).formatstr("%08X");
state_add( I860_R2, "R2", m_iregs[2]).formatstr("%08X");
state_add( I860_R3, "R3", m_iregs[3]).formatstr("%08X");
state_add( I860_R4, "R4", m_iregs[4]).formatstr("%08X");
state_add( I860_R5, "R5", m_iregs[5]).formatstr("%08X");
state_add( I860_R6, "R6", m_iregs[6]).formatstr("%08X");
state_add( I860_R7, "R7", m_iregs[7]).formatstr("%08X");
state_add( I860_R8, "R8", m_iregs[8]).formatstr("%08X");
state_add( I860_R9, "R9", m_iregs[9]).formatstr("%08X");
state_add( I860_R10, "R10", m_iregs[10]).formatstr("%08X");
state_add( I860_R11, "R11", m_iregs[11]).formatstr("%08X");
state_add( I860_R12, "R12", m_iregs[12]).formatstr("%08X");
state_add( I860_R13, "R13", m_iregs[13]).formatstr("%08X");
state_add( I860_R14, "R14", m_iregs[14]).formatstr("%08X");
state_add( I860_R15, "R15", m_iregs[15]).formatstr("%08X");
state_add( I860_R16, "R16", m_iregs[16]).formatstr("%08X");
state_add( I860_R17, "R17", m_iregs[17]).formatstr("%08X");
state_add( I860_R18, "R18", m_iregs[18]).formatstr("%08X");
state_add( I860_R19, "R19", m_iregs[19]).formatstr("%08X");
state_add( I860_R20, "R20", m_iregs[20]).formatstr("%08X");
state_add( I860_R21, "R21", m_iregs[21]).formatstr("%08X");
state_add( I860_R22, "R22", m_iregs[22]).formatstr("%08X");
state_add( I860_R23, "R23", m_iregs[23]).formatstr("%08X");
state_add( I860_R24, "R24", m_iregs[24]).formatstr("%08X");
state_add( I860_R25, "R25", m_iregs[25]).formatstr("%08X");
state_add( I860_R26, "R26", m_iregs[26]).formatstr("%08X");
state_add( I860_R27, "R27", m_iregs[27]).formatstr("%08X");
state_add( I860_R28, "R28", m_iregs[28]).formatstr("%08X");
state_add( I860_R29, "R29", m_iregs[29]).formatstr("%08X");
state_add( I860_R30, "R30", m_iregs[30]).formatstr("%08X");
state_add( I860_R31, "R31", m_iregs[31]).formatstr("%08X");
state_add( I860_F0, "F0", m_freg[0]).callimport().callexport().formatstr("%08X");
state_add( I860_F1, "F1", m_freg[1]).callimport().callexport().formatstr("%08X");
state_add( I860_F2, "F2", m_freg[2]).callimport().callexport().formatstr("%08X");
state_add( I860_F3, "F3", m_freg[3]).callimport().callexport().formatstr("%08X");
state_add( I860_F4, "F4", m_freg[4]).callimport().callexport().formatstr("%08X");
state_add( I860_F5, "F5", m_freg[5]).callimport().callexport().formatstr("%08X");
state_add( I860_F6, "F6", m_freg[6]).callimport().callexport().formatstr("%08X");
state_add( I860_F7, "F7", m_freg[7]).callimport().callexport().formatstr("%08X");
state_add( I860_F8, "F8", m_freg[8]).callimport().callexport().formatstr("%08X");
state_add( I860_F9, "F9", m_freg[9]).callimport().callexport().formatstr("%08X");
state_add( I860_F10, "F10", m_freg[10]).callimport().callexport().formatstr("%08X");
state_add( I860_F11, "F11", m_freg[11]).callimport().callexport().formatstr("%08X");
state_add( I860_F12, "F12", m_freg[12]).callimport().callexport().formatstr("%08X");
state_add( I860_F13, "F13", m_freg[13]).callimport().callexport().formatstr("%08X");
state_add( I860_F14, "F14", m_freg[14]).callimport().callexport().formatstr("%08X");
state_add( I860_F15, "F15", m_freg[15]).callimport().callexport().formatstr("%08X");
state_add( I860_F16, "F16", m_freg[16]).callimport().callexport().formatstr("%08X");
state_add( I860_F17, "F17", m_freg[17]).callimport().callexport().formatstr("%08X");
state_add( I860_F18, "F18", m_freg[18]).callimport().callexport().formatstr("%08X");
state_add( I860_F19, "F19", m_freg[19]).callimport().callexport().formatstr("%08X");
state_add( I860_F20, "F20", m_freg[20]).callimport().callexport().formatstr("%08X");
state_add( I860_F21, "F21", m_freg[21]).callimport().callexport().formatstr("%08X");
state_add( I860_F22, "F22", m_freg[22]).callimport().callexport().formatstr("%08X");
state_add( I860_F23, "F23", m_freg[23]).callimport().callexport().formatstr("%08X");
state_add( I860_F24, "F24", m_freg[24]).callimport().callexport().formatstr("%08X");
state_add( I860_F25, "F25", m_freg[25]).callimport().callexport().formatstr("%08X");
state_add( I860_F26, "F26", m_freg[26]).callimport().callexport().formatstr("%08X");
state_add( I860_F27, "F27", m_freg[27]).callimport().callexport().formatstr("%08X");
state_add( I860_F28, "F28", m_freg[28]).callimport().callexport().formatstr("%08X");
state_add( I860_F29, "F29", m_freg[29]).callimport().callexport().formatstr("%08X");
state_add( I860_F30, "F30", m_freg[30]).callimport().callexport().formatstr("%08X");
state_add( I860_F31, "F31", m_freg[31]).callimport().callexport().formatstr("%08X");
state_add(STATE_GENPC, "curpc", m_pc).noshow();
m_icountptr = &m_icount;
}
void am29000_cpu_device::device_start()
{
m_program = &space(AS_PROGRAM);
m_direct = m_program->direct<0>();
m_data = &space(AS_DATA);
m_datadirect = m_data->direct<0>();
m_io = &space(AS_IO);
m_cfg = (PRL_AM29000 | PRL_REV_D) << CFG_PRL_SHIFT;
/* Register state for saving */
save_item(NAME(m_pc));
save_item(NAME(m_r));
save_item(NAME(m_tlb));
save_item(NAME(m_vab));
save_item(NAME(m_ops));
save_item(NAME(m_cps));
save_item(NAME(m_cfg));
save_item(NAME(m_cha));
save_item(NAME(m_chd));
save_item(NAME(m_chc));
save_item(NAME(m_rbp));
save_item(NAME(m_tmc));
save_item(NAME(m_tmr));
save_item(NAME(m_pc0));
save_item(NAME(m_pc1));
save_item(NAME(m_pc2));
save_item(NAME(m_mmu));
save_item(NAME(m_lru));
save_item(NAME(m_ipc));
save_item(NAME(m_ipa));
save_item(NAME(m_ipb));
save_item(NAME(m_q));
save_item(NAME(m_alu));
save_item(NAME(m_fpe));
save_item(NAME(m_inte));
save_item(NAME(m_fps));
save_item(NAME(m_exceptions));
save_item(NAME(m_exception_queue));
save_item(NAME(m_irq_active));
save_item(NAME(m_irq_lines));
save_item(NAME(m_exec_ir));
save_item(NAME(m_next_ir));
save_item(NAME(m_pl_flags));
save_item(NAME(m_next_pl_flags));
save_item(NAME(m_iret_pc));
save_item(NAME(m_exec_pc));
save_item(NAME(m_next_pc));
// Register state for debugger
state_add( AM29000_PC, "PC", m_pc ).callimport().formatstr("%08X");
state_add( AM29000_VAB, "VAB", m_vab ).formatstr("%08X");
state_add( AM29000_OPS, "OPS", m_ops ).formatstr("%08X");
state_add( AM29000_CPS, "CPS", m_cps ).formatstr("%08X");
state_add( AM29000_CFG, "CFG", m_cfg ).formatstr("%08X");
state_add( AM29000_CHA, "CHA", m_cha ).formatstr("%08X");
state_add( AM29000_CHD, "CHD", m_chd ).formatstr("%08X");
state_add( AM29000_CHC, "CHC", m_chc ).formatstr("%08X");
state_add( AM29000_RBP, "RBP", m_rbp ).formatstr("%08X");
state_add( AM29000_TMC, "TMC", m_tmc ).formatstr("%08X");
state_add( AM29000_TMR, "TMR", m_tmr ).formatstr("%08X");
state_add( AM29000_PC0, "PC0", m_pc0 ).formatstr("%08X");
state_add( AM29000_PC1, "PC1", m_pc1 ).formatstr("%08X");
state_add( AM29000_PC2, "PC2", m_pc2 ).formatstr("%08X");
state_add( AM29000_MMU, "MMU", m_mmu ).formatstr("%08X");
state_add( AM29000_LRU, "LRU", m_lru ).formatstr("%08X");
state_add( AM29000_IPC, "IPC", m_ipc ).formatstr("%08X");
state_add( AM29000_IPA, "IPA", m_ipa ).formatstr("%08X");
state_add( AM29000_IPB, "IPB", m_ipb ).formatstr("%08X");
state_add( AM29000_Q, "Q", m_q ).formatstr("%08X");
state_add( AM29000_ALU, "ALU", m_alu ).formatstr("%08X");
// state_add( AM29000_BP, "BP", GET_ALU_BP).formatstr("%08X");
// state_add( AM29000_FC, "FC", GET_ALU_FC).formatstr("%08X");
// state_add( AM29000_CR, "CR", GET_CHC_CR).formatstr("%08X");
state_add( AM29000_FPE, "FPE", m_fpe ).formatstr("%08X");
state_add( AM29000_INTE, "INTE", m_inte ).formatstr("%08X");
state_add( AM29000_FPS, "FPS", m_fps ).formatstr("%08X");
state_add( AM29000_R1, "R1", m_r[1] ).formatstr("%08X");
state_add( AM29000_R64, "R64", m_r[64] ).formatstr("%08X");
state_add( AM29000_R65, "R65", m_r[65] ).formatstr("%08X");
state_add( AM29000_R66, "R66", m_r[66] ).formatstr("%08X");
state_add( AM29000_R67, "R67", m_r[67] ).formatstr("%08X");
state_add( AM29000_R68, "R68", m_r[68] ).formatstr("%08X");
state_add( AM29000_R69, "R69", m_r[69] ).formatstr("%08X");
state_add( AM29000_R70, "R70", m_r[70] ).formatstr("%08X");
state_add( AM29000_R71, "R71", m_r[71] ).formatstr("%08X");
state_add( AM29000_R72, "R72", m_r[72] ).formatstr("%08X");
state_add( AM29000_R73, "R73", m_r[73] ).formatstr("%08X");
state_add( AM29000_R74, "R74", m_r[74] ).formatstr("%08X");
state_add( AM29000_R75, "R75", m_r[75] ).formatstr("%08X");
state_add( AM29000_R76, "R76", m_r[76] ).formatstr("%08X");
state_add( AM29000_R77, "R77", m_r[77] ).formatstr("%08X");
state_add( AM29000_R78, "R78", m_r[78] ).formatstr("%08X");
state_add( AM29000_R79, "R79", m_r[79] ).formatstr("%08X");
state_add( AM29000_R80, "R80", m_r[80] ).formatstr("%08X");
state_add( AM29000_R81, "R81", m_r[81] ).formatstr("%08X");
state_add( AM29000_R82, "R82", m_r[82] ).formatstr("%08X");
state_add( AM29000_R83, "R83", m_r[83] ).formatstr("%08X");
state_add( AM29000_R84, "R84", m_r[84] ).formatstr("%08X");
state_add( AM29000_R85, "R85", m_r[85] ).formatstr("%08X");
state_add( AM29000_R86, "R86", m_r[86] ).formatstr("%08X");
state_add( AM29000_R87, "R87", m_r[87] ).formatstr("%08X");
state_add( AM29000_R88, "R88", m_r[88] ).formatstr("%08X");
state_add( AM29000_R89, "R89", m_r[89] ).formatstr("%08X");
state_add( AM29000_R90, "R90", m_r[90] ).formatstr("%08X");
state_add( AM29000_R91, "R91", m_r[91] ).formatstr("%08X");
state_add( AM29000_R92, "R92", m_r[92] ).formatstr("%08X");
state_add( AM29000_R93, "R93", m_r[93] ).formatstr("%08X");
state_add( AM29000_R94, "R94", m_r[94] ).formatstr("%08X");
state_add( AM29000_R95, "R95", m_r[95] ).formatstr("%08X");
state_add( AM29000_R96, "R96", m_r[96] ).formatstr("%08X");
state_add( AM29000_R97, "R97", m_r[97] ).formatstr("%08X");
state_add( AM29000_R98, "R98", m_r[98] ).formatstr("%08X");
state_add( AM29000_R99, "R99", m_r[99] ).formatstr("%08X");
state_add( AM29000_R100, "R100", m_r[100] ).formatstr("%08X");
state_add( AM29000_R101, "R101", m_r[101] ).formatstr("%08X");
state_add( AM29000_R102, "R102", m_r[102] ).formatstr("%08X");
state_add( AM29000_R103, "R103", m_r[103] ).formatstr("%08X");
state_add( AM29000_R104, "R104", m_r[104] ).formatstr("%08X");
state_add( AM29000_R105, "R105", m_r[105] ).formatstr("%08X");
state_add( AM29000_R106, "R106", m_r[106] ).formatstr("%08X");
state_add( AM29000_R107, "R107", m_r[107] ).formatstr("%08X");
state_add( AM29000_R108, "R108", m_r[108] ).formatstr("%08X");
state_add( AM29000_R109, "R109", m_r[109] ).formatstr("%08X");
state_add( AM29000_R110, "R110", m_r[110] ).formatstr("%08X");
state_add( AM29000_R111, "R111", m_r[111] ).formatstr("%08X");
state_add( AM29000_R112, "R112", m_r[112] ).formatstr("%08X");
state_add( AM29000_R113, "R113", m_r[113] ).formatstr("%08X");
state_add( AM29000_R114, "R114", m_r[114] ).formatstr("%08X");
state_add( AM29000_R115, "R115", m_r[115] ).formatstr("%08X");
state_add( AM29000_R116, "R116", m_r[116] ).formatstr("%08X");
state_add( AM29000_R117, "R117", m_r[117] ).formatstr("%08X");
state_add( AM29000_R118, "R118", m_r[118] ).formatstr("%08X");
state_add( AM29000_R119, "R119", m_r[119] ).formatstr("%08X");
state_add( AM29000_R120, "R120", m_r[120] ).formatstr("%08X");
state_add( AM29000_R121, "R121", m_r[121] ).formatstr("%08X");
state_add( AM29000_R122, "R122", m_r[122] ).formatstr("%08X");
state_add( AM29000_R123, "R123", m_r[123] ).formatstr("%08X");
state_add( AM29000_R124, "R124", m_r[124] ).formatstr("%08X");
state_add( AM29000_R125, "R125", m_r[125] ).formatstr("%08X");
state_add( AM29000_R126, "R126", m_r[126] ).formatstr("%08X");
state_add( AM29000_R127, "R127", m_r[127] ).formatstr("%08X");
state_add( AM29000_R128, "R128", m_r[128] ).formatstr("%08X");
state_add( AM29000_R129, "R129", m_r[129] ).formatstr("%08X");
state_add( AM29000_R130, "R130", m_r[130] ).formatstr("%08X");
state_add( AM29000_R131, "R131", m_r[131] ).formatstr("%08X");
state_add( AM29000_R132, "R132", m_r[132] ).formatstr("%08X");
state_add( AM29000_R133, "R133", m_r[133] ).formatstr("%08X");
state_add( AM29000_R134, "R134", m_r[134] ).formatstr("%08X");
state_add( AM29000_R135, "R135", m_r[135] ).formatstr("%08X");
state_add( AM29000_R136, "R136", m_r[136] ).formatstr("%08X");
state_add( AM29000_R137, "R137", m_r[137] ).formatstr("%08X");
state_add( AM29000_R138, "R138", m_r[138] ).formatstr("%08X");
state_add( AM29000_R139, "R139", m_r[139] ).formatstr("%08X");
state_add( AM29000_R140, "R140", m_r[140] ).formatstr("%08X");
state_add( AM29000_R141, "R141", m_r[141] ).formatstr("%08X");
state_add( AM29000_R142, "R142", m_r[142] ).formatstr("%08X");
state_add( AM29000_R143, "R143", m_r[143] ).formatstr("%08X");
state_add( AM29000_R144, "R144", m_r[144] ).formatstr("%08X");
state_add( AM29000_R145, "R145", m_r[145] ).formatstr("%08X");
state_add( AM29000_R146, "R146", m_r[146] ).formatstr("%08X");
state_add( AM29000_R147, "R147", m_r[147] ).formatstr("%08X");
state_add( AM29000_R148, "R148", m_r[148] ).formatstr("%08X");
state_add( AM29000_R149, "R149", m_r[149] ).formatstr("%08X");
state_add( AM29000_R150, "R150", m_r[150] ).formatstr("%08X");
state_add( AM29000_R151, "R151", m_r[151] ).formatstr("%08X");
state_add( AM29000_R152, "R152", m_r[152] ).formatstr("%08X");
state_add( AM29000_R153, "R153", m_r[153] ).formatstr("%08X");
state_add( AM29000_R154, "R154", m_r[154] ).formatstr("%08X");
state_add( AM29000_R155, "R155", m_r[155] ).formatstr("%08X");
state_add( AM29000_R156, "R156", m_r[156] ).formatstr("%08X");
state_add( AM29000_R157, "R157", m_r[157] ).formatstr("%08X");
state_add( AM29000_R158, "R158", m_r[158] ).formatstr("%08X");
state_add( AM29000_R159, "R159", m_r[159] ).formatstr("%08X");
state_add( AM29000_R160, "R160", m_r[160] ).formatstr("%08X");
state_add( AM29000_R161, "R161", m_r[161] ).formatstr("%08X");
state_add( AM29000_R162, "R162", m_r[162] ).formatstr("%08X");
state_add( AM29000_R163, "R163", m_r[163] ).formatstr("%08X");
state_add( AM29000_R164, "R164", m_r[164] ).formatstr("%08X");
state_add( AM29000_R165, "R165", m_r[165] ).formatstr("%08X");
state_add( AM29000_R166, "R166", m_r[166] ).formatstr("%08X");
state_add( AM29000_R167, "R167", m_r[167] ).formatstr("%08X");
state_add( AM29000_R168, "R168", m_r[168] ).formatstr("%08X");
state_add( AM29000_R169, "R169", m_r[169] ).formatstr("%08X");
state_add( AM29000_R170, "R170", m_r[170] ).formatstr("%08X");
state_add( AM29000_R171, "R171", m_r[171] ).formatstr("%08X");
state_add( AM29000_R172, "R172", m_r[172] ).formatstr("%08X");
state_add( AM29000_R173, "R173", m_r[173] ).formatstr("%08X");
state_add( AM29000_R174, "R174", m_r[174] ).formatstr("%08X");
state_add( AM29000_R175, "R175", m_r[175] ).formatstr("%08X");
state_add( AM29000_R176, "R176", m_r[176] ).formatstr("%08X");
state_add( AM29000_R177, "R177", m_r[177] ).formatstr("%08X");
state_add( AM29000_R178, "R178", m_r[178] ).formatstr("%08X");
state_add( AM29000_R179, "R179", m_r[179] ).formatstr("%08X");
state_add( AM29000_R180, "R180", m_r[180] ).formatstr("%08X");
state_add( AM29000_R181, "R181", m_r[181] ).formatstr("%08X");
state_add( AM29000_R182, "R182", m_r[182] ).formatstr("%08X");
state_add( AM29000_R183, "R183", m_r[183] ).formatstr("%08X");
state_add( AM29000_R184, "R184", m_r[184] ).formatstr("%08X");
state_add( AM29000_R185, "R185", m_r[185] ).formatstr("%08X");
state_add( AM29000_R186, "R186", m_r[186] ).formatstr("%08X");
state_add( AM29000_R187, "R187", m_r[187] ).formatstr("%08X");
state_add( AM29000_R188, "R188", m_r[188] ).formatstr("%08X");
state_add( AM29000_R189, "R189", m_r[189] ).formatstr("%08X");
state_add( AM29000_R190, "R190", m_r[190] ).formatstr("%08X");
state_add( AM29000_R191, "R191", m_r[191] ).formatstr("%08X");
state_add( AM29000_R192, "R192", m_r[192] ).formatstr("%08X");
state_add( AM29000_R193, "R193", m_r[193] ).formatstr("%08X");
state_add( AM29000_R194, "R194", m_r[194] ).formatstr("%08X");
state_add( AM29000_R195, "R195", m_r[195] ).formatstr("%08X");
state_add( AM29000_R196, "R196", m_r[196] ).formatstr("%08X");
state_add( AM29000_R197, "R197", m_r[197] ).formatstr("%08X");
state_add( AM29000_R198, "R198", m_r[198] ).formatstr("%08X");
state_add( AM29000_R199, "R199", m_r[199] ).formatstr("%08X");
state_add( AM29000_R200, "R200", m_r[200] ).formatstr("%08X");
state_add( AM29000_R201, "R201", m_r[201] ).formatstr("%08X");
state_add( AM29000_R202, "R202", m_r[202] ).formatstr("%08X");
state_add( AM29000_R203, "R203", m_r[203] ).formatstr("%08X");
state_add( AM29000_R204, "R204", m_r[204] ).formatstr("%08X");
state_add( AM29000_R205, "R205", m_r[205] ).formatstr("%08X");
state_add( AM29000_R206, "R206", m_r[206] ).formatstr("%08X");
state_add( AM29000_R207, "R207", m_r[207] ).formatstr("%08X");
state_add( AM29000_R208, "R208", m_r[208] ).formatstr("%08X");
state_add( AM29000_R209, "R209", m_r[209] ).formatstr("%08X");
state_add( AM29000_R210, "R210", m_r[210] ).formatstr("%08X");
state_add( AM29000_R211, "R211", m_r[211] ).formatstr("%08X");
state_add( AM29000_R212, "R212", m_r[212] ).formatstr("%08X");
state_add( AM29000_R213, "R213", m_r[213] ).formatstr("%08X");
state_add( AM29000_R214, "R214", m_r[214] ).formatstr("%08X");
state_add( AM29000_R215, "R215", m_r[215] ).formatstr("%08X");
state_add( AM29000_R216, "R216", m_r[216] ).formatstr("%08X");
state_add( AM29000_R217, "R217", m_r[217] ).formatstr("%08X");
state_add( AM29000_R218, "R218", m_r[218] ).formatstr("%08X");
state_add( AM29000_R219, "R219", m_r[219] ).formatstr("%08X");
state_add( AM29000_R220, "R220", m_r[220] ).formatstr("%08X");
state_add( AM29000_R221, "R221", m_r[221] ).formatstr("%08X");
state_add( AM29000_R222, "R222", m_r[222] ).formatstr("%08X");
state_add( AM29000_R223, "R223", m_r[223] ).formatstr("%08X");
state_add( AM29000_R224, "R224", m_r[224] ).formatstr("%08X");
state_add( AM29000_R225, "R225", m_r[225] ).formatstr("%08X");
state_add( AM29000_R226, "R226", m_r[226] ).formatstr("%08X");
state_add( AM29000_R227, "R227", m_r[227] ).formatstr("%08X");
state_add( AM29000_R228, "R228", m_r[228] ).formatstr("%08X");
state_add( AM29000_R229, "R229", m_r[229] ).formatstr("%08X");
state_add( AM29000_R230, "R230", m_r[230] ).formatstr("%08X");
state_add( AM29000_R231, "R231", m_r[231] ).formatstr("%08X");
state_add( AM29000_R232, "R232", m_r[232] ).formatstr("%08X");
state_add( AM29000_R233, "R233", m_r[233] ).formatstr("%08X");
state_add( AM29000_R234, "R234", m_r[234] ).formatstr("%08X");
state_add( AM29000_R235, "R235", m_r[235] ).formatstr("%08X");
state_add( AM29000_R236, "R236", m_r[236] ).formatstr("%08X");
state_add( AM29000_R237, "R237", m_r[237] ).formatstr("%08X");
state_add( AM29000_R238, "R238", m_r[238] ).formatstr("%08X");
state_add( AM29000_R239, "R239", m_r[239] ).formatstr("%08X");
state_add( AM29000_R240, "R240", m_r[240] ).formatstr("%08X");
state_add( AM29000_R241, "R241", m_r[241] ).formatstr("%08X");
state_add( AM29000_R242, "R242", m_r[242] ).formatstr("%08X");
state_add( AM29000_R243, "R243", m_r[243] ).formatstr("%08X");
state_add( AM29000_R244, "R244", m_r[244] ).formatstr("%08X");
state_add( AM29000_R245, "R245", m_r[245] ).formatstr("%08X");
state_add( AM29000_R246, "R246", m_r[246] ).formatstr("%08X");
state_add( AM29000_R247, "R247", m_r[247] ).formatstr("%08X");
state_add( AM29000_R248, "R248", m_r[248] ).formatstr("%08X");
state_add( AM29000_R249, "R249", m_r[249] ).formatstr("%08X");
state_add( AM29000_R250, "R250", m_r[250] ).formatstr("%08X");
state_add( AM29000_R251, "R251", m_r[251] ).formatstr("%08X");
state_add( AM29000_R252, "R252", m_r[252] ).formatstr("%08X");
state_add( AM29000_R253, "R253", m_r[253] ).formatstr("%08X");
state_add( AM29000_R254, "R254", m_r[254] ).formatstr("%08X");
state_add( AM29000_R255, "R255", m_r[255] ).formatstr("%08X");
state_add(STATE_GENPCBASE, "CURPC", m_pc).callimport().noshow();
state_add(STATE_GENFLAGS, "CURFLAGS", m_alu).formatstr("%13s").noshow();
set_icountptr(m_icount);
}
