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

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

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