/* Text representation of status */
void tty_report(int cyc) {
sim_log("\nCycle %d. CC=%s, Stat=%s\n", cyc, cc_name(cc), stat_name(status));
sim_log("F: predPC = 0x%x\n", pc_curr->pc);
sim_log("D: instr = %s, rA = %s, rB = %s, valC = 0x%x, valP = 0x%x, Stat = %s\n",
iname(HPACK(if_id_curr->icode, if_id_curr->ifun)),
reg_name(if_id_curr->ra), reg_name(if_id_curr->rb),
if_id_curr->valc, if_id_curr->valp,
stat_name(if_id_curr->status));
sim_log("E: instr = %s, valC = 0x%x, valA = 0x%x, valB = 0x%x\n srcA = %s, srcB = %s, dstE = %s, dstM = %s, Stat = %s\n",
iname(HPACK(id_ex_curr->icode, id_ex_curr->ifun)),
id_ex_curr->valc, id_ex_curr->vala, id_ex_curr->valb,
reg_name(id_ex_curr->srca), reg_name(id_ex_curr->srcb),
reg_name(id_ex_curr->deste), reg_name(id_ex_curr->destm),
stat_name(id_ex_curr->status));
sim_log("M: instr = %s, Cnd = %d, valE = 0x%x, valA = 0x%x\n dstE = %s, dstM = %s, Stat = %s\n",
iname(HPACK(ex_mem_curr->icode, ex_mem_curr->ifun)),
ex_mem_curr->takebranch,
ex_mem_curr->vale, ex_mem_curr->vala,
reg_name(ex_mem_curr->deste), reg_name(ex_mem_curr->destm),
stat_name(ex_mem_curr->status));
sim_log("W: instr = %s, valE = 0x%x, valM = 0x%x, dstE = %s, dstM = %s, Stat = %s\n",
iname(HPACK(mem_wb_curr->icode, mem_wb_curr->ifun)),
mem_wb_curr->vale, mem_wb_curr->valm,
reg_name(mem_wb_curr->deste), reg_name(mem_wb_curr->destm),
stat_name(mem_wb_curr->status));
}
static char *format_pc(pc_ptr state)
{
char pstring[9];
wstring(state->pc, 4, 32, pstring);
sprintf(status_msg, "%s %s", stat_name(state->status), pstring);
return status_msg;
}
int main(int argc, char *argv[])
{
FILE *binfile;
int max_steps = MAX_STEP;
y86sim_t *sim;
mem_t *saver, *savem;
int step = 0;
stat_t e = STAT_AOK;
if (argc < 2 || argc > 3)
usage(argv[0]);
/* set max steps */
if (argc > 2)
max_steps = atoi(argv[2]);
/* load binary file to memory */
if (strcmp(argv[1]+(strlen(argv[1])-4), ".bin"))
usage(argv[0]); /* only support *.bin file */
binfile = fopen(argv[1], "rb");
if (!binfile) {
err_print("Can't open binary file '%s'", argv[1]);
exit(1);
}
sim = new_y86sim(MEM_SIZE);
if (load_binfile(sim->m, binfile) < 0) {
err_print("Failed to load binary file '%s'", argv[1]);
free_y86sim(sim);
exit(1);
}
fclose(binfile);
/* save initial register and memory stat */
saver = dup_reg(sim->r);
savem = dup_mem(sim->m);
/* execute binary code step-by-step */
for (step = 0; step < max_steps && e == STAT_AOK; step++)
e = nexti(sim);
/* print final stat of y86sim */
printf("Stopped in %d steps at PC = 0x%x. Status '%s', CC %s\n",
step, sim->pc, stat_name(e), cc_name(sim->cc));
printf("Changes to registers:\n");
diff_reg(saver, sim->r, stdout);
printf("\nChanges to memory:\n");
diff_mem(savem, sim->m, stdout);
free_y86sim(sim);
free_reg(saver);
free_mem(savem);
return 0;
}
int main(int argc, char *argv[])
{
FILE *code_file;
int max_steps = 10000;
// edit by leo
init_sharemem();
// edit end
state_ptr s = new_state(MEM_SIZE);
mem_t saver = copy_reg(s->r);
mem_t savem;
int step = 0;
stat_t e = STAT_AOK;
if (argc < 2 || argc > 3)
usage(argv[0]);
code_file = fopen(argv[1], "r");
if (!code_file) {
fprintf(stderr, "Can't open code file '%s'\n", argv[1]);
exit(1);
}
if (!load_mem(s->m, code_file, 1)) {
printf("Exiting\n");
return 1;
}
savem = copy_mem(s->m);
// edit by leo
// printf("error happen after here!\n");
// edit end
if (argc > 2)
max_steps = atoi(argv[2]);
for (step = 0; step < max_steps && e == STAT_AOK; step++)
e = step_state(s, stdout);
printf("Stopped in %d steps at PC = 0x%x. Status '%s', CC %s\n",
step, s->pc, stat_name(e), cc_name(s->cc));
printf("Changes to registers:\n");
diff_reg(saver, s->r, stdout);
printf("\nChanges to memory:\n");
diff_mem(savem, s->m, stdout);
free_state(s);
free_reg(saver);
free_mem(savem);
return 0;
}
/* Provide mechanism for simulator to update status display */
void show_stat(stat_t stat)
{
int code;
sprintf(tcl_msg, "showStat %s", stat_name(stat));
code = Tcl_Eval(sim_interp, tcl_msg);
if (code != TCL_OK) {
fprintf(stderr, "Failed to display status\n");
fprintf(stderr, "Error Message was '%s'\n", sim_interp->result);
}
}
static void overlay_set_onoff(struct mmp_overlay *overlay, int on)
{
if (overlay->status == on) {
dev_info(overlay_to_ctrl(overlay)->dev, "overlay %s is already %s\n",
overlay->path->name, stat_name(overlay->status));
return;
}
overlay->status = on;
dmafetch_onoff(overlay, on);
if (overlay->path->ops.check_status(overlay->path)
!= overlay->path->status)
path_onoff(overlay->path, on);
}
BOOL LLFloaterJoystick::postBuild()
{
F32 range = gSavedSettings.getBOOL("Cursor3D") ? 1024.f : 2.f;
LLUIString axis = getString("Axis");
LLUIString joystick = getString("JoystickMonitor");
// use this child to get relative positioning info; we'll place the
// joystick monitor on its right, vertically aligned to it.
LLView* child = getChild<LLView>("FlycamAxisScale1");
LLRect rect;
if (child)
{
LLRect r = child->getRect();
rect = LLRect(350, r.mTop, r.mRight + 200, 0);
}
LLStatView::Params params;
params.name("axis values");
params.rect(rect);
params.show_label(true);
params.label(joystick);
mAxisStatsView = LLUICtrlFactory::create<LLStatView>(params);
for (U32 i = 0; i < 6; i++)
{
axis.setArg("[NUM]", llformat("%d", i));
std::string stat_name(llformat("Joystick axis %d", i));
mAxisStats[i] = new LLStat(stat_name,4);
mAxisStatsBar[i] = mAxisStatsView->addStat(axis, mAxisStats[i]);
mAxisStatsBar[i]->mMinBar = -range;
mAxisStatsBar[i]->mMaxBar = range;
mAxisStatsBar[i]->mLabelSpacing = range * 0.5f;
mAxisStatsBar[i]->mTickSpacing = range * 0.25f;
}
addChild(mAxisStatsView);
mCheckJoystickEnabled = getChild<LLCheckBoxCtrl>("enable_joystick");
childSetCommitCallback("enable_joystick",onCommitJoystickEnabled,this);
mCheckFlycamEnabled = getChild<LLCheckBoxCtrl>("JoystickFlycamEnabled");
childSetCommitCallback("JoystickFlycamEnabled",onCommitJoystickEnabled,this);
getChild<LLUICtrl>("Default")->setCommitCallback(boost::bind(&LLFloaterJoystick::onClickDefault, this, _2));
childSetAction("cancel_btn", onClickCancel, this);
childSetAction("ok_btn", onClickOK, this);
refresh();
return TRUE;
}
char *format_if_id(if_id_ptr state){
char valcstring[9];
char valpstring[9];
wstring(state->valc, 4, 32, valcstring);
wstring(state->valp, 4, 32, valpstring);
sprintf(status_msg, "%s %s %s %s %s %s",
stat_name(state->status),
iname(HPACK(state->icode,state->ifun)),
reg_name(state->ra),
reg_name(state->rb),
valcstring,
valpstring);
return status_msg;
}
char *format_mem_wb(mem_wb_ptr state){
char valestring[9];
char valmstring[9];
wstring(state->vale, 4, 32, valestring);
wstring(state->valm, 4, 32, valmstring);
sprintf(status_msg, "%s %s %s %s %s %s",
stat_name(state->status),
iname(HPACK(state->icode, state->ifun)),
valestring,
valmstring,
reg_name(state->deste),
reg_name(state->destm));
return status_msg;
}
char *format_ex_mem(ex_mem_ptr state){
char valestring[9];
char valastring[9];
wstring(state->vale, 4, 32, valestring);
wstring(state->vala, 4, 32, valastring);
sprintf(status_msg, "%s %s %c %s %s %s %s",
stat_name(state->status),
iname(HPACK(state->icode, state->ifun)),
state->takebranch ? 'Y' : 'N',
valestring,
valastring,
reg_name(state->deste),
reg_name(state->destm));
return status_msg;
}
/* Implement command versions of the simulation functions */
int simResetCmd(ClientData clientData, Tcl_Interp *interp,
int argc, char *argv[])
{
sim_interp = interp;
if (argc != 1) {
interp->result = "No arguments allowed";
return TCL_ERROR;
}
sim_reset();
if (post_load_mem) {
free_mem(mem);
mem = copy_mem(post_load_mem);
}
interp->result = stat_name(STAT_AOK);
return TCL_OK;
}
char *format_id_ex(id_ex_ptr state){
char valcstring[9];
char valastring[9];
char valbstring[9];
wstring(state->valc, 4, 32, valcstring);
wstring(state->vala, 4, 32, valastring);
wstring(state->valb, 4, 32, valbstring);
sprintf(status_msg, "%s %s %s %s %s %s %s %s %s",
stat_name(state->status),
iname(HPACK(state->icode, state->ifun)),
valcstring,
valastring,
valbstring,
reg_name(state->deste),
reg_name(state->destm),
reg_name(state->srca),
reg_name(state->srcb));
return status_msg;
}
static void path_onoff(struct mmp_path *path, int on)
{
if (path->status == on) {
dev_info(path->dev, "path %s is already %s\n",
path->name, stat_name(path->status));
return;
}
if (on) {
path_enabledisable(path, 1);
if (path->panel && path->panel->set_onoff)
path->panel->set_onoff(path->panel, 1);
} else {
if (path->panel && path->panel->set_onoff)
path->panel->set_onoff(path->panel, 0);
path_enabledisable(path, 0);
}
path->status = on;
}
int simRunCmd(ClientData clientData, Tcl_Interp *interp,
int argc, char *argv[])
{
int step_limit = 1;
byte_t run_status;
cc_t cc;
sim_interp = interp;
if (argc > 2) {
interp->result = "At most one argument allowed";
return TCL_ERROR;
}
if (argc >= 2 &&
(sscanf(argv[1], "%d", &step_limit) != 1 ||
step_limit < 0)) {
sprintf(tcl_msg, "Cannot run for '%s' cycles!", argv[1]);
interp->result = tcl_msg;
return TCL_ERROR;
}
sim_run(step_limit, &run_status, &cc);
interp->result = stat_name(run_status);
return TCL_OK;
}
/*
* run_tty_sim - Run the simulator in TTY mode
*/
static void run_tty_sim()
{
int icount = 0;
status = STAT_AOK;
cc_t result_cc = 0;
int byte_cnt = 0;
mem_t mem0, reg0;
state_ptr isa_state = NULL;
/* In TTY mode, the default object file comes from stdin */
if (!object_file) {
object_file = stdin;
}
/* Initializations */
if (verbosity >= 2)
sim_set_dumpfile(stdout);
sim_init();
/* Emit simulator name */
printf("%s\n", simname);
byte_cnt = load_mem(mem, object_file, 1);
if (byte_cnt == 0) {
fprintf(stderr, "No lines of code found\n");
exit(1);
} else if (verbosity >= 2) {
printf("%d bytes of code read\n", byte_cnt);
}
fclose(object_file);
if (do_check) {
isa_state = new_state(0);
free_mem(isa_state->r);
free_mem(isa_state->m);
isa_state->m = copy_mem(mem);
isa_state->r = copy_mem(reg);
isa_state->cc = cc;
}
mem0 = copy_mem(mem);
reg0 = copy_mem(reg);
icount = sim_run(instr_limit, &status, &result_cc);
if (verbosity > 0) {
printf("%d instructions executed\n", icount);
printf("Status = %s\n", stat_name(status));
printf("Condition Codes: %s\n", cc_name(result_cc));
printf("Changed Register State:\n");
diff_reg(reg0, reg, stdout);
printf("Changed Memory State:\n");
diff_mem(mem0, mem, stdout);
}
if (do_check) {
byte_t e = STAT_AOK;
int step;
bool_t match = TRUE;
for (step = 0; step < instr_limit && e == STAT_AOK; step++) {
e = step_state(isa_state, stdout);
}
if (diff_reg(isa_state->r, reg, NULL)) {
match = FALSE;
if (verbosity > 0) {
printf("ISA Register != Pipeline Register File\n");
diff_reg(isa_state->r, reg, stdout);
}
}
if (diff_mem(isa_state->m, mem, NULL)) {
match = FALSE;
if (verbosity > 0) {
printf("ISA Memory != Pipeline Memory\n");
diff_mem(isa_state->m, mem, stdout);
}
}
if (isa_state->cc != result_cc) {
match = FALSE;
if (verbosity > 0) {
printf("ISA Cond. Codes (%s) != Pipeline Cond. Codes (%s)\n",
cc_name(isa_state->cc), cc_name(result_cc));
}
}
if (match) {
printf("ISA Check Succeeds\n");
} else {
printf("ISA Check Fails\n");
}
}
}
static gint main_snooper (GtkWidget *widget, GdkEventKey *kevent, Tbfwin *bfwin) {
Tsnooper *snooper = SNOOPER(bfwin->snooper);
/** check for valid snooper here **/
if ( ! (snooper->stat & SNOOPER_ACTIVE) ) {
DEBUG_MSG("snooper: snooper on bfwin(%p) was disabled...\n", bfwin);
return FALSE;
}
#ifdef DEBUG
{
gchar *tmpstr = stat_name(snooper->stat);
DEBUG_MSG("snooper: stat(%s)press(%d,%d)length(%d)widget(%s)\n", tmpstr,(kevent->type == GDK_KEY_PRESS), kevent->keyval, kevent->length, gtk_widget_get_name(widget) );
g_free(tmpstr);
}
#endif
if (kevent->type == GDK_KEY_PRESS)
SNOOPER(bfwin->snooper)->last_event = (GdkEvent *)kevent;
if ( kevent->type == GDK_KEY_RELEASE
&& ( snooper->stat & (SNOOPER_CANCEL_RELEASE_EVENT | SNOOPER_HAS_EXCUTING_FUNC ) ) ) {
#ifdef DEBUG
{
gchar *tmpstr = stat_name(snooper->stat);
DEBUG_MSG("snooper: exit as stat = %s\n", tmpstr);
g_free(tmpstr);
}
#endif
snooper->stat &= ~(SNOOPER_CANCEL_RELEASE_EVENT | SNOOPER_HAS_EXCUTING_FUNC);
return TRUE;
}
/** special for completion **/
if ( SNOOPER_COMPLETION_ON(bfwin) ) {
DEBUG_MSG("snooper: completion on bfwin = %p\n", bfwin);
if ( SNOOPER_COMPLETION_MOVE(kevent->keyval) ) {
func_complete_move(kevent, bfwin);
snooper->stat |= SNOOPER_CANCEL_RELEASE_EVENT;
return TRUE;
}else if ( SNOOPER_COMPLETION_ACCEPT(kevent->keyval) ) {
func_complete_do(bfwin);
snooper->stat |= SNOOPER_CANCEL_RELEASE_EVENT;
return TRUE;
}else if ( SNOOPER_COMPLETION_ESCAPE(kevent->keyval) ) {
func_complete_hide(bfwin);
snooper->stat |= SNOOPER_CANCEL_RELEASE_EVENT;
return TRUE;
}else if ( SNOOPER_COMPLETION_DELETE(kevent->keyval) ) {
func_complete_delete(widget, bfwin);
snooper->stat |= SNOOPER_CANCEL_RELEASE_EVENT;
return TRUE;
}else if ( snooper->stat & ~SNOOPER_ACTIVE ) {
DEBUG_MSG("snooper: completion shown and snooper->stat >0. hide stuff...\n");
func_complete_hide(bfwin);
}
}
/** if completion is hidden **/
if (kevent->type == GDK_KEY_PRESS) {
if ( ( snooper->stat & ~SNOOPER_ACTIVE ) && ( kevent->keyval == GDK_Escape ) ) {
/* press Escape to cancel the key sequence ; */
snooper->stat = SNOOPER_ACTIVE | SNOOPER_CANCEL_RELEASE_EVENT;
statusbar_message(bfwin , _("sequence cancelled"), 2000);
return TRUE;
}else if ( ( kevent->length || kevent->keyval == GDK_space) && ( ( snooper->stat & SNOOPER_HALF_SEQ ) || SNOOPER_IS_KEYSEQ(kevent) ) ) {
DEBUG_MSG("snooper2: diff(time) = %d\n", kevent->time - ( (GdkEventKey*) snooper -> last_seq ) -> time );
if ( snooper->stat & SNOOPER_HALF_SEQ ) {
snooper->stat &= ~SNOOPER_HALF_SEQ;
snooper_loopkup_keyseq(widget, bfwin, (GdkEventKey*) snooper -> last_seq, kevent);
return TRUE;
} else {
*( (GdkEventKey*) snooper->last_seq )= *kevent;
if (snooper_loopkup_keyseq(widget, bfwin, kevent, NULL) ) {
return TRUE;
}else{
if (snooper_loopkup_keys_in_accel_map(kevent,bfwin)) {
snooper->stat |= SNOOPER_HAS_EXCUTING_FUNC;
return FALSE;
}else{
snooper->stat |= SNOOPER_HALF_SEQ;
return TRUE;
}
}
}
}else if (kevent->length) {
DEBUG_MSG("snooper: not seq; reset stat = 0\n");
snooper->stat = SNOOPER_ACTIVE;
return FALSE;
}
}else{/** key release **/
if ( snooper->stat & SNOOPER_HALF_SEQ ) {
DEBUG_MSG("snooper: in the middle of sequence; release event cancelled\n");
return TRUE;
}
}
return FALSE;
}
