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

Last change on this file since 98 was 98, checked in by rosiere, 16 years ago

1) Fix bug (read unit, RAT -> write in R0, SPR desallocation ...)
2) Change VHDL Execute_queue -> use Generic/Queue?
3) Complete document on VHDL generation
4) Add soc test
  • Property svn:keywords set to Id
File size: 31.4 KB
Line 
1#ifdef SYSTEMC
2/*
3 * $Id: Operation.cpp 98 2008-12-31 10:18:08Z rosiere $
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
12namespace morpheo                    {
13namespace behavioural {
14namespace core {
15namespace multi_execute_loop {
16namespace execute_loop {
17namespace multi_execute_unit {
18namespace execute_unit {
19namespace 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  //op->_address      = 0;
53  };
54
55#undef  FUNCTION
56#define FUNCTION "Functionnal_unit::operation_l_addc"
57  void operation_l_addc        (execute_operation_t * op, execute_register_t * reg, execute_param_t * param)
58  {
59    log_printf(TRACE,Functionnal_unit,FUNCTION,"Operation : l_addc");
60
61    Tgeneral_data_t carry_in   = get_flag(op->_data_rc,FLAG_CY);
62
63    Tgeneral_data_t gpr1       = unsigned(param->_size_data,op->_data_ra);
64    Tgeneral_data_t gpr2       = unsigned(param->_size_data,(op->_has_immediat==1)?op->_immediat:op->_data_rb);
65    Tgeneral_data_t gpr3       = param->_mask_data & (gpr1 + gpr2 + carry_in);
66
67    bool            overflow   = ovf  (param->_size_data,gpr1,gpr2,gpr3);
68    bool            carry_out  = carry(param->_size_data,gpr1,gpr2,gpr3);
69
70    // Result
71    op->_timing       = param->_timing[op->_type][op->_operation];
72    op->_data_rd      = gpr3;
73    op->_data_re      = 0;
74    op->_data_re      = set_flag(op->_data_re,FLAG_OV,overflow );
75    op->_data_re      = set_flag(op->_data_re,FLAG_CY,carry_out);
76    op->_exception    = (overflow==1)?EXCEPTION_ALU_RANGE:EXCEPTION_ALU_NONE;
77    op->_no_sequence  = 0;
78  //op->_address      = 0;
79  };
80
81#undef  FUNCTION
82#define FUNCTION "Functionnal_unit::operation_l_sub"
83  void operation_l_sub         (execute_operation_t * op, execute_register_t * reg, execute_param_t * param)
84  {
85    log_printf(TRACE,Functionnal_unit,FUNCTION,"Operation : l_sub");
86
87    Tgeneral_data_t gpr1      =                       unsigned(param->_size_data,op->_data_ra);
88    Tgeneral_data_t gpr2      = neg(param->_size_data,unsigned(param->_size_data,op->_data_rb));
89    Tgeneral_data_t gpr3      = param->_mask_data & (gpr1 + gpr2);
90
91    bool            overflow  = ovf  (param->_size_data,gpr1,gpr2,gpr3);
92    bool            carry_out = carry(param->_size_data,gpr1,gpr2,gpr3);
93
94    // Result
95    op->_timing       = param->_timing[op->_type][op->_operation];
96    op->_data_rd      = gpr3;
97    op->_data_re      = 0;
98    op->_data_re      = set_flag(op->_data_re,FLAG_OV,overflow );
99    op->_data_re      = set_flag(op->_data_re,FLAG_CY,carry_out);
100    op->_exception    = (overflow==1)?EXCEPTION_ALU_RANGE:EXCEPTION_ALU_NONE;
101    op->_no_sequence  = 0;
102  //op->_address      = 0;
103  };
104
105#undef  FUNCTION
106#define FUNCTION "Functionnal_unit::operation_l_and"
107  void operation_l_and         (execute_operation_t * op, execute_register_t * reg, execute_param_t * param)
108  {
109    log_printf(TRACE,Functionnal_unit,FUNCTION,"Operation : l_and");
110
111    Tgeneral_data_t gpr1       = unsigned(param->_size_data,op->_data_ra);
112    Tgeneral_data_t gpr2       = unsigned(param->_size_data,(op->_has_immediat==1)?op->_immediat:op->_data_rb);
113    Tgeneral_data_t gpr3       = (gpr1 & gpr2);
114
115    // Result
116    op->_timing       = param->_timing[op->_type][op->_operation];
117    op->_data_rd      = gpr3;
118  //op->_data_re      = 0;
119    op->_exception    = EXCEPTION_ALU_NONE;
120    op->_no_sequence  = 0;
121  //op->_address      = 0;
122  };
123
124#undef  FUNCTION
125#define FUNCTION "Functionnal_unit::operation_l_or"
126  void operation_l_or          (execute_operation_t * op, execute_register_t * reg, execute_param_t * param)
127  {
128    log_printf(TRACE,Functionnal_unit,FUNCTION,"Operation : l_or");
129
130    Tgeneral_data_t gpr1       = unsigned(param->_size_data,op->_data_ra);
131    Tgeneral_data_t gpr2       = unsigned(param->_size_data,(op->_has_immediat==1)?op->_immediat:op->_data_rb);
132    Tgeneral_data_t gpr3       = (gpr1 | gpr2);
133
134    // Result
135    op->_timing       = param->_timing[op->_type][op->_operation];
136    op->_data_rd      = gpr3;
137  //op->_data_re      = 0;
138    op->_exception    = EXCEPTION_ALU_NONE;
139    op->_no_sequence  = 0;
140  //op->_address      = 0;
141  };
142
143#undef  FUNCTION
144#define FUNCTION "Functionnal_unit::operation_l_xor"
145  void operation_l_xor         (execute_operation_t * op, execute_register_t * reg, execute_param_t * param)
146  {
147    log_printf(TRACE,Functionnal_unit,FUNCTION,"Operation : l_xor");
148
149    Tgeneral_data_t gpr1       = unsigned(param->_size_data,op->_data_ra);
150    Tgeneral_data_t gpr2       = unsigned(param->_size_data,(op->_has_immediat==1)?op->_immediat:op->_data_rb);
151    Tgeneral_data_t gpr3       = (gpr1 ^ gpr2);
152
153    // Result
154    op->_timing       = param->_timing[op->_type][op->_operation];
155    op->_data_rd      = gpr3;
156  //op->_data_re      = 0;
157    op->_exception    = EXCEPTION_ALU_NONE;
158    op->_no_sequence  = 0;
159  //op->_address      = 0;
160  };
161
162#undef  FUNCTION
163#define FUNCTION "Functionnal_unit::operation_l_movhi"
164  void operation_l_movhi       (execute_operation_t * op, execute_register_t * reg, execute_param_t * param)
165  {
166    log_printf(TRACE,Functionnal_unit,FUNCTION,"Operation : l_movhi");
167
168    Tgeneral_data_t gpr1       = unsigned(param->_size_data,op->_immediat);
169    Tgeneral_data_t gpr2       = param->_mask_data & (gpr1<<16);
170
171    // Result
172    op->_timing       = param->_timing[op->_type][op->_operation];
173    op->_data_rd      = gpr2;
174  //op->_data_re      = 0;
175    op->_exception    = EXCEPTION_ALU_NONE;
176    op->_no_sequence  = 0;
177  //op->_address      = 0;
178  };
179
180#undef  FUNCTION
181#define FUNCTION "Functionnal_unit::operation_l_cmov"
182  void operation_l_cmov        (execute_operation_t * op, execute_register_t * reg, execute_param_t * param)
183  {
184    log_printf(TRACE,Functionnal_unit,FUNCTION,"Operation : l_cmov");
185
186    Tgeneral_data_t f_in       = get_flag(op->_data_rc,FLAG_F);
187
188    Tgeneral_data_t gpr1       = unsigned(param->_size_data,op->_data_ra);
189    Tgeneral_data_t gpr2       = unsigned(param->_size_data,op->_data_rb);
190    Tgeneral_data_t gpr3       = ((f_in==0)?gpr2:gpr1);
191
192    // Result
193    op->_timing       = param->_timing[op->_type][op->_operation];
194    op->_data_rd      = gpr3;
195  //op->_data_re      = 0;
196    op->_exception    = EXCEPTION_ALU_NONE;
197    op->_no_sequence  = 0;
198  //op->_address      = 0;
199  };
200
201#undef  FUNCTION
202#define FUNCTION "Functionnal_unit::operation_l_test_f"
203  void operation_l_test_f      (execute_operation_t * op, execute_register_t * reg, execute_param_t * param)
204  {
205    log_printf(TRACE,Functionnal_unit,FUNCTION,"Operation : l_test_f");
206
207    Tgeneral_data_t f_in       = get_flag(op->_data_rc,FLAG_F);
208    Tgeneral_data_t imm        = unsigned(param->_size_data,op->_immediat);
209
210    // Result
211    op->_timing       = param->_timing[op->_type][op->_operation];
212  //op->_data_rd      = 0;
213  //op->_data_re      = 0;
214    op->_exception    = EXCEPTION_ALU_NONE;
215    op->_no_sequence  = f_in != 0;
216    op->_address      = imm;
217  };
218
219#undef  FUNCTION
220#define FUNCTION "Functionnal_unit::operation_l_test_nf"
221  void operation_l_test_nf     (execute_operation_t * op, execute_register_t * reg, execute_param_t * param)
222  {
223    log_printf(TRACE,Functionnal_unit,FUNCTION,"Operation : l_test_nf");
224
225    Tgeneral_data_t f_in       = get_flag(op->_data_rc,FLAG_F);
226    Tgeneral_data_t imm        = unsigned(param->_size_data,op->_immediat);
227
228    log_printf(TRACE,Functionnal_unit,FUNCTION,"  * data_rc     : %d",op->_data_rc);
229    log_printf(TRACE,Functionnal_unit,FUNCTION,"  * f_in        : %d",f_in);
230
231    // Result
232    op->_timing       = param->_timing[op->_type][op->_operation];
233  //op->_data_rd      = 0;
234  //op->_data_re      = 0;
235    op->_exception    = EXCEPTION_ALU_NONE;
236    op->_no_sequence  = f_in == 0;
237    op->_address      = imm;
238
239    log_printf(TRACE,Functionnal_unit,FUNCTION,"  * no_sequence : %d",op->_no_sequence);
240  };
241
242#undef  FUNCTION
243#define FUNCTION "Functionnal_unit::operation_l_jalr"
244  void operation_l_jalr        (execute_operation_t * op, execute_register_t * reg, execute_param_t * param)
245  {
246    log_printf(TRACE,Functionnal_unit,FUNCTION,"Operation : l_jalr");
247    // jal  : has_imm = 1, write_rd = 1, read_rb = 0
248    // jalr : has_imm = 1, write_rd = 1, read_rb = 1
249    // jr   : has_imm = 0, write_rd = 0, read_rb = 1
250
251
252    Tgeneral_data_t gpr        = unsigned(param->_size_data,op->_data_rb);
253    Tgeneral_data_t imm        = unsigned(param->_size_data,op->_immediat);
254
255    // Result
256    op->_timing       = param->_timing[op->_type][op->_operation];
257    op->_data_rd      = imm;
258  //op->_data_re      = 0;
259    op->_exception    = EXCEPTION_ALU_NONE;
260    op->_no_sequence  = 1;
261    op->_address      = gpr;
262  };
263
264#undef  FUNCTION
265#define FUNCTION "Functionnal_unit::operation_l_extend_s"
266  void operation_l_extend_s    (execute_operation_t * op, execute_register_t * reg, execute_param_t * param)
267  {
268    log_printf(TRACE,Functionnal_unit,FUNCTION,"Operation : l_extend_s");
269
270    Tgeneral_data_t imm        = unsigned(param->_size_data,op->_immediat);
271    Tgeneral_data_t gpr1       = unsigned(param->_size_data,op->_data_ra);
272    Tgeneral_data_t gpr2       = extend<Tgeneral_data_t>(param->_size_data, gpr1, true , imm);
273
274    // Result
275    op->_timing       = param->_timing[op->_type][op->_operation];
276    op->_data_rd      = gpr2;
277  //op->_data_re      = 0;
278    op->_exception    = EXCEPTION_ALU_NONE;
279    op->_no_sequence  = 0;
280  //op->_address      = 0;
281  };
282
283#undef  FUNCTION
284#define FUNCTION "Functionnal_unit::operation_l_extend_z"
285  void operation_l_extend_z    (execute_operation_t * op, execute_register_t * reg, execute_param_t * param)
286  {
287    log_printf(TRACE,Functionnal_unit,FUNCTION,"Operation : l_extend_z");
288
289    Tgeneral_data_t imm        = unsigned(param->_size_data,op->_immediat);
290    Tgeneral_data_t gpr1       = unsigned(param->_size_data,op->_data_ra);
291    Tgeneral_data_t gpr2       = extend<Tgeneral_data_t>(param->_size_data, gpr1, false , imm);
292
293    // Result
294    op->_timing       = param->_timing[op->_type][op->_operation];
295    op->_data_rd      = gpr2;
296  //op->_data_re      = 0;
297    op->_exception    = EXCEPTION_ALU_NONE;
298    op->_no_sequence  = 0;
299  //op->_address      = 0;
300  };
301
302#undef  FUNCTION
303#define FUNCTION "Functionnal_unit::operation_l_sll"
304  void operation_l_sll         (execute_operation_t * op, execute_register_t * reg, execute_param_t * param)
305  {
306    log_printf(TRACE,Functionnal_unit,FUNCTION,"Operation : l_sll");
307
308    Tgeneral_data_t gpr1       = unsigned(param->_size_data,op->_data_ra);
309    Tgeneral_data_t gpr2       = param->_mask_shift & unsigned(param->_size_data,(op->_has_immediat==1)?op->_immediat:op->_data_rb);
310    Tgeneral_data_t gpr3       = shift_logic_left<Tgeneral_data_t>(param->_size_data, gpr1, gpr2);
311
312    // Result
313    op->_timing       = param->_timing[op->_type][op->_operation];
314    op->_data_rd      = gpr3;
315  //op->_data_re      = 0;
316    op->_exception    = EXCEPTION_ALU_NONE;
317    op->_no_sequence  = 0;
318  //op->_address      = 0;
319  };
320
321#undef  FUNCTION
322#define FUNCTION "Functionnal_unit::operation_l_srl"
323  void operation_l_srl         (execute_operation_t * op, execute_register_t * reg, execute_param_t * param)
324  {
325    log_printf(TRACE,Functionnal_unit,FUNCTION,"Operation : l_srl");
326
327    Tgeneral_data_t gpr1       = unsigned(param->_size_data,op->_data_ra);
328    Tgeneral_data_t gpr2       = param->_mask_shift & unsigned(param->_size_data,(op->_has_immediat==1)?op->_immediat:op->_data_rb);
329    Tgeneral_data_t gpr3       = shift_logic_right<Tgeneral_data_t>(param->_size_data, gpr1, gpr2);
330
331    // Result
332    op->_timing       = param->_timing[op->_type][op->_operation];
333    op->_data_rd      = gpr3;
334  //op->_data_re      = 0;
335    op->_exception    = EXCEPTION_ALU_NONE;
336    op->_no_sequence  = 0;
337  //op->_address      = 0;
338  };
339
340#undef  FUNCTION
341#define FUNCTION "Functionnal_unit::operation_l_sra"
342  void operation_l_sra         (execute_operation_t * op, execute_register_t * reg, execute_param_t * param)
343  {
344    log_printf(TRACE,Functionnal_unit,FUNCTION,"Operation : l_sra");
345
346    Tgeneral_data_t gpr1       = unsigned(param->_size_data,op->_data_ra);
347    Tgeneral_data_t gpr2       = param->_mask_shift & unsigned(param->_size_data,(op->_has_immediat==1)?op->_immediat:op->_data_rb);
348    Tgeneral_data_t gpr3       = shift_arithmetic_right<Tgeneral_data_t>(param->_size_data, gpr1, gpr2);
349
350    // Result
351    op->_timing       = param->_timing[op->_type][op->_operation];
352    op->_data_rd      = gpr3;
353  //op->_data_re      = 0;
354    op->_exception    = EXCEPTION_ALU_NONE;
355    op->_no_sequence  = 0;
356  //op->_address      = 0;
357  };
358
359#undef  FUNCTION
360#define FUNCTION "Functionnal_unit::operation_l_ror"
361  void operation_l_ror         (execute_operation_t * op, execute_register_t * reg, execute_param_t * param)
362  {
363    log_printf(TRACE,Functionnal_unit,FUNCTION,"Operation : l_ror");
364
365    Tgeneral_data_t gpr1       = unsigned(param->_size_data,op->_data_ra);
366    Tgeneral_data_t gpr2       = param->_mask_shift & unsigned(param->_size_data,(op->_has_immediat==1)?op->_immediat:op->_data_rb);
367    Tgeneral_data_t gpr3       = rotate_right<Tgeneral_data_t>(param->_size_data, gpr1, gpr2);
368
369    // Result
370    op->_timing       = param->_timing[op->_type][op->_operation];
371    op->_data_rd      = gpr3;
372  //op->_data_re      = 0;
373    op->_exception    = EXCEPTION_ALU_NONE;
374    op->_no_sequence  = 0;
375  //op->_address      = 0;
376  };
377
378#undef  FUNCTION
379#define FUNCTION "Functionnal_unit::operation_l_ff1"
380  void operation_l_ff1         (execute_operation_t * op, execute_register_t * reg, execute_param_t * param)
381  {
382    log_printf(TRACE,Functionnal_unit,FUNCTION,"Operation : l_ff1");
383
384    Tgeneral_data_t gpr        = unsigned(param->_size_data,op->_data_ra);
385    Tgeneral_data_t index;
386
387    for (index=0; (index<param->_size_data) and (((gpr>>index)&1)!= 1); index++);
388
389    // Result
390    op->_timing       = param->_timing[op->_type][op->_operation];
391    op->_data_rd      = (index==param->_size_data)?0:(index+1);
392  //op->_data_re      = 0;
393    op->_exception    = EXCEPTION_ALU_NONE;
394    op->_no_sequence  = 0;
395  //op->_address      = 0;
396  };
397
398#undef  FUNCTION
399#define FUNCTION "Functionnal_unit::operation_l_fl1"
400  void operation_l_fl1         (execute_operation_t * op, execute_register_t * reg, execute_param_t * param)
401  {
402    log_printf(TRACE,Functionnal_unit,FUNCTION,"Operation : l_fl1");
403
404    Tgeneral_data_t gpr        = unsigned(param->_size_data,op->_data_ra);
405    Tgeneral_data_t index;
406
407    for (index=param->_size_data; (index>0) and (((gpr>>(index-1))&1)!= 1); index--);
408
409    // Result
410    op->_timing       = param->_timing[op->_type][op->_operation];
411    op->_data_rd      = index;
412  //op->_data_re      = 0;
413    op->_exception    = EXCEPTION_ALU_NONE;
414    op->_no_sequence  = 0;
415  //op->_address      = 0;
416  };
417
418#undef  FUNCTION
419#define FUNCTION "Functionnal_unit::operation_l_sfeq"
420  void operation_l_sfeq        (execute_operation_t * op, execute_register_t * reg, execute_param_t * param)
421  {
422    log_printf(TRACE,Functionnal_unit,FUNCTION,"Operation : l_sfeq");
423
424    Tgeneral_data_t gpr1       = unsigned(param->_size_data,op->_data_ra);
425    Tgeneral_data_t gpr2       = unsigned(param->_size_data,(op->_has_immediat==1)?op->_immediat:op->_data_rb);
426
427    bool            f_out      = (gpr1 == gpr2);
428
429    // Result
430    op->_timing       = param->_timing[op->_type][op->_operation];
431  //op->_data_rd      = 0;
432    op->_data_re      = set_flag(op->_data_re,FLAG_F,f_out);
433    op->_exception    = EXCEPTION_ALU_NONE;
434    op->_no_sequence  = 0;
435  //op->_address      = 0;
436  };
437
438#undef  FUNCTION
439#define FUNCTION "Functionnal_unit::operation_l_sfne"
440  void operation_l_sfne        (execute_operation_t * op, execute_register_t * reg, execute_param_t * param)
441  {
442    log_printf(TRACE,Functionnal_unit,FUNCTION,"Operation : l_sfne");
443
444    Tgeneral_data_t gpr1       = unsigned(param->_size_data,op->_data_ra);
445    Tgeneral_data_t gpr2       = unsigned(param->_size_data,(op->_has_immediat==1)?op->_immediat:op->_data_rb);
446
447    bool            f_out      = (gpr1 != gpr2);
448
449    // Result
450    op->_timing       = param->_timing[op->_type][op->_operation];
451  //op->_data_rd      = 0;
452    op->_data_re      = set_flag(op->_data_re,FLAG_F,f_out);
453    op->_exception    = EXCEPTION_ALU_NONE;
454    op->_no_sequence  = 0;
455  //op->_address      = 0;
456  };
457
458#undef  FUNCTION
459#define FUNCTION "Functionnal_unit::operation_l_sfgeu"
460  void operation_l_sfgeu       (execute_operation_t * op, execute_register_t * reg, execute_param_t * param)
461  {
462    log_printf(TRACE,Functionnal_unit,FUNCTION,"Operation : l_sfgeu");
463
464    Tgeneral_data_t gpr1       = unsigned(param->_size_data,op->_data_ra);
465    Tgeneral_data_t gpr2       = unsigned(param->_size_data,(op->_has_immediat==1)?op->_immediat:op->_data_rb);
466
467    bool            f_out      = (gpr1 >= gpr2);
468
469    // Result
470    op->_timing       = param->_timing[op->_type][op->_operation];
471  //op->_data_rd      = 0;
472    op->_data_re      = set_flag(op->_data_re,FLAG_F,f_out);
473    op->_exception    = EXCEPTION_ALU_NONE;
474    op->_no_sequence  = 0;
475  //op->_address      = 0;
476  };
477
478#undef  FUNCTION
479#define FUNCTION "Functionnal_unit::operation_l_sfgtu"
480  void operation_l_sfgtu       (execute_operation_t * op, execute_register_t * reg, execute_param_t * param)
481  {
482    log_printf(TRACE,Functionnal_unit,FUNCTION,"Operation : l_sfgtu");
483
484    Tgeneral_data_t gpr1       = unsigned(param->_size_data,op->_data_ra);
485    Tgeneral_data_t gpr2       = unsigned(param->_size_data,(op->_has_immediat==1)?op->_immediat:op->_data_rb);
486
487    bool            f_out      = (gpr1 >  gpr2);
488
489    // Result
490    op->_timing       = param->_timing[op->_type][op->_operation];
491  //op->_data_rd      = 0;
492    op->_data_re      = set_flag(op->_data_re,FLAG_F,f_out);
493    op->_exception    = EXCEPTION_ALU_NONE;
494    op->_no_sequence  = 0;
495  //op->_address      = 0;
496  };
497
498#undef  FUNCTION
499#define FUNCTION "Functionnal_unit::operation_l_sfleu"
500  void operation_l_sfleu       (execute_operation_t * op, execute_register_t * reg, execute_param_t * param)
501  {
502    log_printf(TRACE,Functionnal_unit,FUNCTION,"Operation : l_sfleu");
503
504    Tgeneral_data_t gpr1       = unsigned(param->_size_data,op->_data_ra);
505    Tgeneral_data_t gpr2       = unsigned(param->_size_data,(op->_has_immediat==1)?op->_immediat:op->_data_rb);
506
507    bool            f_out      = (gpr1 <= gpr2);
508
509    // Result
510    op->_timing       = param->_timing[op->_type][op->_operation];
511  //op->_data_rd      = 0;
512    op->_data_re      = set_flag(op->_data_re,FLAG_F,f_out);
513    op->_exception    = EXCEPTION_ALU_NONE;
514    op->_no_sequence  = 0;
515  //op->_address      = 0;
516  };
517
518#undef  FUNCTION
519#define FUNCTION "Functionnal_unit::operation_l_sfltu"
520  void operation_l_sfltu       (execute_operation_t * op, execute_register_t * reg, execute_param_t * param)
521  {
522    log_printf(TRACE,Functionnal_unit,FUNCTION,"Operation : l_sfltu");
523
524    Tgeneral_data_t gpr1       = unsigned(param->_size_data,op->_data_ra);
525    Tgeneral_data_t gpr2       = unsigned(param->_size_data,(op->_has_immediat==1)?op->_immediat:op->_data_rb);
526
527    bool            f_out      = (gpr1 <  gpr2);
528
529    // Result
530    op->_timing       = param->_timing[op->_type][op->_operation];
531  //op->_data_rd      = 0;
532    op->_data_re      = set_flag(op->_data_re,FLAG_F,f_out);
533    op->_exception    = EXCEPTION_ALU_NONE;
534    op->_no_sequence  = 0;
535  //op->_address      = 0;
536  };
537
538#undef  FUNCTION
539#define FUNCTION "Functionnal_unit::operation_l_sfges"
540  void operation_l_sfges       (execute_operation_t * op, execute_register_t * reg, execute_param_t * param)
541  {
542    log_printf(TRACE,Functionnal_unit,FUNCTION,"Operation : l_sfges");
543
544    Tgeneral_data_t gpr1       =   op->_data_ra;
545    Tgeneral_data_t gpr2       =   (op->_has_immediat==1)?op->_immediat:op->_data_rb;
546   
547    log_printf(TRACE,Functionnal_unit,FUNCTION," * data_ra  : %.8x",unsigned(param->_size_data,op->_data_ra));
548    log_printf(TRACE,Functionnal_unit,FUNCTION," * data_ras : %.8x",  signed(param->_size_data,op->_data_ra));
549    log_printf(TRACE,Functionnal_unit,FUNCTION," * data_rb  : %.8x",unsigned(param->_size_data,(op->_has_immediat==1)?op->_immediat:op->_data_rb));
550    log_printf(TRACE,Functionnal_unit,FUNCTION," * data_rbs : %.8x",  signed(param->_size_data,(op->_has_immediat==1)?op->_immediat:op->_data_rb));
551   
552    bool            f_out;
553
554    switch (concatenation_bool(sign(param->_size_data,gpr1),sign(param->_size_data,gpr2)))
555      {
556      case 1 /*b01*/ : f_out = 1                               ; break;
557      case 2 /*b10*/ : f_out = 0                               ; break;
558      default        : f_out = signed(param->_size_data,gpr1) >= signed(param->_size_data,gpr2); break;
559      }
560
561    log_printf(TRACE,Functionnal_unit,FUNCTION," * f_out    : %.8x",f_out);
562
563    // Result
564    op->_timing       = param->_timing[op->_type][op->_operation];
565  //op->_data_rd      = 0;
566    op->_data_re      = set_flag(op->_data_re,FLAG_F,f_out);
567    op->_exception    = EXCEPTION_ALU_NONE;
568    op->_no_sequence  = 0;
569  //op->_address      = 0;
570  };
571
572#undef  FUNCTION
573#define FUNCTION "Functionnal_unit::operation_l_sfgts"
574  void operation_l_sfgts       (execute_operation_t * op, execute_register_t * reg, execute_param_t * param)
575  {
576    log_printf(TRACE,Functionnal_unit,FUNCTION,"Operation : l_sfgts");
577
578    Tgeneral_data_t gpr1       = op->_data_ra ;
579    Tgeneral_data_t gpr2       = (op->_has_immediat==1)?op->_immediat:op->_data_rb ;
580
581    bool            f_out;
582
583    switch (concatenation_bool(sign(param->_size_data,gpr1),sign(param->_size_data,gpr2)))
584      {
585      case 1 /*b01*/ : f_out = 1; break;
586      case 2 /*b10*/ : f_out = 0; break;
587      default        : f_out = signed(param->_size_data,gpr1) >  signed(param->_size_data,gpr2); break;
588      }
589
590    // Result
591    op->_timing       = param->_timing[op->_type][op->_operation];
592  //op->_data_rd      = 0;
593    op->_data_re      = set_flag(op->_data_re,FLAG_F,f_out);
594    op->_exception    = EXCEPTION_ALU_NONE;
595    op->_no_sequence  = 0;
596  //op->_address      = 0;
597  };
598
599#undef  FUNCTION
600#define FUNCTION "Functionnal_unit::operation_l_sfles"
601  void operation_l_sfles       (execute_operation_t * op, execute_register_t * reg, execute_param_t * param)
602  {
603    log_printf(TRACE,Functionnal_unit,FUNCTION,"Operation : l_sfles");
604
605    Tgeneral_data_t gpr1       = op->_data_ra ;
606    Tgeneral_data_t gpr2       = (op->_has_immediat==1)?op->_immediat:op->_data_rb ;
607
608    bool            f_out;
609
610    switch (concatenation_bool(sign(param->_size_data,gpr1),sign(param->_size_data,gpr2)))
611      {
612      case 1 /*b01*/ : f_out = 0; break;
613      case 2 /*b10*/ : f_out = 1; break;
614      default        : f_out = signed(param->_size_data,gpr1) <= signed(param->_size_data,gpr2); break;
615      }
616   
617    // Result
618    op->_timing       = param->_timing[op->_type][op->_operation];
619  //op->_data_rd      = 0;
620    op->_data_re      = set_flag(op->_data_re,FLAG_F,f_out);
621    op->_exception    = EXCEPTION_ALU_NONE;
622    op->_no_sequence  = 0;
623  //op->_address      = 0;
624  };
625
626#undef  FUNCTION
627#define FUNCTION "Functionnal_unit::operation_l_sflts"
628  void operation_l_sflts       (execute_operation_t * op, execute_register_t * reg, execute_param_t * param)
629  {
630    log_printf(TRACE,Functionnal_unit,FUNCTION,"Operation : l_sflts");
631
632    Tgeneral_data_t gpr1       = op->_data_ra ;
633    Tgeneral_data_t gpr2       = (op->_has_immediat==1)?op->_immediat:op->_data_rb;
634
635    bool            f_out;
636
637    switch (concatenation_bool(sign(param->_size_data,gpr1),sign(param->_size_data,gpr2)))
638      {
639      case 1 /*b01*/ : f_out = 0; break;
640      case 2 /*b10*/ : f_out = 1; break;
641      default        : f_out = signed(param->_size_data,gpr1) <  signed(param->_size_data,gpr2); break;
642      }
643
644    // Result
645    op->_timing       = param->_timing[op->_type][op->_operation];
646  //op->_data_rd      = 0;
647    op->_data_re      = set_flag(op->_data_re,FLAG_F,f_out);
648    op->_exception    = EXCEPTION_ALU_NONE;
649    op->_no_sequence  = 0;
650  //op->_address      = 0;
651  };
652
653#undef  FUNCTION
654#define FUNCTION "Functionnal_unit::operation_l_mtspr"
655  void operation_l_mtspr       (execute_operation_t * op, execute_register_t * reg, execute_param_t * param)
656  {
657    log_printf(TRACE,Functionnal_unit,FUNCTION,"Operation : l_mtspr");
658
659    Tgeneral_data_t imm        = unsigned(param->_size_data,op->_immediat);
660    Tgeneral_data_t gpr1       = unsigned(param->_size_data,op->_data_ra);
661    Tgeneral_data_t gpr2       = unsigned(param->_size_data,op->_data_rb);
662    Tgeneral_data_t addr       = range<Tgeneral_data_t>(gpr1|imm,16);
663
664    Texception_t    exception;
665
666    // HACK : use the field num_reg_re to pass the SM and SUMRA flag.
667    Tcontrol_t      flag_SM    = get_flag(op->_num_reg_re, 0x1);
668    Tcontrol_t      flag_SUMRA = get_flag(op->_num_reg_re, 0x2);
669
670    spr_address_t   spr_addr   = reg->_spr_access_mode->translate_address(addr);
671
672    // Test if this group is implemented in this functionnal_unit
673    if (reg->_spr_access_mode->valid(spr_addr))
674      {
675        if (reg->_spr_access_mode->write(spr_addr, flag_SM, flag_SUMRA))
676          {
677            reg->_i_write_spr         = true;
678            reg->_access_num_group    = spr_addr._group;
679            reg->_access_num_register = spr_addr._register;
680            reg->_spr_old             = reg->_spr[spr_addr._group][spr_addr._register];
681            reg->_spr[spr_addr._group][spr_addr._register] = gpr2;
682
683            exception = EXCEPTION_ALU_NONE;
684          }
685        else
686          {
687            exception = EXCEPTION_ALU_SPR_ACCESS_INVALID;
688          }
689      }
690    else
691      {
692        exception = EXCEPTION_ALU_SPR_ACCESS_MUST_WRITE;
693      }
694   
695    // Result
696    op->_timing       = param->_timing[op->_type][op->_operation];
697    op->_data_rd      = gpr2; // data_rb
698  //op->_data_re      = 0;
699    op->_exception    = exception;
700    op->_no_sequence  = 0;
701    op->_address      = addr; // data_ra or imm
702  };
703
704#undef  FUNCTION
705#define FUNCTION "Functionnal_unit::operation_l_mfspr"
706  void operation_l_mfspr       (execute_operation_t * op, execute_register_t * reg, execute_param_t * param)
707  {
708    log_printf(TRACE,Functionnal_unit,FUNCTION,"Operation : l_mfspr");
709
710    Tgeneral_data_t imm        = unsigned(param->_size_data,op->_immediat);
711    Tgeneral_data_t gpr1       = unsigned(param->_size_data,op->_data_ra);
712    Tgeneral_data_t gpr2       = 0;
713    Tgeneral_data_t addr       = range<Tgeneral_data_t>(gpr1|imm,16);
714
715    Texception_t    exception;
716
717    // HACK : use the field num_reg_re to pass the SM and SUMRA flag.
718    Tcontrol_t      flag_SM    = get_flag(op->_num_reg_re, 0x1);
719    Tcontrol_t      flag_SUMRA = get_flag(op->_num_reg_re, 0x2);
720
721    spr_address_t   spr_addr   = reg->_spr_access_mode->translate_address(addr);
722   
723    // Test if this group is implemented in this functionnal_unit
724    if (reg->_spr_access_mode->valid(spr_addr))
725      {
726        if (reg->_spr_access_mode->read(spr_addr, flag_SM, flag_SUMRA))
727          {
728            reg->_i_read_spr          = true;
729            reg->_access_num_group    = spr_addr._group;
730            reg->_access_num_register = spr_addr._register;
731           
732            gpr2 = reg->_spr[spr_addr._group][spr_addr._register];
733
734            exception = EXCEPTION_ALU_NONE;
735          }
736        else
737          {
738            exception = EXCEPTION_ALU_SPR_ACCESS_INVALID;
739          }
740      }
741    else
742      {
743        exception = EXCEPTION_ALU_SPR_ACCESS_MUST_READ;
744      }
745
746    // Result
747    op->_timing       = param->_timing[op->_type][op->_operation];
748    op->_write_rd     = (exception == EXCEPTION_ALU_NONE);
749    op->_data_rd      = gpr2; // spr
750  //op->_data_re      = 0;
751    op->_exception    = exception;
752    op->_no_sequence  = 0;
753    op->_address      = addr; // data_ra or imm
754  };
755
756#undef  FUNCTION
757#define FUNCTION "Functionnal_unit::operation_l_macrc"
758  void operation_l_macrc        (execute_operation_t * op, execute_register_t * reg, execute_param_t * param)
759  {
760    log_printf(TRACE,Functionnal_unit,FUNCTION,"Operation : l_macrc");
761
762    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));
763
764    reg->_spr[GROUP_MAC][SPR_MACLO] = 0;
765    reg->_spr[GROUP_MAC][SPR_MACHI] = 0;
766
767    // Result
768    op->_timing       = param->_timing[op->_type][op->_operation];
769    op->_data_rd      = gpr;
770  //op->_data_re      = 0;
771    op->_exception    = EXCEPTION_ALU_NONE;
772    op->_no_sequence  = 0;
773  //op->_address      = 0;
774  };
775
776#undef  FUNCTION
777#define FUNCTION "Functionnal_unit::operation_l_mac"
778  void operation_l_mac          (execute_operation_t * op, execute_register_t * reg, execute_param_t * param)
779  {
780    log_printf(TRACE,Functionnal_unit,FUNCTION,"Operation : l_mac");
781
782    Tgeneral_data_t gpr1 = unsigned(param->_size_data,op->_data_ra);
783    Tgeneral_data_t gpr2 = unsigned(param->_size_data,(op->_has_immediat==1)?op->_immediat:op->_data_rb);
784    uint64_t        temp = range<uint64_t>(gpr1 * gpr2, 32);
785
786    temp = ((static_cast<uint64_t>(reg->_spr[GROUP_MAC][SPR_MACHI]) << 32) | static_cast<uint64_t>(reg->_spr[GROUP_MAC][SPR_MACLO])) + temp;
787
788    reg->_spr[GROUP_MAC][SPR_MACLO] = range<Tgeneral_data_t>(temp    ,32);
789    reg->_spr[GROUP_MAC][SPR_MACHI] = range<Tgeneral_data_t>(temp>>32,32);
790   
791    // Result
792    op->_timing       = param->_timing[op->_type][op->_operation];
793  //op->_data_rd      = 0;
794  //op->_data_re      = 0;
795    op->_exception    = EXCEPTION_ALU_NONE;
796    op->_no_sequence  = 0;
797  //op->_address      = 0;
798  };
799
800#undef  FUNCTION
801#define FUNCTION "Functionnal_unit::operation_l_msb"
802  void operation_l_msb          (execute_operation_t * op, execute_register_t * reg, execute_param_t * param)
803  {
804    log_printf(TRACE,Functionnal_unit,FUNCTION,"Operation : l_msb");
805
806    Tgeneral_data_t gpr1 = unsigned(param->_size_data,op->_data_ra);
807    Tgeneral_data_t gpr2 = unsigned(param->_size_data,(op->_has_immediat==1)?op->_immediat:op->_data_rb);
808    uint64_t        temp = range<uint64_t>(gpr1 * gpr2, 32);
809
810    temp = ((static_cast<uint64_t>(reg->_spr[GROUP_MAC][SPR_MACHI]) << 32) | static_cast<uint64_t>(reg->_spr[GROUP_MAC][SPR_MACLO])) - temp;
811
812    reg->_spr[GROUP_MAC][SPR_MACLO] = range<Tgeneral_data_t>(temp    ,32);
813    reg->_spr[GROUP_MAC][SPR_MACHI] = range<Tgeneral_data_t>(temp>>32,32);
814   
815    // Result
816    op->_timing       = param->_timing[op->_type][op->_operation];
817  //op->_data_rd      = 0;
818  //op->_data_re      = 0;
819    op->_exception    = EXCEPTION_ALU_NONE;
820    op->_no_sequence  = 0;
821  //op->_address      = 0;
822  };
823
824}; // end namespace functionnal_unit
825}; // end namespace execute_unit
826}; // end namespace multi_execute_unit
827}; // end namespace execute_loop
828}; // end namespace multi_execute_loop
829}; // end namespace core
830}; // end namespace behavioural
831}; // end namespace morpheo             
832#endif
Note: See TracBrowser for help on using the repository browser.