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

Last change on this file since 100 was 100, checked in by rosiere, 15 years ago

1) Bug fix (Operation, Instruction)
2) Modif Return Address Stack
3) Add Soft Test
4) Add Soc Test
  • Property svn:keywords set to Id
File size: 31.4 KB
Line 
1#ifdef SYSTEMC
2/*
3 * $Id: Operation.cpp 100 2009-01-08 13:06:27Z 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<<2; // add "00"
258  //op->_data_re      = 0;
259    op->_exception    = EXCEPTION_ALU_NONE;
260    op->_no_sequence  = 1;
261    op->_address      = gpr>>2; // del "00"
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.