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

Line
1	#ifdef SYSTEMC
2	/*
3	* $Id: Operation.cpp 116 2009-04-30 13:51:41Z moulu $
4	*
5	* [ Description ]
6	*
7	*/
8
9	#include "Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Execute_unit/Execute_unit/Functionnal_unit/Operation/include/Operation.h"
10	#include "Behavioural/include/Operation.h"
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
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);
38
39	Tgeneral_data_t gpr3 = param->_mask_data & (gpr1 + gpr2);
40
41	bool overflow = ovf (param->_size_data,gpr1,gpr2,gpr3);
42	bool carry_out = carry(param->_size_data,gpr1,gpr2,gpr3);
43
44	// Result
45	op->_timing = param->_timing[op->_type][op->_operation];
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;
52	#ifdef SYSTEMC_VHDL_COMPATIBILITY
53	op->_address = 0;
54	#else
55	//op->_address = 0;
56	#endif
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
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);
69	Tgeneral_data_t gpr3 = param->_mask_data & (gpr1 + gpr2 + carry_in);
70
71	bool overflow = ovf (param->_size_data,gpr1,gpr2,gpr3);
72	bool carry_out = carry(param->_size_data,gpr1,gpr2,gpr3);
73
74	// Result
75	op->_timing = param->_timing[op->_type][op->_operation];
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;
82	#ifdef SYSTEMC_VHDL_COMPATIBILITY
83	op->_address = 0;
84	#else
85	//op->_address = 0;
86	#endif
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
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));
97	Tgeneral_data_t gpr3 = param->_mask_data & (gpr1 + gpr2);
98
99	bool overflow = ovf (param->_size_data,gpr1,gpr2,gpr3);
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);
103
104	// Result
105	op->_timing = param->_timing[op->_type][op->_operation];
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;
112	#ifdef SYSTEMC_VHDL_COMPATIBILITY
113	op->_address = 0;
114	#else
115	//op->_address = 0;
116	#endif
117	};
118
119	#undef FUNCTION
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;
154	#ifdef SYSTEMC_VHDL_COMPATIBILITY
155	op->_address = 0;
156	#else
157	//op->_address = 0;
158	#endif
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;
196	#ifdef SYSTEMC_VHDL_COMPATIBILITY
197	op->_address = 0;
198	#else
199	//op->_address = 0;
200	#endif
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;
223	#ifdef SYSTEMC_VHDL_COMPATIBILITY
224	op->_address = 0;
225	#else
226	//op->_address = 0;
227	#endif
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;
250	#ifdef SYSTEMC_VHDL_COMPATIBILITY
251	op->_address = 0;
252	#else
253	//op->_address = 0;
254	#endif
255	};
256
257	#undef FUNCTION
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
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);
265	Tgeneral_data_t gpr3 = (gpr1 & gpr2);
266
267	// Result
268	op->_timing = param->_timing[op->_type][op->_operation];
269	op->_data_rd = gpr3;
270	//op->_data_re = 0;
271	op->_exception = EXCEPTION_ALU_NONE;
272	op->_no_sequence = 0;
273	#ifdef SYSTEMC_VHDL_COMPATIBILITY
274	op->_address = 0;
275	#else
276	//op->_address = 0;
277	#endif
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
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);
288	Tgeneral_data_t gpr3 = (gpr1 \| gpr2);
289
290	// Result
291	op->_timing = param->_timing[op->_type][op->_operation];
292	op->_data_rd = gpr3;
293	//op->_data_re = 0;
294	op->_exception = EXCEPTION_ALU_NONE;
295	op->_no_sequence = 0;
296	#ifdef SYSTEMC_VHDL_COMPATIBILITY
297	op->_address = 0;
298	#else
299	//op->_address = 0;
300	#endif
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
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);
311	Tgeneral_data_t gpr3 = (gpr1 ^ gpr2);
312
313	// Result
314	op->_timing = param->_timing[op->_type][op->_operation];
315	op->_data_rd = gpr3;
316	//op->_data_re = 0;
317	op->_exception = EXCEPTION_ALU_NONE;
318	op->_no_sequence = 0;
319	#ifdef SYSTEMC_VHDL_COMPATIBILITY
320	op->_address = 0;
321	#else
322	//op->_address = 0;
323	#endif
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
332	Tgeneral_data_t gpr1 = unsigned(param->_size_data,op->_immediat);
333	Tgeneral_data_t gpr2 = param->_mask_data & (gpr1<<16);
334
335	// Result
336	op->_timing = param->_timing[op->_type][op->_operation];
337	op->_data_rd = gpr2;
338	//op->_data_re = 0;
339	op->_exception = EXCEPTION_ALU_NONE;
340	op->_no_sequence = 0;
341	#ifdef SYSTEMC_VHDL_COMPATIBILITY
342	op->_address = 0;
343	#else
344	//op->_address = 0;
345	#endif
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
356	Tgeneral_data_t gpr1 = unsigned(param->_size_data,op->_data_ra);
357	Tgeneral_data_t gpr2 = unsigned(param->_size_data,op->_data_rb);
358	Tgeneral_data_t gpr3 = ((f_in==0)?gpr2:gpr1);
359
360	// Result
361	op->_timing = param->_timing[op->_type][op->_operation];
362	op->_data_rd = gpr3;
363	//op->_data_re = 0;
364	op->_exception = EXCEPTION_ALU_NONE;
365	op->_no_sequence = 0;
366	#ifdef SYSTEMC_VHDL_COMPATIBILITY
367	op->_address = 0;
368	#else
369	//op->_address = 0;
370	#endif
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);
380	Tgeneral_data_t imm = unsigned(param->_size_data,op->_immediat);
381
382	// Result
383	op->_timing = param->_timing[op->_type][op->_operation];
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);
398	Tgeneral_data_t imm = unsigned(param->_size_data,op->_immediat);
399
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
403	// Result
404	op->_timing = param->_timing[op->_type][op->_operation];
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;
410
411	log_printf(TRACE,Functionnal_unit,FUNCTION," * no_sequence : %d",op->_no_sequence);
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
424	Tgeneral_data_t gpr = unsigned(param->_size_data,op->_data_rb);
425	Tgeneral_data_t imm = unsigned(param->_size_data,op->_immediat);
426
427	// Result
428	op->_timing = param->_timing[op->_type][op->_operation];
429	op->_data_rd = imm<<2; // add "00"
430	//op->_data_re = 0;
431	op->_exception = EXCEPTION_ALU_NONE;
432	op->_no_sequence = 1;
433	op->_address = gpr>>2; // del "00"
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
442	Tgeneral_data_t imm = unsigned(param->_size_data,op->_immediat);
443	Tgeneral_data_t gpr1 = unsigned(param->_size_data,op->_data_ra);
444	Tgeneral_data_t gpr2 = extend<Tgeneral_data_t>(param->_size_data, gpr1, true , imm);
445
446	// Result
447	op->_timing = param->_timing[op->_type][op->_operation];
448	op->_data_rd = gpr2;
449	//op->_data_re = 0;
450	op->_exception = EXCEPTION_ALU_NONE;
451	op->_no_sequence = 0;
452	#ifdef SYSTEMC_VHDL_COMPATIBILITY
453	op->_address = 0;
454	#else
455	//op->_address = 0;
456	#endif
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
465	Tgeneral_data_t imm = unsigned(param->_size_data,op->_immediat);
466	Tgeneral_data_t gpr1 = unsigned(param->_size_data,op->_data_ra);
467	Tgeneral_data_t gpr2 = extend<Tgeneral_data_t>(param->_size_data, gpr1, false , imm);
468
469	// Result
470	op->_timing = param->_timing[op->_type][op->_operation];
471	op->_data_rd = gpr2;
472	//op->_data_re = 0;
473	op->_exception = EXCEPTION_ALU_NONE;
474	op->_no_sequence = 0;
475	#ifdef SYSTEMC_VHDL_COMPATIBILITY
476	op->_address = 0;
477	#else
478	//op->_address = 0;
479	#endif
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
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);
490	Tgeneral_data_t gpr3 = shift_logic_left<Tgeneral_data_t>(param->_size_data, gpr1, gpr2);
491
492	// Result
493	op->_timing = param->_timing[op->_type][op->_operation];
494	op->_data_rd = gpr3;
495	//op->_data_re = 0;
496	op->_exception = EXCEPTION_ALU_NONE;
497	op->_no_sequence = 0;
498	#ifdef SYSTEMC_VHDL_COMPATIBILITY
499	op->_address = 0;
500	#else
501	//op->_address = 0;
502	#endif
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
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);
513	Tgeneral_data_t gpr3 = shift_logic_right<Tgeneral_data_t>(param->_size_data, gpr1, gpr2);
514
515	// Result
516	op->_timing = param->_timing[op->_type][op->_operation];
517	op->_data_rd = gpr3;
518	//op->_data_re = 0;
519	op->_exception = EXCEPTION_ALU_NONE;
520	op->_no_sequence = 0;
521	#ifdef SYSTEMC_VHDL_COMPATIBILITY
522	op->_address = 0;
523	#else
524	//op->_address = 0;
525	#endif
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
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);
536	Tgeneral_data_t gpr3 = shift_arithmetic_right<Tgeneral_data_t>(param->_size_data, gpr1, gpr2);
537
538	// Result
539	op->_timing = param->_timing[op->_type][op->_operation];
540	op->_data_rd = gpr3;
541	//op->_data_re = 0;
542	op->_exception = EXCEPTION_ALU_NONE;
543	op->_no_sequence = 0;
544	#ifdef SYSTEMC_VHDL_COMPATIBILITY
545	op->_address = 0;
546	#else
547	//op->_address = 0;
548	#endif
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
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);
559	Tgeneral_data_t gpr3 = rotate_right<Tgeneral_data_t>(param->_size_data, gpr1, gpr2);
560
561	// Result
562	op->_timing = param->_timing[op->_type][op->_operation];
563	op->_data_rd = gpr3;
564	//op->_data_re = 0;
565	op->_exception = EXCEPTION_ALU_NONE;
566	op->_no_sequence = 0;
567	#ifdef SYSTEMC_VHDL_COMPATIBILITY
568	op->_address = 0;
569	#else
570	//op->_address = 0;
571	#endif
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
580	Tgeneral_data_t gpr = unsigned(param->_size_data,op->_data_ra);
581	Tgeneral_data_t index;
582
583	for (index=0; (index<param->_size_data) and (((gpr>>index)&1)!= 1); index++);
584
585	// Result
586	op->_timing = param->_timing[op->_type][op->_operation];
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;
591	#ifdef SYSTEMC_VHDL_COMPATIBILITY
592	op->_address = 0;
593	#else
594	//op->_address = 0;
595	#endif
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
604	Tgeneral_data_t gpr = unsigned(param->_size_data,op->_data_ra);
605	Tgeneral_data_t index;
606
607	for (index=param->_size_data; (index>0) and (((gpr>>(index-1))&1)!= 1); index--);
608
609	// Result
610	op->_timing = param->_timing[op->_type][op->_operation];
611	op->_data_rd = index;
612	//op->_data_re = 0;
613	op->_exception = EXCEPTION_ALU_NONE;
614	op->_no_sequence = 0;
615	#ifdef SYSTEMC_VHDL_COMPATIBILITY
616	op->_address = 0;
617	#else
618	//op->_address = 0;
619	#endif
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
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);
630
631	bool f_out = (gpr1 == gpr2);
632
633	// Result
634	op->_timing = param->_timing[op->_type][op->_operation];
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;
639	#ifdef SYSTEMC_VHDL_COMPATIBILITY
640	op->_address = 0;
641	#else
642	//op->_address = 0;
643	#endif
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
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);
654
655	bool f_out = (gpr1 != gpr2);
656
657	// Result
658	op->_timing = param->_timing[op->_type][op->_operation];
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;
663	#ifdef SYSTEMC_VHDL_COMPATIBILITY
664	op->_address = 0;
665	#else
666	//op->_address = 0;
667	#endif
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
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);
678
679	// Tgeneral_data_t is unsigned
680	bool f_out = (gpr1 >= gpr2);
681
682	// Result
683	op->_timing = param->_timing[op->_type][op->_operation];
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;
688	#ifdef SYSTEMC_VHDL_COMPATIBILITY
689	op->_address = 0;
690	#else
691	//op->_address = 0;
692	#endif
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
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);
703
704	// Tgeneral_data_t is unsigned
705	bool f_out = (gpr1 > gpr2);
706
707	// Result
708	op->_timing = param->_timing[op->_type][op->_operation];
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;
713	#ifdef SYSTEMC_VHDL_COMPATIBILITY
714	op->_address = 0;
715	#else
716	//op->_address = 0;
717	#endif
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
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);
728
729	// Tgeneral_data_t is unsigned
730	bool f_out = (gpr1 <= gpr2);
731
732	// Result
733	op->_timing = param->_timing[op->_type][op->_operation];
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;
738	#ifdef SYSTEMC_VHDL_COMPATIBILITY
739	op->_address = 0;
740	#else
741	//op->_address = 0;
742	#endif
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
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);
753
754	// Tgeneral_data_t is unsigned
755	bool f_out = (gpr1 < gpr2);
756
757	// Result
758	op->_timing = param->_timing[op->_type][op->_operation];
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;
763	#ifdef SYSTEMC_VHDL_COMPATIBILITY
764	op->_address = 0;
765	#else
766	//op->_address = 0;
767	#endif
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;
778
779	bool f_out;
780
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);
785
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	// }
792
793	// Result
794	op->_timing = param->_timing[op->_type][op->_operation];
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;
799	#ifdef SYSTEMC_VHDL_COMPATIBILITY
800	op->_address = 0;
801	#else
802	//op->_address = 0;
803	#endif
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
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);
821
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
829	// Result
830	op->_timing = param->_timing[op->_type][op->_operation];
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;
835	#ifdef SYSTEMC_VHDL_COMPATIBILITY
836	op->_address = 0;
837	#else
838	//op->_address = 0;
839	#endif
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
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	// }
864
865	// Result
866	op->_timing = param->_timing[op->_type][op->_operation];
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;
871	#ifdef SYSTEMC_VHDL_COMPATIBILITY
872	op->_address = 0;
873	#else
874	//op->_address = 0;
875	#endif
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
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);
893
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
901	// Result
902	op->_timing = param->_timing[op->_type][op->_operation];
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;
907	#ifdef SYSTEMC_VHDL_COMPATIBILITY
908	op->_address = 0;
909	#else
910	//op->_address = 0;
911	#endif
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
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);
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);
932
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	{
953	exception = EXCEPTION_ALU_SPR_ACCESS_MUST_WRITE;
954	}
955
956	// Result
957	op->_timing = param->_timing[op->_type][op->_operation];
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
971	Tgeneral_data_t imm = unsigned(param->_size_data,op->_immediat);
972	Tgeneral_data_t gpr1 = unsigned(param->_size_data,op->_data_ra);
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	{
1004	exception = EXCEPTION_ALU_SPR_ACCESS_MUST_READ;
1005	}
1006
1007	// Result
1008	op->_timing = param->_timing[op->_type][op->_operation];
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
1029	op->_timing = param->_timing[op->_type][op->_operation];
1030	op->_data_rd = gpr;
1031	//op->_data_re = 0;
1032	op->_exception = EXCEPTION_ALU_NONE;
1033	op->_no_sequence = 0;
1034	#ifdef SYSTEMC_VHDL_COMPATIBILITY
1035	op->_address = 0;
1036	#else
1037	//op->_address = 0;
1038	#endif
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
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);
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
1057	op->_timing = param->_timing[op->_type][op->_operation];
1058	//op->_data_rd = 0;
1059	//op->_data_re = 0;
1060	op->_exception = EXCEPTION_ALU_NONE;
1061	op->_no_sequence = 0;
1062	#ifdef SYSTEMC_VHDL_COMPATIBILITY
1063	op->_address = 0;
1064	#else
1065	//op->_address = 0;
1066	#endif
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
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);
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
1085	op->_timing = param->_timing[op->_type][op->_operation];
1086	//op->_data_rd = 0;
1087	//op->_data_re = 0;
1088	op->_exception = EXCEPTION_ALU_NONE;
1089	op->_no_sequence = 0;
1090	#ifdef SYSTEMC_VHDL_COMPATIBILITY
1091	op->_address = 0;
1092	#else
1093	//op->_address = 0;
1094	#endif
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: