state.c

给予GTK开发的调试工具

	new_gap(vbox);

	r_cr0_text = new_label_and_entry(vbox, "CR0", WLEN_REGISTER);
	r_cr1_text = new_label_and_entry(vbox, "CR1", WLEN_REGISTER);
	r_cr2_text = new_label_and_entry(vbox, "CR2", WLEN_REGISTER);
	r_cr3_text = new_label_and_entry(vbox, "CR3", WLEN_REGISTER);
	r_cr4_text = new_label_and_entry(vbox, "CR4", WLEN_REGISTER);

	/////////////////////////////////////////////

	vbox = new_vbox_1(hbox);

	r_tr_text = new_label_and_entry(vbox, "TR", WLEN_SEGMENT);
	r_ldtr_text = new_label_and_entry(vbox, "LDTR", WLEN_SEGMENT);
	r_gdtr_text = new_label_and_entry(vbox, "GDTR", WLEN_DTABLE);
	r_idtr_text = new_label_and_entry(vbox, "IDTR", WLEN_DTABLE);

	eflags_list = new_sized_list(vbox, EFLAGS_COLUMN_TITLES, eflags_column_titles, FLAGS_LIST_W, FLAGS_LIST_H);
}


#define LEN_TEMP 50
void stateUpdate( ){
	char temp[LEN_TEMP];

	read_state();

	if(!show_state) return;

	snprintf(temp, LEN_TEMP, "%.8X", cpu.eax);
	gtk_entry_set_text(GTK_ENTRY(r_eax_text), temp);
	snprintf(temp, LEN_TEMP, "%.8X", cpu.ebx);
	gtk_entry_set_text(GTK_ENTRY(r_ebx_text), temp);
	snprintf(temp, LEN_TEMP, "%.8X", cpu.ecx);
	gtk_entry_set_text(GTK_ENTRY(r_ecx_text), temp);
	snprintf(temp, LEN_TEMP, "%.8X", cpu.edx);
	gtk_entry_set_text(GTK_ENTRY(r_edx_text), temp);
	if(((cpu.cr0 & 1) && (cpu.ss.descriptor[1] & 0x400000)) || (cpu.ebp > 0xffff))
		snprintf(temp, LEN_TEMP, "%.8X", cpu.ebp);
	else snprintf(temp, LEN_TEMP, "%.4X", cpu.ebp);
	gtk_entry_set_text(GTK_ENTRY(r_ebp_text), temp);
	snprintf(temp, LEN_TEMP, "%.8X", cpu.esi);
	gtk_entry_set_text(GTK_ENTRY(r_esi_text), temp);
	snprintf(temp, LEN_TEMP, "%.8X", cpu.edi);
	gtk_entry_set_text(GTK_ENTRY(r_edi_text), temp);
	if(((cpu.cr0 & 1) && (cpu.ss.descriptor[1] & 0x400000)) || (cpu.esp > 0xffff))
		snprintf(temp, LEN_TEMP, "%.8X", cpu.esp);
	else snprintf(temp, LEN_TEMP, "%.4X", cpu.esp);
	gtk_entry_set_text(GTK_ENTRY(r_esp_text), temp);

	snprintf(temp, LEN_TEMP, "%.8X", cpu.eflags);
	gtk_entry_set_text(GTK_ENTRY(r_eflags_text), temp);
	if(((cpu.cr0 & 1) && (cpu.cs.descriptor[1] & 0x400000)) || (cpu.eip > 0xffff))
		snprintf(temp, LEN_TEMP, "%.8X", cpu.eip);
	else snprintf(temp, LEN_TEMP, "%.4X", cpu.eip);
	gtk_entry_set_text(GTK_ENTRY(r_eip_text), temp);

	snprintf(temp, LEN_TEMP, "%.4X  %s", cpu.cs.segment, (cpu.cs.valid ? "valid" : "invalid"));
	gtk_entry_set_text(GTK_ENTRY(r_cs_text), temp);
	snprintf(temp, LEN_TEMP, "%.4X  %s", cpu.ss.segment, (cpu.ss.valid ? "valid" : "invalid"));
	gtk_entry_set_text(GTK_ENTRY(r_ss_text), temp);
	snprintf(temp, LEN_TEMP, "%.4X  %s", cpu.ds.segment, (cpu.ds.valid ? "valid" : "invalid"));
	gtk_entry_set_text(GTK_ENTRY(r_ds_text), temp);
	snprintf(temp, LEN_TEMP, "%.4X  %s", cpu.es.segment, (cpu.es.valid ? "valid" : "invalid"));
	gtk_entry_set_text(GTK_ENTRY(r_es_text), temp);
	snprintf(temp, LEN_TEMP, "%.4X  %s", cpu.fs.segment, (cpu.fs.valid ? "valid" : "invalid"));
	gtk_entry_set_text(GTK_ENTRY(r_fs_text), temp);
	snprintf(temp, LEN_TEMP, "%.4X  %s", cpu.gs.segment, (cpu.gs.valid ? "valid" : "invalid"));
	gtk_entry_set_text(GTK_ENTRY(r_gs_text), temp);

	snprintf(temp, LEN_TEMP, "%.4X  %s", cpu.tr.segment, (cpu.tr.valid ? "valid" : "invalid"));
	gtk_entry_set_text(GTK_ENTRY(r_tr_text), temp);
	snprintf(temp, LEN_TEMP, "%.4X  %s", cpu.ldtr.segment, (cpu.ldtr.valid ? "valid" : "invalid"));
	gtk_entry_set_text(GTK_ENTRY(r_ldtr_text), temp);

	snprintf(temp, LEN_TEMP, "%.8X  (%.5X)", cpu.gdtr.base, cpu.gdtr.limit);
	gtk_entry_set_text(GTK_ENTRY(r_gdtr_text), temp);
	snprintf(temp, LEN_TEMP, "%.8X  (%.5X)", cpu.idtr.base, cpu.idtr.limit);
	gtk_entry_set_text(GTK_ENTRY(r_idtr_text), temp);

	snprintf(temp, LEN_TEMP, "%.8X", cpu.dr0);
	gtk_entry_set_text(GTK_ENTRY(r_dr0_text), temp);
	snprintf(temp, LEN_TEMP, "%.8X", cpu.dr1);
	gtk_entry_set_text(GTK_ENTRY(r_dr1_text), temp);
	snprintf(temp, LEN_TEMP, "%.8X", cpu.dr2);
	gtk_entry_set_text(GTK_ENTRY(r_dr2_text), temp);
	snprintf(temp, LEN_TEMP, "%.8X", cpu.dr3);
	gtk_entry_set_text(GTK_ENTRY(r_dr3_text), temp);
//	snprintf(temp, LEN_TEMP, "%.8X", cpu.dr4);
//	gtk_entry_set_text(GTK_ENTRY(r_dr4_text), temp);
//	snprintf(temp, LEN_TEMP, "%.8X", cpu.dr5);
//	gtk_entry_set_text(GTK_ENTRY(r_dr5_text), temp);
	snprintf(temp, LEN_TEMP, "%.8X", cpu.dr6);
	gtk_entry_set_text(GTK_ENTRY(r_dr6_text), temp);
	snprintf(temp, LEN_TEMP, "%.8X", cpu.dr7);
	gtk_entry_set_text(GTK_ENTRY(r_dr7_text), temp);

	snprintf(temp, LEN_TEMP, "%.8X", cpu.tr3);
	gtk_entry_set_text(GTK_ENTRY(r_tr3_text), temp);
	snprintf(temp, LEN_TEMP, "%.8X", cpu.tr4);
	gtk_entry_set_text(GTK_ENTRY(r_tr4_text), temp);
	snprintf(temp, LEN_TEMP, "%.8X", cpu.tr5);
	gtk_entry_set_text(GTK_ENTRY(r_tr5_text), temp);
	snprintf(temp, LEN_TEMP, "%.8X", cpu.tr6);
	gtk_entry_set_text(GTK_ENTRY(r_tr6_text), temp);
	snprintf(temp, LEN_TEMP, "%.8X", cpu.tr7);
	gtk_entry_set_text(GTK_ENTRY(r_tr7_text), temp);

	snprintf(temp, LEN_TEMP, "%.8X", cpu.cr0);
	gtk_entry_set_text(GTK_ENTRY(r_cr0_text), temp);
	snprintf(temp, LEN_TEMP, "%.8X", cpu.cr1);
	gtk_entry_set_text(GTK_ENTRY(r_cr1_text), temp);
	snprintf(temp, LEN_TEMP, "%.8X", cpu.cr2);
	gtk_entry_set_text(GTK_ENTRY(r_cr2_text), temp);
	snprintf(temp, LEN_TEMP, "%.8X", cpu.cr3);
	gtk_entry_set_text(GTK_ENTRY(r_cr3_text), temp);
	snprintf(temp, LEN_TEMP, "%.8X", cpu.cr4);
	gtk_entry_set_text(GTK_ENTRY(r_cr4_text), temp);

	gtk_clist_freeze(eflags_list);
	gtk_clist_clear(eflags_list);
	add_flag(cpu.eflags&1, "Carry");
	add_flag((cpu.eflags&2)>>1, "-");			// 1
	add_flag((cpu.eflags&4)>>2, "Parity");
	add_flag((cpu.eflags&8)>>3, "-");			// 0
	add_flag((cpu.eflags&16)>>4, "Auxillary");
	add_flag((cpu.eflags&32)>>5, "-");			// 0
	add_flag((cpu.eflags&64)>>6, "Zero");
	add_flag((cpu.eflags&128)>>7, "Sign");
	add_flag((cpu.eflags&256)>>8, "Trap");
	add_flag((cpu.eflags&512)>>9, "Interrupt");
	add_flag((cpu.eflags&1024)>>10, "Direction");
	add_flag((cpu.eflags&2048)>>11, "Overflow");
	add_flag((cpu.eflags&12288)>>12, "IOPL");
	add_flag((cpu.eflags&16384)>>14, "Nested Task");
	add_flag((cpu.eflags&32768)>>15, "-");			// 0
	add_flag((cpu.eflags&65535)>>16, "Resume");
	add_flag((cpu.eflags&131072)>>17, "V86");
	add_flag((cpu.eflags&262144)>>18, "Alignment Check");
	add_flag((cpu.eflags&524288)>>19, "Virtual Interrupt");
	add_flag((cpu.eflags&1048576)>>20, "Virtual Interrupt Pending");
	add_flag((cpu.eflags&2097152)>>21, "ID");
	gtk_clist_thaw(eflags_list);

	stateUpdateStack();
}


void stateUpdateStack( ){
	char esp_offset[LEN_NUMBER], value[LEN_NUMBER], ebp_offset[LEN_NUMBER], *row[STACK_COLUMN_TITLES];
	uint stack_size, shift, length, tos;
	uint32 stack_bottom, stack_base, stack_value, ptr;
	int ptr_sign;

	if(!cpu.ss.valid || bochs_offline || bochs_running) return;

	if((cpu.cr0 & 1) && (cpu.ss.descriptor[1] & 0x400000)){		// check for a 32bit stack
		stack_size = 4;
		shift = 2;
		if(!virtual_to_physical(&cpu.ss, 0, &stack_base)){
			g_print("BFE: failed to calculate stack base, stack not updated.\n");
			return;
		}
		gtk_label_set_text(GTK_LABEL(stack_label), "32bit Stack");
	} else {
		stack_size = 2;
		shift = 1;
		stack_base = cpu.ss.segment<<4;
		gtk_label_set_text(GTK_LABEL(stack_label), "16bit Stack");
	}
	stack_bottom = (stack_below << shift) >= cpu.esp ? 0 : cpu.esp - (stack_below << shift);
	
	row[0] = esp_offset;
	row[1] = value;
	row[2] = ebp_offset;
	length = 0;
	tos = -1;

	gtk_clist_freeze(stack_list);
	gtk_clist_clear(stack_list);

	ptr = cpu.esp + (stack_above << shift);
	ptr_sign = ptr < (uint)4 ? 1 : -1;
	for(; ptr >= stack_bottom; ptr -= stack_size){
		if(ptr_sign > 0 && (int)ptr < 0) break;
		if(stack_size == 2){
			fprintf(writepipe, "x /1hx 0x%X\n", stack_base + ptr);
		} else {
			fprintf(writepipe, "x /1wx 0x%X\n", stack_base + ptr);
		}
		if(fscanf(readpipe, "%*s %*s 0x%x", &stack_value) == 1){
			if(ptr == cpu.esp){
				snprintf(esp_offset, LEN_NUMBER, "TOS");
				tos = length;
			} else {
				snprintf(esp_offset, LEN_NUMBER, "%+d", (int)(ptr - cpu.esp));
			}
			snprintf(ebp_offset, LEN_NUMBER, "%+d", (int)(ptr - cpu.ebp));
			if(stack_size == 2) snprintf(value, LEN_NUMBER, "%.4X", stack_value);
			else snprintf(value, LEN_NUMBER, "%.8X", stack_value);

			if(((stack_size == 2) && !(ptr >= 0x10000)) || (stack_size == 4)){
				gtk_clist_append(stack_list, row);
				length++;
			}
		}
		prompt_read();
		if(ptr == 0) break;
	}
	gtk_clist_thaw(stack_list);
	if(tos != -1){
		gtk_clist_moveto(stack_list, tos, 0, 0.5, 0.0);
		gtk_clist_select_row(stack_list, tos, 0);
	}
}