tb.c

skyeye 仿真软件

				dp_head_len = dp_head_imm_len;
			}
			else {
				dp_head_len = dp_head_reg_len;
			}
		}

		//op_setcpsr_nzc_len
		op_setcpsr_nzc_len += op_logic_T0_sn.len;
		//op_setcpsr_nzc_len += op_set_nf.len;
		op_setcpsr_nzc_len += op_logic_T0_sz.len;
		//op_setcpsr_nzc_len += op_set_zf.len;
		//op_setcpsr_nzc_len += op_set_cf.len;
		op_setcpsr_nzc_len += op_set_nzcf.len;

		//op_setcpsr_nzcv_len
		op_setcpsr_nzcv_len += op_logic_T0_sn.len;
		//op_setcpsr_nzcv_len += op_set_nf.len;
		op_setcpsr_nzcv_len += op_logic_T0_sz.len;
		//op_setcpsr_nzcv_len += op_set_zf.len;
		//op_setcpsr_nzcv_len += op_set_cf.len;
		//op_setcpsr_nzcv_len += op_set_vf.len;
		op_setcpsr_nzcv_len += op_set_nzcvf.len;

		//op_setcpsr_nzc_setreg
		op_setcpsr_nzc_notsetr15_len += op_setcpsr_nzc_len;
		op_setcpsr_nzc_notsetr15_len +=
			op_movl_reg_Tx_array_maxlen[0];
		op_setcpsr_nzc_setr15_len += op_movl_reg_Tx_array_maxlen[0];
		op_setcpsr_nzc_setr15_len +=
			op_movl_Tx_im[2].len + sizeof (ARMword) +
			op_movl_trap_T2.len;
		if (op_setcpsr_nzc_notsetr15_len > op_setcpsr_nzc_setr15_len) {
			op_setcpsr_nzc_setreg_len +=
				op_setcpsr_nzc_notsetr15_len;
		}
		else {
			op_setcpsr_nzc_setreg_len +=
				op_setcpsr_nzc_setr15_len;
		}

		//op_setcpsr_nzcv_setreg
		op_setcpsr_nzcv_notsetr15_len += op_setcpsr_nzcv_len;
		op_setcpsr_nzcv_notsetr15_len +=
			op_movl_reg_Tx_array_maxlen[0];
		op_setcpsr_nzcv_setr15_len += op_movl_reg_Tx_array_maxlen[0];
		op_setcpsr_nzcv_setr15_len +=
			op_movl_Tx_im[2].len + sizeof (ARMword) +
			op_movl_trap_T2.len;
		if (op_setcpsr_nzcv_notsetr15_len >
		    op_setcpsr_nzcv_setr15_len) {
			op_setcpsr_nzcv_setreg_len +=
				op_setcpsr_nzcv_notsetr15_len;
		}
		else {
			op_setcpsr_nzcv_setreg_len +=
				op_setcpsr_nzcv_setr15_len;
		}

		//mrs
		if (op_mrs_T0_spsr.len > op_mrs_T0_cpsr.len) {
			dp_len += op_mrs_T0_spsr.len;
		}
		else {
			dp_len += op_mrs_T0_cpsr.len;
		}
		dp_len += op_movl_reg_Tx_array_maxlen[0];
		TEA_OUT (printf
			 ("mrs insn's max len is %d\n",
			  dp_len + tb_insn_len_max));

//teawater add for xscale(arm v5) 2005.09.14------------------------------------]
		//clz
		dp_tmp1 = 0;
		dp_tmp1 += op_movl_Tx_reg_array_maxlen[1];
		dp_tmp1 += op_clzl_T0_T1.len;
		dp_tmp1 += op_movl_reg_Tx_array_maxlen[0];
		if (dp_tmp1 > dp_len) {
			dp_len = dp_tmp1;
		}
		TEA_OUT (printf
			 ("clz insn's max len is %d\n",
			  dp_tmp1 + tb_insn_len_max));
//AJ2D--------------------------------------------------------------------------

//teawater add for xscale(arm v5) 2005.09.26------------------------------------
		//qadd
		dp_tmp1 = 0;
		dp_tmp1 += op_movl_Tx_reg_array_maxlen[0];
		dp_tmp1 += op_movl_Tx_reg_array_maxlen[1];
		dp_tmp1 += op_qaddl_T0_T1_sq.len;
		dp_tmp1 += op_movl_reg_Tx_array_maxlen[0];
		dp_tmp1 += op_set_q.len;
		if (dp_tmp1 > dp_len) {
			dp_len = dp_tmp1;
		}
		TEA_OUT (printf
			 ("qadd insn's max len is %d\n",
			  dp_tmp1 + tb_insn_len_max));

		//qsub
		dp_tmp1 = 0;
		dp_tmp1 += op_movl_Tx_reg_array_maxlen[0];
		dp_tmp1 += op_movl_Tx_reg_array_maxlen[1];
		dp_tmp1 += op_qsubl_T0_T1_sq.len;
		dp_tmp1 += op_movl_reg_Tx_array_maxlen[0];
		dp_tmp1 += op_set_q.len;
		if (dp_tmp1 > dp_len) {
			dp_len = dp_tmp1;
		}
		TEA_OUT (printf
			 ("qsub insn's max len is %d\n",
			  dp_tmp1 + tb_insn_len_max));

		//qdadd
		dp_tmp1 = 0;
		dp_tmp1 += op_movl_Tx_reg_array_maxlen[0];
		dp_tmp1 += op_movl_Tx_reg_array_maxlen[1];
		dp_tmp1 += op_qaddl_T0_T1_sq.len;
		dp_tmp1 += op_movl_Tx_reg_array_maxlen[1];
		dp_tmp1 += op_qaddl_T0_T1_sq.len;
		dp_tmp1 += op_movl_reg_Tx_array_maxlen[0];
		dp_tmp1 += op_set_q.len;
		if (dp_tmp1 > dp_len) {
			dp_len = dp_tmp1;
		}
		TEA_OUT (printf
			 ("qdadd insn's max len is %d\n",
			  dp_tmp1 + tb_insn_len_max));

		//qdsub
		dp_tmp1 = 0;
		dp_tmp1 += op_movl_Tx_reg_array_maxlen[0];
		dp_tmp1 += op_movl_Tx_reg_array_maxlen[1];
		dp_tmp1 += op_qaddl_T0_T1_sq.len;
		dp_tmp1 += op_movl_T1_T0.len;
		dp_tmp1 += op_movl_Tx_reg_array_maxlen[0];
		dp_tmp1 += op_qsubl_T0_T1_sq.len;
		dp_tmp1 += op_movl_reg_Tx_array_maxlen[0];
		dp_tmp1 += op_set_q.len;
		if (dp_tmp1 > dp_len) {
			dp_len = dp_tmp1;
		}
		TEA_OUT (printf
			 ("qdsub insn's max len is %d\n",
			  dp_tmp1 + tb_insn_len_max));

		//sm_head
		sm_head = 0;
		sm_head += op_movl_Tx_reg_array_maxlen[0];
		sm_head += op_movl_Tx_reg_array_maxlen[1];
		if (op_hi_T0.len > op_lo_T0.len) {
			sm_head += op_hi_T0.len;
		}
		else {
			sm_head += op_lo_T0.len;
		}
		sm_head += op_signextend_halfword_T0.len;
		if (op_hi_T1.len > op_lo_T1.len) {
			sm_head += op_hi_T1.len;
		}
		else {
			sm_head += op_lo_T1.len;
		}
		sm_head += op_signextend_halfword_T1.len;

		//smlaxy
		dp_tmp1 = sm_head;
		dp_tmp1 += op_mul_T0_T1.len;
		dp_tmp1 += op_movl_Tx_reg_array_maxlen[1];
		dp_tmp1 += op_addl_T0_T1_sq.len;
		dp_tmp1 += op_movl_reg_Tx_array_maxlen[0];
		dp_tmp1 += op_set_q.len;
		if (dp_tmp1 > dp_len) {
			dp_len = dp_tmp1;
		}
		TEA_OUT (printf
			 ("smlaxy insn's max len is %d\n",
			  dp_tmp1 + tb_insn_len_max));

		//smulwy
		dp_tmp1 = sm_head;
		dp_tmp1 += op_smulwy_T0_T1.len;
		dp_tmp1 += op_movl_Tx_reg_array_maxlen[1];
		if (dp_tmp1 > dp_len) {
			dp_len = dp_tmp1;
		}
		TEA_OUT (printf
			 ("smulwy insn's max len is %d\n",
			  dp_tmp1 + tb_insn_len_max));

		//smlawy
		dp_tmp1 = sm_head;
		dp_tmp1 += op_smulwy_T0_T1.len;
		dp_tmp1 += op_movl_Tx_reg_array_maxlen[1];
		dp_tmp1 += op_addl_T0_T1_sq.len;
		dp_tmp1 += op_movl_reg_Tx_array_maxlen[0];
		dp_tmp1 += op_set_q.len;
		if (dp_tmp1 > dp_len) {
			dp_len = dp_tmp1;
		}
		TEA_OUT (printf
			 ("smlawy insn's max len is %d\n",
			  dp_tmp1 + tb_insn_len_max));

		//smlalxy
		dp_tmp1 = sm_head;
		dp_tmp1 += op_mul_T0_T1.len;
		dp_tmp1 += op_movl_Tx_reg_array_maxlen[1];
		dp_tmp1 += op_movl_Tx_reg_array_maxlen[2];
		dp_tmp1 += op_smlalxy_T2_T1_T0.len;
		dp_tmp1 += op_movl_reg_Tx_array_maxlen[1];
		dp_tmp1 += op_movl_reg_Tx_array_maxlen[2];
		if (dp_tmp1 > dp_len) {
			dp_len = dp_tmp1;
		}
		TEA_OUT (printf
			 ("smlalxy insn's max len is %d\n",
			  dp_tmp1 + tb_insn_len_max));

		//smulxy
		dp_tmp1 = sm_head;
		dp_tmp1 += op_mul_T0_T1.len;
		dp_tmp1 += op_movl_reg_Tx_array_maxlen[0];
		if (dp_tmp1 > dp_len) {
			dp_len = dp_tmp1;
		}
		TEA_OUT (printf
			 ("smulxy insn's max len is %d\n",
			  dp_tmp1 + tb_insn_len_max));
//AJ2D--------------------------------------------------------------------------

//teawater add check thumb 2005.07.21-------------------------------------------
		//bx or blx(2)
		dp_tmp1 += op_movl_Tx_reg_array_maxlen[1];
		if (op_bx_T1.len > op_blx_T1.len) {
			dp_tmp1 += op_bx_T1.len;
		}
		else {
			dp_tmp1 += op_blx_T1.len;
		}
		if (dp_tmp1 > dp_len) {
			dp_len = dp_tmp1;
		}
		TEA_OUT (printf
			 ("bx or blx(2) insn's max len is %d\n",
			  dp_tmp1 + tb_insn_len_max));
//AJ2D--------------------------------------------------------------------------

		//msr
		dp_tmp1 = 0;
		dp_tmp1 += dp_head_len;
		dp_tmp1 += op_movl_Tx_im[0].len + sizeof (ARMword);
		if (op_msr_spsr_T0_T1.len > op_msr_cpsr_T0_T1.len) {
			dp_tmp1 += op_msr_spsr_T0_T1.len;
		}
		else {
			dp_tmp1 += op_msr_spsr_T0_T1.len;
		}
		if (dp_tmp1 > dp_len) {
			dp_len = dp_tmp1;
		}
		TEA_OUT (printf
			 ("msr insn's max len is %d\n",
			  dp_tmp1 + tb_insn_len_max));

		//and
		dp_tmp1 = 0;
		dp_tmp1 += dp_head_len;
		dp_tmp1 += op_movl_Tx_reg_array_maxlen[0];
		dp_tmp1 += op_andl_T0_T1.len;
		dp_tmp1 += op_setcpsr_nzc_setreg_len;
		if (dp_tmp1 > dp_len) {
			dp_len = dp_tmp1;
		}
		TEA_OUT (printf
			 ("and insn's max len is %d\n",
			  dp_tmp1 + tb_insn_len_max));

		//eor
		dp_tmp1 = 0;
		dp_tmp1 += dp_head_len;
		dp_tmp1 += op_movl_Tx_reg_array_maxlen[0];
		dp_tmp1 += op_eorl_T0_T1.len;
		dp_tmp1 += op_setcpsr_nzc_setreg_len;
		if (dp_tmp1 > dp_len) {
			dp_len = dp_tmp1;
		}
		TEA_OUT (printf
			 ("eor insn's max len is %d\n",
			  dp_tmp1 + tb_insn_len_max));

		//sub
		dp_tmp1 = 0;
		dp_tmp1 += dp_head_len;
		dp_tmp1 += op_movl_Tx_reg_array_maxlen[0];
		if (op_subl_T0_T1_scv.len + op_setcpsr_nzcv_notsetr15_len >
		    op_subl_T0_T1.len + op_setcpsr_nzcv_setr15_len) {
			dp_tmp1 +=
				op_subl_T0_T1_scv.len +
				op_setcpsr_nzcv_notsetr15_len;
		}
		else {
			dp_tmp1 +=
				op_subl_T0_T1.len +
				op_setcpsr_nzcv_setr15_len;
		}
		if (dp_tmp1 > dp_len) {
			dp_len = dp_tmp1;
		}
		TEA_OUT (printf
			 ("sub insn's max len is %d\n",
			  dp_tmp1 + tb_insn_len_max));

		//rsb
		dp_tmp1 = 0;
		dp_tmp1 += dp_head_len;
		dp_tmp1 += op_movl_Tx_reg_array_maxlen[0];
		if (op_rsbl_T0_T1_scv.len + op_setcpsr_nzcv_notsetr15_len >
		    op_rsbl_T0_T1.len + op_setcpsr_nzcv_setr15_len) {
			dp_tmp1 +=
				op_rsbl_T0_T1_scv.len +
				op_setcpsr_nzcv_notsetr15_len;
		}
		else {
			dp_tmp1 +=
				op_rsbl_T0_T1.len +
				op_setcpsr_nzcv_setr15_len;
		}
		if (dp_tmp1 > dp_len) {
			dp_len = dp_tmp1;
		}
		TEA_OUT (printf
			 ("rsb insn's max len is %d\n",
			  dp_tmp1 + tb_insn_len_max));

		//add
		dp_tmp1 = 0;
		dp_tmp1 += dp_head_len;
		dp_tmp1 += op_movl_Tx_reg_array_maxlen[0];
		if (op_addl_T0_T1_scv.len + op_setcpsr_nzcv_notsetr15_len >
		    op_addl_T0_T1.len + op_setcpsr_nzcv_setr15_len) {
			dp_tmp1 +=
				op_addl_T0_T1_scv.len +
				op_setcpsr_nzcv_notsetr15_len;
		}
		else {
			dp_tmp1 +=
				op_addl_T0_T1.len +
				op_setcpsr_nzcv_setr15_len;
		}
		if (dp_tmp1 > dp_len) {
			dp_len = dp_tmp1;
		}
		TEA_OUT (printf
			 ("add insn's max len is %d\n",
			  dp_tmp1 + tb_insn_len_max));

		//adc
		dp_tmp1 = 0;
		dp_tmp1 += dp_head_len;
		dp_tmp1 += op_movl_Tx_reg_array_maxlen[0];
		if (op_adcl_T0_T1_scv.len + op_setcpsr_nzcv_notsetr15_len >
		    op_adcl_T0_T1.len + op_setcpsr_nzcv_setr15_len) {
			dp_tmp1 +=
				op_adcl_T0_T1_scv.len +
				op_setcpsr_nzcv_notsetr15_len;
		}
		else {
			dp_tmp1 +=
				op_adcl_T0_T1.len +
				op_setcpsr_nzcv_setr15_len;
		}
		if (dp_tmp1 > dp_len) {
			dp_len = dp_tmp1;
		}
		TEA_OUT (printf
			 ("adc insn's max len is %d\n",
			  dp_tmp1 + tb_insn_len_max));

		//sbc
		dp_tmp1 = 0;
		dp_tmp1 += dp_head_len;
		dp_tmp1 += op_movl_Tx_reg_array_maxlen[0];
		if (op_sbcl_T0_T1_scv.len + op_setcpsr_nzcv_notsetr15_len >
		    op_sbcl_T0_T1.len + op_setcpsr_nzcv_setr15_len) {
			dp_tmp1 +=
				op_sbcl_T0_T1_scv.len +
				op_setcpsr_nzcv_notsetr15_len;
		}
		else {
			dp_tmp1 +=
				op_sbcl_T0_T1.len +
				op_setcpsr_nzcv_setr15_len;
		}
		if (dp_tmp1 > dp_len) {
			dp_len = dp_tmp1;
		}
		TEA_OUT (printf
			 ("sbc insn's max len is %d\n",
			  dp_tmp1 + tb_insn_len_max));

		//rsc
		dp_tmp1 = 0;
		dp_tmp1 += dp_head_len;
		dp_tmp1 += op_movl_Tx_reg_array_maxlen[0];
		if (op_rscl_T0_T1_scv.len + op_setcpsr_nzcv_notsetr15_len >
		    op_rscl_T0_T1.len + op_setcpsr_nzcv_setr15_len) {
			dp_tmp1 +=
				op_rscl_T0_T1_scv.len +
				op_setcpsr_nzcv_notsetr15_len;
		}
		else {
			dp_tmp1 +=
				op_rscl_T0_T1.len +
				op_setcpsr_nzcv_setr15_len;
		}
		if (dp_tmp1 > dp_len) {
			dp_len = dp_tmp1;
		}
		TEA_OUT (printf
			 ("rsc insn's max len is %d\n",
			  dp_tmp1 + tb_insn_len_max));

		//tst
		dp_tmp1 = 0;
		dp_tmp1 += dp_head_len;
		dp_tmp1 += op_movl_Tx_reg_array_maxlen[0];
		dp_tmp1 += op_andl_T0_T1.len;
		dp_tmp1 += op_setcpsr_nzc_len;
		if (dp_tmp1 > dp_len) {
			dp_len = dp_tmp1;
		}
		TEA_OUT (printf
			 ("tst insn's max len is %d\n",
			  dp_tmp1 + tb_insn_len_max));

		//teq
		dp_tmp1 = 0;
		dp_tmp1 += dp_head_len;
		dp_tmp1 += op_movl_Tx_reg_array_maxlen[0];
		dp_tmp1 += op_eorl_T0_T1.len;
		dp_tmp1 += op_setcpsr_nzc_len;
		if (dp_tmp1 > dp_len) {
			dp_len = dp_tmp1;
		}
		TEA_OUT (printf
			 ("teq insn's max len is %d\n",
			  dp_tmp1 + tb_insn_len_max));

		//cmp
		dp_tmp1 = 0;
		dp_tmp1 += dp_head_len;
		dp_tmp1 += op_movl_Tx_reg_array_maxlen[0];
		dp_tmp1 += op_subl_T0_T1_scv.len;
		dp_tmp1 += op_setcpsr_nzcv_len;
		if (dp_tmp1 > dp_len) {
			dp_len = dp_tmp1;
		}
		TEA_OUT (printf
			 ("cmp insn's max len is %d\n",
			  dp_tmp1 + tb_insn_len_max));

		//cmn
		dp_tmp1 = 0;
		dp_tmp1 += dp_head_len;
		dp_tmp1 += op_movl_Tx_reg_array_maxlen[0];
		dp_tmp1 += op_addl_T0_T1_scv.len;
		dp_tmp1 += op_setcpsr_nzcv_len;
		if (dp_tmp1 > dp_len) {
			dp_len = dp_tmp1;
		}
		TEA_OUT (printf
			 ("cmn insn's max len is %d\n",
			  dp_tmp1 + tb_insn_len_max));

		//orr
		dp_tmp1 = 0;
		dp_tmp1 += dp_head_len;
		dp_tmp1 += op_movl_Tx_reg_array_maxlen[0];
		dp_tmp1 += op_orrl_T0_T1.len;
		dp_tmp1 += op_setcpsr_nzc_setreg_len;
		if (dp_tmp1 > dp_len) {
			dp_len = dp_tmp1;
		}
		TEA_OUT (printf
			 ("orr insn's max len is %d\n",
			  dp_tmp1 + tb_insn_len_max));

		//mov
		dp_tmp1 = 0;
		dp_tmp1 += dp_head_len;
		dp_tmp1 += op_movl_T0_T1.len;
		dp_tmp1 += op_setcpsr_nzc_setreg_len;
		if (dp_tmp1 > dp_len) {
			dp_len = dp_tmp1;
		}
		TEA_OUT (printf
			 ("mov insn's max len is %d\n",
			  dp_tmp1 + tb_insn_len_max));

		//bic
		dp_tmp1 = 0;
		dp_tmp1 += dp_head_len;
		dp_tmp1 += op_movl_Tx_reg_array_maxlen[0];
		dp_tmp1 += op_bicl_T0_T1.len;
		dp_tmp1 += op_setcpsr_nzc_setreg_len;
		if (dp_tmp1 > dp_len) {
			dp_len = dp_tmp1;
		}
		TEA_OUT (printf
			 ("bic insn's max len is %d\n",
			  dp_tmp1 + tb_insn_len_max));

		//mvn
		dp_tmp1 = 0;
		dp_tmp1 += dp_head_len;
		dp_tmp1 += op_notl_T0_T1.len;
		dp_tmp1 += op_setcpsr_nzc_setreg_len;
		if (dp_tmp1 > dp_len) {
			dp_len = dp_tmp1;
		}
		TEA_OUT (printf
			 ("mvn insn's max len is %d\n",
			  dp_tmp1 + tb_insn_len_max));
	}

	//other_len
	{
		int op_add_data_offset_len = 0, ldr_head_len =
			0, str_head_len = 0;
		int other_tmp1, other_tmp2;

		//op_add_data_offset_len
		op_add_data_offset_len += op_movl_Tx_reg_array_maxlen[2];
		op_add_data_offset_len += op_shift_T2_im_maxlen;
		op_add_data_offset_len += sizeof (uint8_t);
		if (op_subl_T1_T2.len > op_addl_T1_T2.len) {
			op_add_data_offset_len += op_subl_T1_T2.len;
		}
		else {
			op_add_data_offset_len += op_addl_T1_T2.len;
		}
		if (op_addl_T1_im.len + sizeof (ARMword) >
		    op_add_data_offset_len) {
			op_add_data_offset_len =
				op_addl_T1_im.len + sizeof (ARMword);
		}

		//ldr_head_len str_head_len
		ldr_head_len += op_movl_Tx_reg_array_maxlen[1];
		ldr_head_len += op_add_data_offset_len;
		ldr_head_len += op_movl_reg_Tx_array_maxlen[1];
		//if (!state->is_XScale) {
		if (state->abort_model > 1) {
			ldr_head_len += op_test_dataabort_ret.len;
		}
		str_head_len = ldr_head_len;
		ldr_head_len += op_movl_reg_Tx_array_maxlen[0];
		//if (!state->is_XScale) {
		if (state->abort_model > 1) {
			ldr_head_len += op_test_dataabort.len;