Context Navigation

Operation.cpp @ 116

Last change on this file since 116 was 116, checked in by moulu, 15 years ago
1) added a generic multiplier (systemC isn't working with 8bits) 2) added a partial functionnal unit vhdl.
Property svn:keywords set to `Id`
File size: 38.9 KB

Rev	Line
[72]	1	#ifdef SYSTEMC
	2	/*
	3	* $Id: Operation.cpp 116 2009-04-30 13:51:41Z moulu $
	4	*
	5	* [ Description ]
	6	*
	7	*/
	8
[78]	9	#include "Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Execute_unit/Execute_unit/Functionnal_unit/Operation/include/Operation.h"
[88]	10	#include "Behavioural/include/Operation.h"
[72]	11
	12	namespace morpheo {
	13	namespace behavioural {
	14	namespace core {
	15	namespace multi_execute_loop {
	16	namespace execute_loop {
	17	namespace multi_execute_unit {
	18	namespace execute_unit {
	19	namespace functionnal_unit {
	20
	21	#undef FUNCTION
	22	#define FUNCTION "Functionnal_unit::operation_unimplemented"
	23	void operation_unimplemented (execute_operation_t * op, execute_register_t * reg, execute_param_t * param)
	24	{
	25	log_printf(TRACE,Functionnal_unit,FUNCTION,"Operation : unimplemented");
	26
	27	throw ERRORMORPHEO(FUNCTION,"The operation '"+toString(op->_operation)+"' is not implemented in this Functionnal_unit");
	28	};
	29
	30	#undef FUNCTION
	31	#define FUNCTION "Functionnal_unit::operation_l_add"
	32	void operation_l_add (execute_operation_t * op, execute_register_t * reg, execute_param_t * param)
	33	{
	34	log_printf(TRACE,Functionnal_unit,FUNCTION,"Operation : l_add");
	35
[88]	36	Tgeneral_data_t gpr1 = unsigned(param->_size_data,op->_data_ra);
	37	Tgeneral_data_t gpr2 = unsigned(param->_size_data,(op->_has_immediat==1)?op->_immediat:op->_data_rb);
[72]	38
	39	Tgeneral_data_t gpr3 = param->_mask_data & (gpr1 + gpr2);
	40
[88]	41	bool overflow = ovf (param->_size_data,gpr1,gpr2,gpr3);
	42	bool carry_out = carry(param->_size_data,gpr1,gpr2,gpr3);
[72]	43
	44	// Result
[76]	45	op->_timing = param->_timing[op->_type][op->_operation];
[72]	46	op->_data_rd = gpr3;
	47	op->_data_re = 0;
	48	op->_data_re = set_flag(op->_data_re,FLAG_OV,overflow );
	49	op->_data_re = set_flag(op->_data_re,FLAG_CY,carry_out);
	50	op->_exception = (overflow==1)?EXCEPTION_ALU_RANGE:EXCEPTION_ALU_NONE;
	51	op->_no_sequence = 0;
[116]	52	#ifdef SYSTEMC_VHDL_COMPATIBILITY
	53	op->_address = 0;
	54	#else
[72]	55	//op->_address = 0;
[116]	56	#endif
[72]	57	};
	58
	59	#undef FUNCTION
	60	#define FUNCTION "Functionnal_unit::operation_l_addc"
	61	void operation_l_addc (execute_operation_t * op, execute_register_t * reg, execute_param_t * param)
	62	{
	63	log_printf(TRACE,Functionnal_unit,FUNCTION,"Operation : l_addc");
	64
	65	Tgeneral_data_t carry_in = get_flag(op->_data_rc,FLAG_CY);
	66
[88]	67	Tgeneral_data_t gpr1 = unsigned(param->_size_data,op->_data_ra);
	68	Tgeneral_data_t gpr2 = unsigned(param->_size_data,(op->_has_immediat==1)?op->_immediat:op->_data_rb);
[72]	69	Tgeneral_data_t gpr3 = param->_mask_data & (gpr1 + gpr2 + carry_in);
	70
[88]	71	bool overflow = ovf (param->_size_data,gpr1,gpr2,gpr3);
	72	bool carry_out = carry(param->_size_data,gpr1,gpr2,gpr3);
[72]	73
	74	// Result
[76]	75	op->_timing = param->_timing[op->_type][op->_operation];
[72]	76	op->_data_rd = gpr3;
	77	op->_data_re = 0;
	78	op->_data_re = set_flag(op->_data_re,FLAG_OV,overflow );
	79	op->_data_re = set_flag(op->_data_re,FLAG_CY,carry_out);
	80	op->_exception = (overflow==1)?EXCEPTION_ALU_RANGE:EXCEPTION_ALU_NONE;
	81	op->_no_sequence = 0;
[116]	82	#ifdef SYSTEMC_VHDL_COMPATIBILITY
	83	op->_address = 0;
	84	#else
[72]	85	//op->_address = 0;
[116]	86	#endif
[72]	87	};
	88
	89	#undef FUNCTION
	90	#define FUNCTION "Functionnal_unit::operation_l_sub"
	91	void operation_l_sub (execute_operation_t * op, execute_register_t * reg, execute_param_t * param)
	92	{
	93	log_printf(TRACE,Functionnal_unit,FUNCTION,"Operation : l_sub");
	94
[88]	95	Tgeneral_data_t gpr1 = unsigned(param->_size_data,op->_data_ra);
	96	Tgeneral_data_t gpr2 = neg(param->_size_data,unsigned(param->_size_data,op->_data_rb));
[72]	97	Tgeneral_data_t gpr3 = param->_mask_data & (gpr1 + gpr2);
	98
[88]	99	bool overflow = ovf (param->_size_data,gpr1,gpr2,gpr3);
[101]	100	// bool carry_out = carry(param->_size_data,gpr1,gpr2,gpr3);
	101	// In ISA : l.sub don't change flag carry
	102	bool carry_out = get_flag(op->_data_rc,FLAG_CY);
[72]	103
	104	// Result
[76]	105	op->_timing = param->_timing[op->_type][op->_operation];
[72]	106	op->_data_rd = gpr3;
	107	op->_data_re = 0;
	108	op->_data_re = set_flag(op->_data_re,FLAG_OV,overflow );
	109	op->_data_re = set_flag(op->_data_re,FLAG_CY,carry_out);
	110	op->_exception = (overflow==1)?EXCEPTION_ALU_RANGE:EXCEPTION_ALU_NONE;
	111	op->_no_sequence = 0;
[116]	112	#ifdef SYSTEMC_VHDL_COMPATIBILITY
	113	op->_address = 0;
	114	#else
[72]	115	//op->_address = 0;
[116]	116	#endif
[72]	117	};
	118
	119	#undef FUNCTION
[101]	120	#define FUNCTION "Functionnal_unit::operation_l_mul"
	121	void operation_l_mul (execute_operation_t * op, execute_register_t * reg, execute_param_t * param)
	122	{
	123	log_printf(TRACE,Functionnal_unit,FUNCTION,"Operation : l_mul");
	124
	125	Tgeneral_data_t gpr1 = unsigned(param->_size_data,op->_data_ra);
	126	Tgeneral_data_t gpr2 = unsigned(param->_size_data,(op->_has_immediat==1)?op->_immediat:op->_data_rb);
	127	Tgeneral_data_t gpr3 ;
	128	bool overflow ;
	129	bool carry_out ;
	130
	131	if (param->_size_data == 32)
	132	{
	133	int64_t res = static_cast<int64_t>(gpr1) * static_cast<int64_t>(gpr2);
	134
	135	log_printf(TRACE,Functionnal_unit,FUNCTION," * res : %llx",res);
	136
	137	gpr3 = param->_mask_data & static_cast<Tgeneral_data_t>(res);
	138	carry_out = res != gpr3;
	139	overflow = carry_out;
	140	}
	141	else
	142	{
	143	throw ERRORMORPHEO(FUNCTION,_("64 bits multiplcation : not yet implemented\n"));
	144	}
	145
	146	// Result
	147	op->_timing = param->_timing[op->_type][op->_operation];
	148	op->_data_rd = gpr3;
	149	op->_data_re = 0;
	150	op->_data_re = set_flag(op->_data_re,FLAG_OV,overflow );
	151	op->_data_re = set_flag(op->_data_re,FLAG_CY,carry_out);
	152	op->_exception = (overflow==1)?EXCEPTION_ALU_RANGE:EXCEPTION_ALU_NONE;
	153	op->_no_sequence = 0;
[116]	154	#ifdef SYSTEMC_VHDL_COMPATIBILITY
	155	op->_address = 0;
	156	#else
[101]	157	//op->_address = 0;
[116]	158	#endif
[101]	159	};
	160
	161	#undef FUNCTION
	162	#define FUNCTION "Functionnal_unit::operation_l_mulu"
	163	void operation_l_mulu (execute_operation_t * op, execute_register_t * reg, execute_param_t * param)
	164	{
	165	log_printf(TRACE,Functionnal_unit,FUNCTION,"Operation : l_mulu");
	166
	167	Tgeneral_data_t gpr1 = unsigned(param->_size_data,op->_data_ra);
	168	Tgeneral_data_t gpr2 = unsigned(param->_size_data,op->_data_rb);
	169	Tgeneral_data_t gpr3 ;
	170	bool overflow ;
	171	bool carry_out ;
	172
	173	if (param->_size_data == 32)
	174	{
	175	uint64_t res = static_cast<uint64_t>(gpr1) * static_cast<uint64_t>(gpr2);
	176
	177	log_printf(TRACE,Functionnal_unit,FUNCTION," * res : %llx",res);
	178
	179	gpr3 = param->_mask_data & static_cast<Tgeneral_data_t>(res);
	180	carry_out = res != gpr3;
	181	overflow = carry_out;
	182	}
	183	else
	184	{
	185	throw ERRORMORPHEO(FUNCTION,_("64 bits multiplcation : not yet implemented\n"));
	186	}
	187
	188	// Result
	189	op->_timing = param->_timing[op->_type][op->_operation];
	190	op->_data_rd = gpr3;
	191	op->_data_re = 0;
	192	op->_data_re = set_flag(op->_data_re,FLAG_OV,overflow );
	193	op->_data_re = set_flag(op->_data_re,FLAG_CY,carry_out);
	194	op->_exception = (overflow==1)?EXCEPTION_ALU_RANGE:EXCEPTION_ALU_NONE;
	195	op->_no_sequence = 0;
[116]	196	#ifdef SYSTEMC_VHDL_COMPATIBILITY
	197	op->_address = 0;
	198	#else
[101]	199	//op->_address = 0;
[116]	200	#endif
[101]	201	};
	202
	203	#undef FUNCTION
	204	#define FUNCTION "Functionnal_unit::operation_l_div"
	205	void operation_l_div (execute_operation_t * op, execute_register_t * reg, execute_param_t * param)
	206	{
	207	log_printf(TRACE,Functionnal_unit,FUNCTION,"Operation : l_div");
	208
	209	Tgeneral_data_t gpr1 = signed(param->_size_data,op->_data_ra);
	210	Tgeneral_data_t gpr2 = signed(param->_size_data,op->_data_rb);
	211	Tgeneral_data_t gpr3 = (gpr2!=0)?(gpr1/gpr2):0;
	212	bool overflow = ovf (param->_size_data,gpr1,gpr2,gpr3);
	213	bool carry_out = (gpr2==0);
	214
	215	// Result
	216	op->_timing = param->_timing[op->_type][op->_operation];
	217	op->_data_rd = gpr3;
	218	op->_data_re = 0;
	219	op->_data_re = set_flag(op->_data_re,FLAG_OV,overflow );
	220	op->_data_re = set_flag(op->_data_re,FLAG_CY,carry_out);
	221	op->_exception = (overflow==1)?EXCEPTION_ALU_RANGE:EXCEPTION_ALU_NONE;
	222	op->_no_sequence = 0;
[116]	223	#ifdef SYSTEMC_VHDL_COMPATIBILITY
	224	op->_address = 0;
	225	#else
[101]	226	//op->_address = 0;
[116]	227	#endif
[101]	228	};
	229
	230	#undef FUNCTION
	231	#define FUNCTION "Functionnal_unit::operation_l_divu"
	232	void operation_l_divu (execute_operation_t * op, execute_register_t * reg, execute_param_t * param)
	233	{
	234	log_printf(TRACE,Functionnal_unit,FUNCTION,"Operation : l_divu");
	235
	236	Tgeneral_data_t gpr1 = unsigned(param->_size_data,op->_data_ra);
	237	Tgeneral_data_t gpr2 = unsigned(param->_size_data,op->_data_rb);
	238	Tgeneral_data_t gpr3 = (gpr2!=0)?(gpr1/gpr2):0;
	239	bool overflow = ovf (param->_size_data,gpr1,gpr2,gpr3);
	240	bool carry_out = (gpr2==0);
	241
	242	// Result
	243	op->_timing = param->_timing[op->_type][op->_operation];
	244	op->_data_rd = gpr3;
	245	op->_data_re = 0;
	246	op->_data_re = set_flag(op->_data_re,FLAG_OV,overflow );
	247	op->_data_re = set_flag(op->_data_re,FLAG_CY,carry_out);
	248	op->_exception = (overflow==1)?EXCEPTION_ALU_RANGE:EXCEPTION_ALU_NONE;
	249	op->_no_sequence = 0;
[116]	250	#ifdef SYSTEMC_VHDL_COMPATIBILITY
	251	op->_address = 0;
	252	#else
[101]	253	//op->_address = 0;
[116]	254	#endif
[101]	255	};
	256
	257	#undef FUNCTION
[72]	258	#define FUNCTION "Functionnal_unit::operation_l_and"
	259	void operation_l_and (execute_operation_t * op, execute_register_t * reg, execute_param_t * param)
	260	{
	261	log_printf(TRACE,Functionnal_unit,FUNCTION,"Operation : l_and");
	262
[88]	263	Tgeneral_data_t gpr1 = unsigned(param->_size_data,op->_data_ra);
	264	Tgeneral_data_t gpr2 = unsigned(param->_size_data,(op->_has_immediat==1)?op->_immediat:op->_data_rb);
[72]	265	Tgeneral_data_t gpr3 = (gpr1 & gpr2);
	266
	267	// Result
[76]	268	op->_timing = param->_timing[op->_type][op->_operation];
[72]	269	op->_data_rd = gpr3;
	270	//op->_data_re = 0;
	271	op->_exception = EXCEPTION_ALU_NONE;
	272	op->_no_sequence = 0;
[116]	273	#ifdef SYSTEMC_VHDL_COMPATIBILITY
	274	op->_address = 0;
	275	#else
[72]	276	//op->_address = 0;
[116]	277	#endif
[72]	278	};
	279
	280	#undef FUNCTION
	281	#define FUNCTION "Functionnal_unit::operation_l_or"
	282	void operation_l_or (execute_operation_t * op, execute_register_t * reg, execute_param_t * param)
	283	{
	284	log_printf(TRACE,Functionnal_unit,FUNCTION,"Operation : l_or");
	285
[88]	286	Tgeneral_data_t gpr1 = unsigned(param->_size_data,op->_data_ra);
	287	Tgeneral_data_t gpr2 = unsigned(param->_size_data,(op->_has_immediat==1)?op->_immediat:op->_data_rb);
[72]	288	Tgeneral_data_t gpr3 = (gpr1 \| gpr2);
	289
	290	// Result
[76]	291	op->_timing = param->_timing[op->_type][op->_operation];
[72]	292	op->_data_rd = gpr3;
	293	//op->_data_re = 0;
	294	op->_exception = EXCEPTION_ALU_NONE;
	295	op->_no_sequence = 0;
[116]	296	#ifdef SYSTEMC_VHDL_COMPATIBILITY
	297	op->_address = 0;
	298	#else
[72]	299	//op->_address = 0;
[116]	300	#endif
[72]	301	};
	302
	303	#undef FUNCTION
	304	#define FUNCTION "Functionnal_unit::operation_l_xor"
	305	void operation_l_xor (execute_operation_t * op, execute_register_t * reg, execute_param_t * param)
	306	{
	307	log_printf(TRACE,Functionnal_unit,FUNCTION,"Operation : l_xor");
	308
[88]	309	Tgeneral_data_t gpr1 = unsigned(param->_size_data,op->_data_ra);
	310	Tgeneral_data_t gpr2 = unsigned(param->_size_data,(op->_has_immediat==1)?op->_immediat:op->_data_rb);
[72]	311	Tgeneral_data_t gpr3 = (gpr1 ^ gpr2);
	312
	313	// Result
[76]	314	op->_timing = param->_timing[op->_type][op->_operation];
[72]	315	op->_data_rd = gpr3;
	316	//op->_data_re = 0;
	317	op->_exception = EXCEPTION_ALU_NONE;
	318	op->_no_sequence = 0;
[116]	319	#ifdef SYSTEMC_VHDL_COMPATIBILITY
	320	op->_address = 0;
	321	#else
[72]	322	//op->_address = 0;
[116]	323	#endif
[72]	324	};
	325
	326	#undef FUNCTION
	327	#define FUNCTION "Functionnal_unit::operation_l_movhi"
	328	void operation_l_movhi (execute_operation_t * op, execute_register_t * reg, execute_param_t * param)
	329	{
	330	log_printf(TRACE,Functionnal_unit,FUNCTION,"Operation : l_movhi");
	331
[88]	332	Tgeneral_data_t gpr1 = unsigned(param->_size_data,op->_immediat);
[72]	333	Tgeneral_data_t gpr2 = param->_mask_data & (gpr1<<16);
	334
	335	// Result
[76]	336	op->_timing = param->_timing[op->_type][op->_operation];
[72]	337	op->_data_rd = gpr2;
	338	//op->_data_re = 0;
	339	op->_exception = EXCEPTION_ALU_NONE;
	340	op->_no_sequence = 0;
[116]	341	#ifdef SYSTEMC_VHDL_COMPATIBILITY
	342	op->_address = 0;
	343	#else
[72]	344	//op->_address = 0;
[116]	345	#endif
[72]	346	};
	347
	348	#undef FUNCTION
	349	#define FUNCTION "Functionnal_unit::operation_l_cmov"
	350	void operation_l_cmov (execute_operation_t * op, execute_register_t * reg, execute_param_t * param)
	351	{
	352	log_printf(TRACE,Functionnal_unit,FUNCTION,"Operation : l_cmov");
	353
	354	Tgeneral_data_t f_in = get_flag(op->_data_rc,FLAG_F);
	355
[88]	356	Tgeneral_data_t gpr1 = unsigned(param->_size_data,op->_data_ra);
	357	Tgeneral_data_t gpr2 = unsigned(param->_size_data,op->_data_rb);
[72]	358	Tgeneral_data_t gpr3 = ((f_in==0)?gpr2:gpr1);
	359
	360	// Result
[76]	361	op->_timing = param->_timing[op->_type][op->_operation];
[72]	362	op->_data_rd = gpr3;
	363	//op->_data_re = 0;
	364	op->_exception = EXCEPTION_ALU_NONE;
	365	op->_no_sequence = 0;
[116]	366	#ifdef SYSTEMC_VHDL_COMPATIBILITY
	367	op->_address = 0;
	368	#else
[72]	369	//op->_address = 0;
[116]	370	#endif
[72]	371	};
	372
	373	#undef FUNCTION
	374	#define FUNCTION "Functionnal_unit::operation_l_test_f"
	375	void operation_l_test_f (execute_operation_t * op, execute_register_t * reg, execute_param_t * param)
	376	{
	377	log_printf(TRACE,Functionnal_unit,FUNCTION,"Operation : l_test_f");
	378
	379	Tgeneral_data_t f_in = get_flag(op->_data_rc,FLAG_F);
[88]	380	Tgeneral_data_t imm = unsigned(param->_size_data,op->_immediat);
[72]	381
	382	// Result
[76]	383	op->_timing = param->_timing[op->_type][op->_operation];
[72]	384	//op->_data_rd = 0;
	385	//op->_data_re = 0;
	386	op->_exception = EXCEPTION_ALU_NONE;
	387	op->_no_sequence = f_in != 0;
	388	op->_address = imm;
	389	};
	390
	391	#undef FUNCTION
	392	#define FUNCTION "Functionnal_unit::operation_l_test_nf"
	393	void operation_l_test_nf (execute_operation_t * op, execute_register_t * reg, execute_param_t * param)
	394	{
	395	log_printf(TRACE,Functionnal_unit,FUNCTION,"Operation : l_test_nf");
	396
	397	Tgeneral_data_t f_in = get_flag(op->_data_rc,FLAG_F);
[88]	398	Tgeneral_data_t imm = unsigned(param->_size_data,op->_immediat);
[72]	399
[98]	400	log_printf(TRACE,Functionnal_unit,FUNCTION," * data_rc : %d",op->_data_rc);
	401	log_printf(TRACE,Functionnal_unit,FUNCTION," * f_in : %d",f_in);
	402
[72]	403	// Result
[76]	404	op->_timing = param->_timing[op->_type][op->_operation];
[72]	405	//op->_data_rd = 0;
	406	//op->_data_re = 0;
	407	op->_exception = EXCEPTION_ALU_NONE;
	408	op->_no_sequence = f_in == 0;
	409	op->_address = imm;
[98]	410
	411	log_printf(TRACE,Functionnal_unit,FUNCTION," * no_sequence : %d",op->_no_sequence);
[72]	412	};
	413
	414	#undef FUNCTION
	415	#define FUNCTION "Functionnal_unit::operation_l_jalr"
	416	void operation_l_jalr (execute_operation_t * op, execute_register_t * reg, execute_param_t * param)
	417	{
	418	log_printf(TRACE,Functionnal_unit,FUNCTION,"Operation : l_jalr");
	419	// jal : has_imm = 1, write_rd = 1, read_rb = 0
	420	// jalr : has_imm = 1, write_rd = 1, read_rb = 1
	421	// jr : has_imm = 0, write_rd = 0, read_rb = 1
	422
	423
[88]	424	Tgeneral_data_t gpr = unsigned(param->_size_data,op->_data_rb);
	425	Tgeneral_data_t imm = unsigned(param->_size_data,op->_immediat);
[72]	426
	427	// Result
[76]	428	op->_timing = param->_timing[op->_type][op->_operation];
[100]	429	op->_data_rd = imm<<2; // add "00"
[72]	430	//op->_data_re = 0;
	431	op->_exception = EXCEPTION_ALU_NONE;
	432	op->_no_sequence = 1;
[100]	433	op->_address = gpr>>2; // del "00"
[72]	434	};
	435
	436	#undef FUNCTION
	437	#define FUNCTION "Functionnal_unit::operation_l_extend_s"
	438	void operation_l_extend_s (execute_operation_t * op, execute_register_t * reg, execute_param_t * param)
	439	{
	440	log_printf(TRACE,Functionnal_unit,FUNCTION,"Operation : l_extend_s");
	441
[88]	442	Tgeneral_data_t imm = unsigned(param->_size_data,op->_immediat);
	443	Tgeneral_data_t gpr1 = unsigned(param->_size_data,op->_data_ra);
[72]	444	Tgeneral_data_t gpr2 = extend<Tgeneral_data_t>(param->_size_data, gpr1, true , imm);
	445
	446	// Result
[76]	447	op->_timing = param->_timing[op->_type][op->_operation];
[72]	448	op->_data_rd = gpr2;
	449	//op->_data_re = 0;
	450	op->_exception = EXCEPTION_ALU_NONE;
	451	op->_no_sequence = 0;
[116]	452	#ifdef SYSTEMC_VHDL_COMPATIBILITY
	453	op->_address = 0;
	454	#else
[72]	455	//op->_address = 0;
[116]	456	#endif
[72]	457	};
	458
	459	#undef FUNCTION
	460	#define FUNCTION "Functionnal_unit::operation_l_extend_z"
	461	void operation_l_extend_z (execute_operation_t * op, execute_register_t * reg, execute_param_t * param)
	462	{
	463	log_printf(TRACE,Functionnal_unit,FUNCTION,"Operation : l_extend_z");
	464
[88]	465	Tgeneral_data_t imm = unsigned(param->_size_data,op->_immediat);
	466	Tgeneral_data_t gpr1 = unsigned(param->_size_data,op->_data_ra);
[72]	467	Tgeneral_data_t gpr2 = extend<Tgeneral_data_t>(param->_size_data, gpr1, false , imm);
	468
	469	// Result
[76]	470	op->_timing = param->_timing[op->_type][op->_operation];
[72]	471	op->_data_rd = gpr2;
	472	//op->_data_re = 0;
	473	op->_exception = EXCEPTION_ALU_NONE;
	474	op->_no_sequence = 0;
[116]	475	#ifdef SYSTEMC_VHDL_COMPATIBILITY
	476	op->_address = 0;
	477	#else
[72]	478	//op->_address = 0;
[116]	479	#endif
[72]	480	};
	481
	482	#undef FUNCTION
	483	#define FUNCTION "Functionnal_unit::operation_l_sll"
	484	void operation_l_sll (execute_operation_t * op, execute_register_t * reg, execute_param_t * param)
	485	{
	486	log_printf(TRACE,Functionnal_unit,FUNCTION,"Operation : l_sll");
	487
[88]	488	Tgeneral_data_t gpr1 = unsigned(param->_size_data,op->_data_ra);
	489	Tgeneral_data_t gpr2 = param->_mask_shift & unsigned(param->_size_data,(op->_has_immediat==1)?op->_immediat:op->_data_rb);
[72]	490	Tgeneral_data_t gpr3 = shift_logic_left<Tgeneral_data_t>(param->_size_data, gpr1, gpr2);
	491
	492	// Result
[76]	493	op->_timing = param->_timing[op->_type][op->_operation];
[72]	494	op->_data_rd = gpr3;
	495	//op->_data_re = 0;
	496	op->_exception = EXCEPTION_ALU_NONE;
	497	op->_no_sequence = 0;
[116]	498	#ifdef SYSTEMC_VHDL_COMPATIBILITY
	499	op->_address = 0;
	500	#else
[72]	501	//op->_address = 0;
[116]	502	#endif
[72]	503	};
	504
	505	#undef FUNCTION
	506	#define FUNCTION "Functionnal_unit::operation_l_srl"
	507	void operation_l_srl (execute_operation_t * op, execute_register_t * reg, execute_param_t * param)
	508	{
	509	log_printf(TRACE,Functionnal_unit,FUNCTION,"Operation : l_srl");
	510
[88]	511	Tgeneral_data_t gpr1 = unsigned(param->_size_data,op->_data_ra);
	512	Tgeneral_data_t gpr2 = param->_mask_shift & unsigned(param->_size_data,(op->_has_immediat==1)?op->_immediat:op->_data_rb);
[72]	513	Tgeneral_data_t gpr3 = shift_logic_right<Tgeneral_data_t>(param->_size_data, gpr1, gpr2);
	514
	515	// Result
[76]	516	op->_timing = param->_timing[op->_type][op->_operation];
[72]	517	op->_data_rd = gpr3;
	518	//op->_data_re = 0;
	519	op->_exception = EXCEPTION_ALU_NONE;
	520	op->_no_sequence = 0;
[116]	521	#ifdef SYSTEMC_VHDL_COMPATIBILITY
	522	op->_address = 0;
	523	#else
[72]	524	//op->_address = 0;
[116]	525	#endif
[72]	526	};
	527
	528	#undef FUNCTION
	529	#define FUNCTION "Functionnal_unit::operation_l_sra"
	530	void operation_l_sra (execute_operation_t * op, execute_register_t * reg, execute_param_t * param)
	531	{
	532	log_printf(TRACE,Functionnal_unit,FUNCTION,"Operation : l_sra");
	533
[88]	534	Tgeneral_data_t gpr1 = unsigned(param->_size_data,op->_data_ra);
	535	Tgeneral_data_t gpr2 = param->_mask_shift & unsigned(param->_size_data,(op->_has_immediat==1)?op->_immediat:op->_data_rb);
[72]	536	Tgeneral_data_t gpr3 = shift_arithmetic_right<Tgeneral_data_t>(param->_size_data, gpr1, gpr2);
	537
	538	// Result
[76]	539	op->_timing = param->_timing[op->_type][op->_operation];
[72]	540	op->_data_rd = gpr3;
	541	//op->_data_re = 0;
	542	op->_exception = EXCEPTION_ALU_NONE;
	543	op->_no_sequence = 0;
[116]	544	#ifdef SYSTEMC_VHDL_COMPATIBILITY
	545	op->_address = 0;
	546	#else
[72]	547	//op->_address = 0;
[116]	548	#endif
[72]	549	};
	550
	551	#undef FUNCTION
	552	#define FUNCTION "Functionnal_unit::operation_l_ror"
	553	void operation_l_ror (execute_operation_t * op, execute_register_t * reg, execute_param_t * param)
	554	{
	555	log_printf(TRACE,Functionnal_unit,FUNCTION,"Operation : l_ror");
	556
[88]	557	Tgeneral_data_t gpr1 = unsigned(param->_size_data,op->_data_ra);
	558	Tgeneral_data_t gpr2 = param->_mask_shift & unsigned(param->_size_data,(op->_has_immediat==1)?op->_immediat:op->_data_rb);
[72]	559	Tgeneral_data_t gpr3 = rotate_right<Tgeneral_data_t>(param->_size_data, gpr1, gpr2);
	560
	561	// Result
[76]	562	op->_timing = param->_timing[op->_type][op->_operation];
[72]	563	op->_data_rd = gpr3;
	564	//op->_data_re = 0;
	565	op->_exception = EXCEPTION_ALU_NONE;
	566	op->_no_sequence = 0;
[116]	567	#ifdef SYSTEMC_VHDL_COMPATIBILITY
	568	op->_address = 0;
	569	#else
[72]	570	//op->_address = 0;
[116]	571	#endif
[72]	572	};
	573
	574	#undef FUNCTION
	575	#define FUNCTION "Functionnal_unit::operation_l_ff1"
	576	void operation_l_ff1 (execute_operation_t * op, execute_register_t * reg, execute_param_t * param)
	577	{
	578	log_printf(TRACE,Functionnal_unit,FUNCTION,"Operation : l_ff1");
	579
[88]	580	Tgeneral_data_t gpr = unsigned(param->_size_data,op->_data_ra);
[72]	581	Tgeneral_data_t index;
	582
	583	for (index=0; (index<param->_size_data) and (((gpr>>index)&1)!= 1); index++);
	584
	585	// Result
[76]	586	op->_timing = param->_timing[op->_type][op->_operation];
[72]	587	op->_data_rd = (index==param->_size_data)?0:(index+1);
	588	//op->_data_re = 0;
	589	op->_exception = EXCEPTION_ALU_NONE;
	590	op->_no_sequence = 0;
[116]	591	#ifdef SYSTEMC_VHDL_COMPATIBILITY
	592	op->_address = 0;
	593	#else
[72]	594	//op->_address = 0;
[116]	595	#endif
[72]	596	};
	597
	598	#undef FUNCTION
	599	#define FUNCTION "Functionnal_unit::operation_l_fl1"
	600	void operation_l_fl1 (execute_operation_t * op, execute_register_t * reg, execute_param_t * param)
	601	{
	602	log_printf(TRACE,Functionnal_unit,FUNCTION,"Operation : l_fl1");
	603
[88]	604	Tgeneral_data_t gpr = unsigned(param->_size_data,op->_data_ra);
[72]	605	Tgeneral_data_t index;
	606
	607	for (index=param->_size_data; (index>0) and (((gpr>>(index-1))&1)!= 1); index--);
	608
	609	// Result
[76]	610	op->_timing = param->_timing[op->_type][op->_operation];
[72]	611	op->_data_rd = index;
	612	//op->_data_re = 0;
	613	op->_exception = EXCEPTION_ALU_NONE;
	614	op->_no_sequence = 0;
[116]	615	#ifdef SYSTEMC_VHDL_COMPATIBILITY
	616	op->_address = 0;
	617	#else
[72]	618	//op->_address = 0;
[116]	619	#endif
[72]	620	};
	621
	622	#undef FUNCTION
	623	#define FUNCTION "Functionnal_unit::operation_l_sfeq"
	624	void operation_l_sfeq (execute_operation_t * op, execute_register_t * reg, execute_param_t * param)
	625	{
	626	log_printf(TRACE,Functionnal_unit,FUNCTION,"Operation : l_sfeq");
	627
[88]	628	Tgeneral_data_t gpr1 = unsigned(param->_size_data,op->_data_ra);
	629	Tgeneral_data_t gpr2 = unsigned(param->_size_data,(op->_has_immediat==1)?op->_immediat:op->_data_rb);
[72]	630
	631	bool f_out = (gpr1 == gpr2);
	632
	633	// Result
[76]	634	op->_timing = param->_timing[op->_type][op->_operation];
[72]	635	//op->_data_rd = 0;
	636	op->_data_re = set_flag(op->_data_re,FLAG_F,f_out);
	637	op->_exception = EXCEPTION_ALU_NONE;
	638	op->_no_sequence = 0;
[116]	639	#ifdef SYSTEMC_VHDL_COMPATIBILITY
	640	op->_address = 0;
	641	#else
[72]	642	//op->_address = 0;
[116]	643	#endif
[72]	644	};
	645
	646	#undef FUNCTION
	647	#define FUNCTION "Functionnal_unit::operation_l_sfne"
	648	void operation_l_sfne (execute_operation_t * op, execute_register_t * reg, execute_param_t * param)
	649	{
	650	log_printf(TRACE,Functionnal_unit,FUNCTION,"Operation : l_sfne");
	651
[88]	652	Tgeneral_data_t gpr1 = unsigned(param->_size_data,op->_data_ra);
	653	Tgeneral_data_t gpr2 = unsigned(param->_size_data,(op->_has_immediat==1)?op->_immediat:op->_data_rb);
[72]	654
	655	bool f_out = (gpr1 != gpr2);
	656
	657	// Result
[76]	658	op->_timing = param->_timing[op->_type][op->_operation];
[72]	659	//op->_data_rd = 0;
	660	op->_data_re = set_flag(op->_data_re,FLAG_F,f_out);
	661	op->_exception = EXCEPTION_ALU_NONE;
	662	op->_no_sequence = 0;
[116]	663	#ifdef SYSTEMC_VHDL_COMPATIBILITY
	664	op->_address = 0;
	665	#else
[72]	666	//op->_address = 0;
[116]	667	#endif
[72]	668	};
	669
	670	#undef FUNCTION
	671	#define FUNCTION "Functionnal_unit::operation_l_sfgeu"
	672	void operation_l_sfgeu (execute_operation_t * op, execute_register_t * reg, execute_param_t * param)
	673	{
	674	log_printf(TRACE,Functionnal_unit,FUNCTION,"Operation : l_sfgeu");
	675
[88]	676	Tgeneral_data_t gpr1 = unsigned(param->_size_data,op->_data_ra);
	677	Tgeneral_data_t gpr2 = unsigned(param->_size_data,(op->_has_immediat==1)?op->_immediat:op->_data_rb);
[72]	678
[101]	679	// Tgeneral_data_t is unsigned
[72]	680	bool f_out = (gpr1 >= gpr2);
	681
	682	// Result
[76]	683	op->_timing = param->_timing[op->_type][op->_operation];
[72]	684	//op->_data_rd = 0;
	685	op->_data_re = set_flag(op->_data_re,FLAG_F,f_out);
	686	op->_exception = EXCEPTION_ALU_NONE;
	687	op->_no_sequence = 0;
[116]	688	#ifdef SYSTEMC_VHDL_COMPATIBILITY
	689	op->_address = 0;
	690	#else
[72]	691	//op->_address = 0;
[116]	692	#endif
[72]	693	};
	694
	695	#undef FUNCTION
	696	#define FUNCTION "Functionnal_unit::operation_l_sfgtu"
	697	void operation_l_sfgtu (execute_operation_t * op, execute_register_t * reg, execute_param_t * param)
	698	{
	699	log_printf(TRACE,Functionnal_unit,FUNCTION,"Operation : l_sfgtu");
	700
[88]	701	Tgeneral_data_t gpr1 = unsigned(param->_size_data,op->_data_ra);
	702	Tgeneral_data_t gpr2 = unsigned(param->_size_data,(op->_has_immediat==1)?op->_immediat:op->_data_rb);
[72]	703
[101]	704	// Tgeneral_data_t is unsigned
[72]	705	bool f_out = (gpr1 > gpr2);
	706
	707	// Result
[76]	708	op->_timing = param->_timing[op->_type][op->_operation];
[72]	709	//op->_data_rd = 0;
	710	op->_data_re = set_flag(op->_data_re,FLAG_F,f_out);
	711	op->_exception = EXCEPTION_ALU_NONE;
	712	op->_no_sequence = 0;
[116]	713	#ifdef SYSTEMC_VHDL_COMPATIBILITY
	714	op->_address = 0;
	715	#else
[72]	716	//op->_address = 0;
[116]	717	#endif
[72]	718	};
	719
	720	#undef FUNCTION
	721	#define FUNCTION "Functionnal_unit::operation_l_sfleu"
	722	void operation_l_sfleu (execute_operation_t * op, execute_register_t * reg, execute_param_t * param)
	723	{
	724	log_printf(TRACE,Functionnal_unit,FUNCTION,"Operation : l_sfleu");
	725
[88]	726	Tgeneral_data_t gpr1 = unsigned(param->_size_data,op->_data_ra);
	727	Tgeneral_data_t gpr2 = unsigned(param->_size_data,(op->_has_immediat==1)?op->_immediat:op->_data_rb);
[72]	728
[101]	729	// Tgeneral_data_t is unsigned
[72]	730	bool f_out = (gpr1 <= gpr2);
	731
	732	// Result
[76]	733	op->_timing = param->_timing[op->_type][op->_operation];
[72]	734	//op->_data_rd = 0;
	735	op->_data_re = set_flag(op->_data_re,FLAG_F,f_out);
	736	op->_exception = EXCEPTION_ALU_NONE;
	737	op->_no_sequence = 0;
[116]	738	#ifdef SYSTEMC_VHDL_COMPATIBILITY
	739	op->_address = 0;
	740	#else
[72]	741	//op->_address = 0;
[116]	742	#endif
[72]	743	};
	744
	745	#undef FUNCTION
	746	#define FUNCTION "Functionnal_unit::operation_l_sfltu"
	747	void operation_l_sfltu (execute_operation_t * op, execute_register_t * reg, execute_param_t * param)
	748	{
	749	log_printf(TRACE,Functionnal_unit,FUNCTION,"Operation : l_sfltu");
	750
[88]	751	Tgeneral_data_t gpr1 = unsigned(param->_size_data,op->_data_ra);
	752	Tgeneral_data_t gpr2 = unsigned(param->_size_data,(op->_has_immediat==1)?op->_immediat:op->_data_rb);
[72]	753
[101]	754	// Tgeneral_data_t is unsigned
[72]	755	bool f_out = (gpr1 < gpr2);
	756
	757	// Result
[76]	758	op->_timing = param->_timing[op->_type][op->_operation];
[72]	759	//op->_data_rd = 0;
	760	op->_data_re = set_flag(op->_data_re,FLAG_F,f_out);
	761	op->_exception = EXCEPTION_ALU_NONE;
	762	op->_no_sequence = 0;
[116]	763	#ifdef SYSTEMC_VHDL_COMPATIBILITY
	764	op->_address = 0;
	765	#else
[72]	766	//op->_address = 0;
[116]	767	#endif
[72]	768	};
	769
	770	#undef FUNCTION
	771	#define FUNCTION "Functionnal_unit::operation_l_sfges"
	772	void operation_l_sfges (execute_operation_t * op, execute_register_t * reg, execute_param_t * param)
	773	{
	774	log_printf(TRACE,Functionnal_unit,FUNCTION,"Operation : l_sfges");
	775
	776	Tgeneral_data_t gpr1 = op->_data_ra;
	777	Tgeneral_data_t gpr2 = (op->_has_immediat==1)?op->_immediat:op->_data_rb;
[101]	778
[72]	779	bool f_out;
	780
[101]	781	if (param->_size_data == 32)
	782	f_out = static_cast<int32_t>(gpr1) >= static_cast<int32_t>(gpr2);
	783	else
	784	f_out = static_cast<int64_t>(gpr1) >= static_cast<int64_t>(gpr2);
[72]	785
[101]	786	// switch (concatenation_bool(sign(param->_size_data,gpr1),sign(param->_size_data,gpr2)))
	787	// {
	788	// case 1 /b01/ : f_out = 1 ; break;
	789	// case 2 /b10/ : f_out = 0 ; break;
	790	// default : f_out = signed(param->_size_data,gpr1) >= signed(param->_size_data,gpr2); break;
	791	// }
[72]	792
	793	// Result
[76]	794	op->_timing = param->_timing[op->_type][op->_operation];
[72]	795	//op->_data_rd = 0;
	796	op->_data_re = set_flag(op->_data_re,FLAG_F,f_out);
	797	op->_exception = EXCEPTION_ALU_NONE;
	798	op->_no_sequence = 0;
[116]	799	#ifdef SYSTEMC_VHDL_COMPATIBILITY
	800	op->_address = 0;
	801	#else
[72]	802	//op->_address = 0;
[116]	803	#endif
[72]	804	};
	805
	806	#undef FUNCTION
	807	#define FUNCTION "Functionnal_unit::operation_l_sfgts"
	808	void operation_l_sfgts (execute_operation_t * op, execute_register_t * reg, execute_param_t * param)
	809	{
	810	log_printf(TRACE,Functionnal_unit,FUNCTION,"Operation : l_sfgts");
	811
	812	Tgeneral_data_t gpr1 = op->_data_ra ;
	813	Tgeneral_data_t gpr2 = (op->_has_immediat==1)?op->_immediat:op->_data_rb ;
	814
	815	bool f_out;
	816
[101]	817	if (param->_size_data == 32)
	818	f_out = static_cast<int32_t>(gpr1) > static_cast<int32_t>(gpr2);
	819	else
	820	f_out = static_cast<int64_t>(gpr1) > static_cast<int64_t>(gpr2);
[72]	821
[101]	822	// switch (concatenation_bool(sign(param->_size_data,gpr1),sign(param->_size_data,gpr2)))
	823	// {
	824	// case 1 /b01/ : f_out = 1; break;
	825	// case 2 /b10/ : f_out = 0; break;
	826	// default : f_out = signed(param->_size_data,gpr1) > signed(param->_size_data,gpr2); break;
	827	// }
	828
[72]	829	// Result
[76]	830	op->_timing = param->_timing[op->_type][op->_operation];
[72]	831	//op->_data_rd = 0;
	832	op->_data_re = set_flag(op->_data_re,FLAG_F,f_out);
	833	op->_exception = EXCEPTION_ALU_NONE;
	834	op->_no_sequence = 0;
[116]	835	#ifdef SYSTEMC_VHDL_COMPATIBILITY
	836	op->_address = 0;
	837	#else
[72]	838	//op->_address = 0;
[116]	839	#endif
[72]	840	};
	841
	842	#undef FUNCTION
	843	#define FUNCTION "Functionnal_unit::operation_l_sfles"
	844	void operation_l_sfles (execute_operation_t * op, execute_register_t * reg, execute_param_t * param)
	845	{
	846	log_printf(TRACE,Functionnal_unit,FUNCTION,"Operation : l_sfles");
	847
	848	Tgeneral_data_t gpr1 = op->_data_ra ;
	849	Tgeneral_data_t gpr2 = (op->_has_immediat==1)?op->_immediat:op->_data_rb ;
	850
	851	bool f_out;
	852
[101]	853	if (param->_size_data == 32)
	854	f_out = static_cast<int32_t>(gpr1) <= static_cast<int32_t>(gpr2);
	855	else
	856	f_out = static_cast<int64_t>(gpr1) <= static_cast<int64_t>(gpr2);
	857
	858	// switch (concatenation_bool(sign(param->_size_data,gpr1),sign(param->_size_data,gpr2)))
	859	// {
	860	// case 1 /b01/ : f_out = 0; break;
	861	// case 2 /b10/ : f_out = 1; break;
	862	// default : f_out = signed(param->_size_data,gpr1) <= signed(param->_size_data,gpr2); break;
	863	// }
[72]	864
	865	// Result
[76]	866	op->_timing = param->_timing[op->_type][op->_operation];
[72]	867	//op->_data_rd = 0;
	868	op->_data_re = set_flag(op->_data_re,FLAG_F,f_out);
	869	op->_exception = EXCEPTION_ALU_NONE;
	870	op->_no_sequence = 0;
[116]	871	#ifdef SYSTEMC_VHDL_COMPATIBILITY
	872	op->_address = 0;
	873	#else
[72]	874	//op->_address = 0;
[116]	875	#endif
[72]	876	};
	877
	878	#undef FUNCTION
	879	#define FUNCTION "Functionnal_unit::operation_l_sflts"
	880	void operation_l_sflts (execute_operation_t * op, execute_register_t * reg, execute_param_t * param)
	881	{
	882	log_printf(TRACE,Functionnal_unit,FUNCTION,"Operation : l_sflts");
	883
	884	Tgeneral_data_t gpr1 = op->_data_ra ;
	885	Tgeneral_data_t gpr2 = (op->_has_immediat==1)?op->_immediat:op->_data_rb;
	886
	887	bool f_out;
	888
[101]	889	if (param->_size_data == 32)
	890	f_out = static_cast<int32_t>(gpr1) < static_cast<int32_t>(gpr2);
	891	else
	892	f_out = static_cast<int64_t>(gpr1) < static_cast<int64_t>(gpr2);
[72]	893
[101]	894	// switch (concatenation_bool(sign(param->_size_data,gpr1),sign(param->_size_data,gpr2)))
	895	// {
	896	// case 1 /b01/ : f_out = 0; break;
	897	// case 2 /b10/ : f_out = 1; break;
	898	// default : f_out = signed(param->_size_data,gpr1) < signed(param->_size_data,gpr2); break;
	899	// }
	900
[72]	901	// Result
[76]	902	op->_timing = param->_timing[op->_type][op->_operation];
[72]	903	//op->_data_rd = 0;
	904	op->_data_re = set_flag(op->_data_re,FLAG_F,f_out);
	905	op->_exception = EXCEPTION_ALU_NONE;
	906	op->_no_sequence = 0;
[116]	907	#ifdef SYSTEMC_VHDL_COMPATIBILITY
	908	op->_address = 0;
	909	#else
[72]	910	//op->_address = 0;
[116]	911	#endif
[72]	912	};
	913
	914	#undef FUNCTION
	915	#define FUNCTION "Functionnal_unit::operation_l_mtspr"
	916	void operation_l_mtspr (execute_operation_t * op, execute_register_t * reg, execute_param_t * param)
	917	{
	918	log_printf(TRACE,Functionnal_unit,FUNCTION,"Operation : l_mtspr");
	919
[88]	920	Tgeneral_data_t imm = unsigned(param->_size_data,op->_immediat);
	921	Tgeneral_data_t gpr1 = unsigned(param->_size_data,op->_data_ra);
	922	Tgeneral_data_t gpr2 = unsigned(param->_size_data,op->_data_rb);
[72]	923	Tgeneral_data_t addr = range<Tgeneral_data_t>(gpr1\|imm,16);
	924
	925	Texception_t exception;
	926
	927	// HACK : use the field num_reg_re to pass the SM and SUMRA flag.
	928	Tcontrol_t flag_SM = get_flag(op->_num_reg_re, 0x1);
	929	Tcontrol_t flag_SUMRA = get_flag(op->_num_reg_re, 0x2);
	930
	931	spr_address_t spr_addr = reg->_spr_access_mode->translate_address(addr);
[98]	932
[72]	933	// Test if this group is implemented in this functionnal_unit
	934	if (reg->_spr_access_mode->valid(spr_addr))
	935	{
	936	if (reg->_spr_access_mode->write(spr_addr, flag_SM, flag_SUMRA))
	937	{
	938	reg->_i_write_spr = true;
	939	reg->_access_num_group = spr_addr._group;
	940	reg->_access_num_register = spr_addr._register;
	941	reg->_spr_old = reg->_spr[spr_addr._group][spr_addr._register];
	942	reg->_spr[spr_addr._group][spr_addr._register] = gpr2;
	943
	944	exception = EXCEPTION_ALU_NONE;
	945	}
	946	else
	947	{
	948	exception = EXCEPTION_ALU_SPR_ACCESS_INVALID;
	949	}
	950	}
	951	else
	952	{
[88]	953	exception = EXCEPTION_ALU_SPR_ACCESS_MUST_WRITE;
[72]	954	}
	955
	956	// Result
[76]	957	op->_timing = param->_timing[op->_type][op->_operation];
[72]	958	op->_data_rd = gpr2; // data_rb
	959	//op->_data_re = 0;
	960	op->_exception = exception;
	961	op->_no_sequence = 0;
	962	op->_address = addr; // data_ra or imm
	963	};
	964
	965	#undef FUNCTION
	966	#define FUNCTION "Functionnal_unit::operation_l_mfspr"
	967	void operation_l_mfspr (execute_operation_t * op, execute_register_t * reg, execute_param_t * param)
	968	{
	969	log_printf(TRACE,Functionnal_unit,FUNCTION,"Operation : l_mfspr");
	970
[88]	971	Tgeneral_data_t imm = unsigned(param->_size_data,op->_immediat);
	972	Tgeneral_data_t gpr1 = unsigned(param->_size_data,op->_data_ra);
[72]	973	Tgeneral_data_t gpr2 = 0;
	974	Tgeneral_data_t addr = range<Tgeneral_data_t>(gpr1\|imm,16);
	975
	976	Texception_t exception;
	977
	978	// HACK : use the field num_reg_re to pass the SM and SUMRA flag.
	979	Tcontrol_t flag_SM = get_flag(op->_num_reg_re, 0x1);
	980	Tcontrol_t flag_SUMRA = get_flag(op->_num_reg_re, 0x2);
	981
	982	spr_address_t spr_addr = reg->_spr_access_mode->translate_address(addr);
	983
	984	// Test if this group is implemented in this functionnal_unit
	985	if (reg->_spr_access_mode->valid(spr_addr))
	986	{
	987	if (reg->_spr_access_mode->read(spr_addr, flag_SM, flag_SUMRA))
	988	{
	989	reg->_i_read_spr = true;
	990	reg->_access_num_group = spr_addr._group;
	991	reg->_access_num_register = spr_addr._register;
	992
	993	gpr2 = reg->_spr[spr_addr._group][spr_addr._register];
	994
	995	exception = EXCEPTION_ALU_NONE;
	996	}
	997	else
	998	{
	999	exception = EXCEPTION_ALU_SPR_ACCESS_INVALID;
	1000	}
	1001	}
	1002	else
	1003	{
[88]	1004	exception = EXCEPTION_ALU_SPR_ACCESS_MUST_READ;
[72]	1005	}
	1006
	1007	// Result
[76]	1008	op->_timing = param->_timing[op->_type][op->_operation];
[72]	1009	op->_write_rd = (exception == EXCEPTION_ALU_NONE);
	1010	op->_data_rd = gpr2; // spr
	1011	//op->_data_re = 0;
	1012	op->_exception = exception;
	1013	op->_no_sequence = 0;
	1014	op->_address = addr; // data_ra or imm
	1015	};
	1016
	1017	#undef FUNCTION
	1018	#define FUNCTION "Functionnal_unit::operation_l_macrc"
	1019	void operation_l_macrc (execute_operation_t * op, execute_register_t * reg, execute_param_t * param)
	1020	{
	1021	log_printf(TRACE,Functionnal_unit,FUNCTION,"Operation : l_macrc");
	1022
	1023	Tgeneral_data_t gpr = static_cast<Tgeneral_data_t>(range<uint64_t>((static_cast<uint64_t>(reg->_spr[GROUP_MAC][SPR_MACHI]) << 32) \| static_cast<uint64_t>(reg->_spr[GROUP_MAC][SPR_MACLO]), param->_size_data));
	1024
	1025	reg->_spr[GROUP_MAC][SPR_MACLO] = 0;
	1026	reg->_spr[GROUP_MAC][SPR_MACHI] = 0;
	1027
	1028	// Result
[76]	1029	op->_timing = param->_timing[op->_type][op->_operation];
[72]	1030	op->_data_rd = gpr;
	1031	//op->_data_re = 0;
	1032	op->_exception = EXCEPTION_ALU_NONE;
	1033	op->_no_sequence = 0;
[116]	1034	#ifdef SYSTEMC_VHDL_COMPATIBILITY
	1035	op->_address = 0;
	1036	#else
[72]	1037	//op->_address = 0;
[116]	1038	#endif
[72]	1039	};
	1040
	1041	#undef FUNCTION
	1042	#define FUNCTION "Functionnal_unit::operation_l_mac"
	1043	void operation_l_mac (execute_operation_t * op, execute_register_t * reg, execute_param_t * param)
	1044	{
	1045	log_printf(TRACE,Functionnal_unit,FUNCTION,"Operation : l_mac");
	1046
[88]	1047	Tgeneral_data_t gpr1 = unsigned(param->_size_data,op->_data_ra);
	1048	Tgeneral_data_t gpr2 = unsigned(param->_size_data,(op->_has_immediat==1)?op->_immediat:op->_data_rb);
[72]	1049	uint64_t temp = range<uint64_t>(gpr1 * gpr2, 32);
	1050
	1051	temp = ((static_cast<uint64_t>(reg->_spr[GROUP_MAC][SPR_MACHI]) << 32) \| static_cast<uint64_t>(reg->_spr[GROUP_MAC][SPR_MACLO])) + temp;
	1052
	1053	reg->_spr[GROUP_MAC][SPR_MACLO] = range<Tgeneral_data_t>(temp ,32);
	1054	reg->_spr[GROUP_MAC][SPR_MACHI] = range<Tgeneral_data_t>(temp>>32,32);
	1055
	1056	// Result
[76]	1057	op->_timing = param->_timing[op->_type][op->_operation];
[72]	1058	//op->_data_rd = 0;
	1059	//op->_data_re = 0;
	1060	op->_exception = EXCEPTION_ALU_NONE;
	1061	op->_no_sequence = 0;
[116]	1062	#ifdef SYSTEMC_VHDL_COMPATIBILITY
	1063	op->_address = 0;
	1064	#else
[72]	1065	//op->_address = 0;
[116]	1066	#endif
[72]	1067	};
	1068
	1069	#undef FUNCTION
	1070	#define FUNCTION "Functionnal_unit::operation_l_msb"
	1071	void operation_l_msb (execute_operation_t * op, execute_register_t * reg, execute_param_t * param)
	1072	{
	1073	log_printf(TRACE,Functionnal_unit,FUNCTION,"Operation : l_msb");
	1074
[88]	1075	Tgeneral_data_t gpr1 = unsigned(param->_size_data,op->_data_ra);
	1076	Tgeneral_data_t gpr2 = unsigned(param->_size_data,(op->_has_immediat==1)?op->_immediat:op->_data_rb);
[72]	1077	uint64_t temp = range<uint64_t>(gpr1 * gpr2, 32);
	1078
	1079	temp = ((static_cast<uint64_t>(reg->_spr[GROUP_MAC][SPR_MACHI]) << 32) \| static_cast<uint64_t>(reg->_spr[GROUP_MAC][SPR_MACLO])) - temp;
	1080
	1081	reg->_spr[GROUP_MAC][SPR_MACLO] = range<Tgeneral_data_t>(temp ,32);
	1082	reg->_spr[GROUP_MAC][SPR_MACHI] = range<Tgeneral_data_t>(temp>>32,32);
	1083
	1084	// Result
[76]	1085	op->_timing = param->_timing[op->_type][op->_operation];
[72]	1086	//op->_data_rd = 0;
	1087	//op->_data_re = 0;
	1088	op->_exception = EXCEPTION_ALU_NONE;
	1089	op->_no_sequence = 0;
[116]	1090	#ifdef SYSTEMC_VHDL_COMPATIBILITY
	1091	op->_address = 0;
	1092	#else
[72]	1093	//op->_address = 0;
[116]	1094	#endif
[72]	1095	};
	1096
	1097	}; // end namespace functionnal_unit
	1098	}; // end namespace execute_unit
	1099	}; // end namespace multi_execute_unit
	1100	}; // end namespace execute_loop
	1101	}; // end namespace multi_execute_loop
	1102	}; // end namespace core
	1103	}; // end namespace behavioural
	1104	}; // end namespace morpheo
	1105	#endif

Note: See TracBrowser for help on using the repository browser.

Context Navigation

source: trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Execute_unit/Execute_unit/Functionnal_unit/Operation/src/Operation.cpp @ 116

Download in other formats: