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

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

Almost complete design
with Test and test platform
  • Property svn:keywords set to Id
File size: 31.1 KB
Line 
1#ifdef SYSTEMC
2/*
3 * $Id: Operation.cpp 88 2008-12-10 18:31:39Z 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    // Result
229    op->_timing       = param->_timing[op->_type][op->_operation];
230  //op->_data_rd      = 0;
231  //op->_data_re      = 0;
232    op->_exception    = EXCEPTION_ALU_NONE;
233    op->_no_sequence  = f_in == 0;
234    op->_address      = imm;
235  };
236
237#undef  FUNCTION
238#define FUNCTION "Functionnal_unit::operation_l_jalr"
239  void operation_l_jalr        (execute_operation_t * op, execute_register_t * reg, execute_param_t * param)
240  {
241    log_printf(TRACE,Functionnal_unit,FUNCTION,"Operation : l_jalr");
242    // jal  : has_imm = 1, write_rd = 1, read_rb = 0
243    // jalr : has_imm = 1, write_rd = 1, read_rb = 1
244    // jr   : has_imm = 0, write_rd = 0, read_rb = 1
245
246
247    Tgeneral_data_t gpr        = unsigned(param->_size_data,op->_data_rb);
248    Tgeneral_data_t imm        = unsigned(param->_size_data,op->_immediat);
249
250    // Result
251    op->_timing       = param->_timing[op->_type][op->_operation];
252    op->_data_rd      = imm;
253  //op->_data_re      = 0;
254    op->_exception    = EXCEPTION_ALU_NONE;
255    op->_no_sequence  = 1;
256    op->_address      = gpr;
257  };
258
259#undef  FUNCTION
260#define FUNCTION "Functionnal_unit::operation_l_extend_s"
261  void operation_l_extend_s    (execute_operation_t * op, execute_register_t * reg, execute_param_t * param)
262  {
263    log_printf(TRACE,Functionnal_unit,FUNCTION,"Operation : l_extend_s");
264
265    Tgeneral_data_t imm        = unsigned(param->_size_data,op->_immediat);
266    Tgeneral_data_t gpr1       = unsigned(param->_size_data,op->_data_ra);
267    Tgeneral_data_t gpr2       = extend<Tgeneral_data_t>(param->_size_data, gpr1, true , imm);
268
269    // Result
270    op->_timing       = param->_timing[op->_type][op->_operation];
271    op->_data_rd      = gpr2;
272  //op->_data_re      = 0;
273    op->_exception    = EXCEPTION_ALU_NONE;
274    op->_no_sequence  = 0;
275  //op->_address      = 0;
276  };
277
278#undef  FUNCTION
279#define FUNCTION "Functionnal_unit::operation_l_extend_z"
280  void operation_l_extend_z    (execute_operation_t * op, execute_register_t * reg, execute_param_t * param)
281  {
282    log_printf(TRACE,Functionnal_unit,FUNCTION,"Operation : l_extend_z");
283
284    Tgeneral_data_t imm        = unsigned(param->_size_data,op->_immediat);
285    Tgeneral_data_t gpr1       = unsigned(param->_size_data,op->_data_ra);
286    Tgeneral_data_t gpr2       = extend<Tgeneral_data_t>(param->_size_data, gpr1, false , imm);
287
288    // Result
289    op->_timing       = param->_timing[op->_type][op->_operation];
290    op->_data_rd      = gpr2;
291  //op->_data_re      = 0;
292    op->_exception    = EXCEPTION_ALU_NONE;
293    op->_no_sequence  = 0;
294  //op->_address      = 0;
295  };
296
297#undef  FUNCTION
298#define FUNCTION "Functionnal_unit::operation_l_sll"
299  void operation_l_sll         (execute_operation_t * op, execute_register_t * reg, execute_param_t * param)
300  {
301    log_printf(TRACE,Functionnal_unit,FUNCTION,"Operation : l_sll");
302
303    Tgeneral_data_t gpr1       = unsigned(param->_size_data,op->_data_ra);
304    Tgeneral_data_t gpr2       = param->_mask_shift & unsigned(param->_size_data,(op->_has_immediat==1)?op->_immediat:op->_data_rb);
305    Tgeneral_data_t gpr3       = shift_logic_left<Tgeneral_data_t>(param->_size_data, gpr1, gpr2);
306
307    // Result
308    op->_timing       = param->_timing[op->_type][op->_operation];
309    op->_data_rd      = gpr3;
310  //op->_data_re      = 0;
311    op->_exception    = EXCEPTION_ALU_NONE;
312    op->_no_sequence  = 0;
313  //op->_address      = 0;
314  };
315
316#undef  FUNCTION
317#define FUNCTION "Functionnal_unit::operation_l_srl"
318  void operation_l_srl         (execute_operation_t * op, execute_register_t * reg, execute_param_t * param)
319  {
320    log_printf(TRACE,Functionnal_unit,FUNCTION,"Operation : l_srl");
321
322    Tgeneral_data_t gpr1       = unsigned(param->_size_data,op->_data_ra);
323    Tgeneral_data_t gpr2       = param->_mask_shift & unsigned(param->_size_data,(op->_has_immediat==1)?op->_immediat:op->_data_rb);
324    Tgeneral_data_t gpr3       = shift_logic_right<Tgeneral_data_t>(param->_size_data, gpr1, gpr2);
325
326    // Result
327    op->_timing       = param->_timing[op->_type][op->_operation];
328    op->_data_rd      = gpr3;
329  //op->_data_re      = 0;
330    op->_exception    = EXCEPTION_ALU_NONE;
331    op->_no_sequence  = 0;
332  //op->_address      = 0;
333  };
334
335#undef  FUNCTION
336#define FUNCTION "Functionnal_unit::operation_l_sra"
337  void operation_l_sra         (execute_operation_t * op, execute_register_t * reg, execute_param_t * param)
338  {
339    log_printf(TRACE,Functionnal_unit,FUNCTION,"Operation : l_sra");
340
341    Tgeneral_data_t gpr1       = unsigned(param->_size_data,op->_data_ra);
342    Tgeneral_data_t gpr2       = param->_mask_shift & unsigned(param->_size_data,(op->_has_immediat==1)?op->_immediat:op->_data_rb);
343    Tgeneral_data_t gpr3       = shift_arithmetic_right<Tgeneral_data_t>(param->_size_data, gpr1, gpr2);
344
345    // Result
346    op->_timing       = param->_timing[op->_type][op->_operation];
347    op->_data_rd      = gpr3;
348  //op->_data_re      = 0;
349    op->_exception    = EXCEPTION_ALU_NONE;
350    op->_no_sequence  = 0;
351  //op->_address      = 0;
352  };
353
354#undef  FUNCTION
355#define FUNCTION "Functionnal_unit::operation_l_ror"
356  void operation_l_ror         (execute_operation_t * op, execute_register_t * reg, execute_param_t * param)
357  {
358    log_printf(TRACE,Functionnal_unit,FUNCTION,"Operation : l_ror");
359
360    Tgeneral_data_t gpr1       = unsigned(param->_size_data,op->_data_ra);
361    Tgeneral_data_t gpr2       = param->_mask_shift & unsigned(param->_size_data,(op->_has_immediat==1)?op->_immediat:op->_data_rb);
362    Tgeneral_data_t gpr3       = rotate_right<Tgeneral_data_t>(param->_size_data, gpr1, gpr2);
363
364    // Result
365    op->_timing       = param->_timing[op->_type][op->_operation];
366    op->_data_rd      = gpr3;
367  //op->_data_re      = 0;
368    op->_exception    = EXCEPTION_ALU_NONE;
369    op->_no_sequence  = 0;
370  //op->_address      = 0;
371  };
372
373#undef  FUNCTION
374#define FUNCTION "Functionnal_unit::operation_l_ff1"
375  void operation_l_ff1         (execute_operation_t * op, execute_register_t * reg, execute_param_t * param)
376  {
377    log_printf(TRACE,Functionnal_unit,FUNCTION,"Operation : l_ff1");
378
379    Tgeneral_data_t gpr        = unsigned(param->_size_data,op->_data_ra);
380    Tgeneral_data_t index;
381
382    for (index=0; (index<param->_size_data) and (((gpr>>index)&1)!= 1); index++);
383
384    // Result
385    op->_timing       = param->_timing[op->_type][op->_operation];
386    op->_data_rd      = (index==param->_size_data)?0:(index+1);
387  //op->_data_re      = 0;
388    op->_exception    = EXCEPTION_ALU_NONE;
389    op->_no_sequence  = 0;
390  //op->_address      = 0;
391  };
392
393#undef  FUNCTION
394#define FUNCTION "Functionnal_unit::operation_l_fl1"
395  void operation_l_fl1         (execute_operation_t * op, execute_register_t * reg, execute_param_t * param)
396  {
397    log_printf(TRACE,Functionnal_unit,FUNCTION,"Operation : l_fl1");
398
399    Tgeneral_data_t gpr        = unsigned(param->_size_data,op->_data_ra);
400    Tgeneral_data_t index;
401
402    for (index=param->_size_data; (index>0) and (((gpr>>(index-1))&1)!= 1); index--);
403
404    // Result
405    op->_timing       = param->_timing[op->_type][op->_operation];
406    op->_data_rd      = index;
407  //op->_data_re      = 0;
408    op->_exception    = EXCEPTION_ALU_NONE;
409    op->_no_sequence  = 0;
410  //op->_address      = 0;
411  };
412
413#undef  FUNCTION
414#define FUNCTION "Functionnal_unit::operation_l_sfeq"
415  void operation_l_sfeq        (execute_operation_t * op, execute_register_t * reg, execute_param_t * param)
416  {
417    log_printf(TRACE,Functionnal_unit,FUNCTION,"Operation : l_sfeq");
418
419    Tgeneral_data_t gpr1       = unsigned(param->_size_data,op->_data_ra);
420    Tgeneral_data_t gpr2       = unsigned(param->_size_data,(op->_has_immediat==1)?op->_immediat:op->_data_rb);
421
422    bool            f_out      = (gpr1 == gpr2);
423
424    // Result
425    op->_timing       = param->_timing[op->_type][op->_operation];
426  //op->_data_rd      = 0;
427    op->_data_re      = set_flag(op->_data_re,FLAG_F,f_out);
428    op->_exception    = EXCEPTION_ALU_NONE;
429    op->_no_sequence  = 0;
430  //op->_address      = 0;
431  };
432
433#undef  FUNCTION
434#define FUNCTION "Functionnal_unit::operation_l_sfne"
435  void operation_l_sfne        (execute_operation_t * op, execute_register_t * reg, execute_param_t * param)
436  {
437    log_printf(TRACE,Functionnal_unit,FUNCTION,"Operation : l_sfne");
438
439    Tgeneral_data_t gpr1       = unsigned(param->_size_data,op->_data_ra);
440    Tgeneral_data_t gpr2       = unsigned(param->_size_data,(op->_has_immediat==1)?op->_immediat:op->_data_rb);
441
442    bool            f_out      = (gpr1 != gpr2);
443
444    // Result
445    op->_timing       = param->_timing[op->_type][op->_operation];
446  //op->_data_rd      = 0;
447    op->_data_re      = set_flag(op->_data_re,FLAG_F,f_out);
448    op->_exception    = EXCEPTION_ALU_NONE;
449    op->_no_sequence  = 0;
450  //op->_address      = 0;
451  };
452
453#undef  FUNCTION
454#define FUNCTION "Functionnal_unit::operation_l_sfgeu"
455  void operation_l_sfgeu       (execute_operation_t * op, execute_register_t * reg, execute_param_t * param)
456  {
457    log_printf(TRACE,Functionnal_unit,FUNCTION,"Operation : l_sfgeu");
458
459    Tgeneral_data_t gpr1       = unsigned(param->_size_data,op->_data_ra);
460    Tgeneral_data_t gpr2       = unsigned(param->_size_data,(op->_has_immediat==1)?op->_immediat:op->_data_rb);
461
462    bool            f_out      = (gpr1 >= gpr2);
463
464    // Result
465    op->_timing       = param->_timing[op->_type][op->_operation];
466  //op->_data_rd      = 0;
467    op->_data_re      = set_flag(op->_data_re,FLAG_F,f_out);
468    op->_exception    = EXCEPTION_ALU_NONE;
469    op->_no_sequence  = 0;
470  //op->_address      = 0;
471  };
472
473#undef  FUNCTION
474#define FUNCTION "Functionnal_unit::operation_l_sfgtu"
475  void operation_l_sfgtu       (execute_operation_t * op, execute_register_t * reg, execute_param_t * param)
476  {
477    log_printf(TRACE,Functionnal_unit,FUNCTION,"Operation : l_sfgtu");
478
479    Tgeneral_data_t gpr1       = unsigned(param->_size_data,op->_data_ra);
480    Tgeneral_data_t gpr2       = unsigned(param->_size_data,(op->_has_immediat==1)?op->_immediat:op->_data_rb);
481
482    bool            f_out      = (gpr1 >  gpr2);
483
484    // Result
485    op->_timing       = param->_timing[op->_type][op->_operation];
486  //op->_data_rd      = 0;
487    op->_data_re      = set_flag(op->_data_re,FLAG_F,f_out);
488    op->_exception    = EXCEPTION_ALU_NONE;
489    op->_no_sequence  = 0;
490  //op->_address      = 0;
491  };
492
493#undef  FUNCTION
494#define FUNCTION "Functionnal_unit::operation_l_sfleu"
495  void operation_l_sfleu       (execute_operation_t * op, execute_register_t * reg, execute_param_t * param)
496  {
497    log_printf(TRACE,Functionnal_unit,FUNCTION,"Operation : l_sfleu");
498
499    Tgeneral_data_t gpr1       = unsigned(param->_size_data,op->_data_ra);
500    Tgeneral_data_t gpr2       = unsigned(param->_size_data,(op->_has_immediat==1)?op->_immediat:op->_data_rb);
501
502    bool            f_out      = (gpr1 <= gpr2);
503
504    // Result
505    op->_timing       = param->_timing[op->_type][op->_operation];
506  //op->_data_rd      = 0;
507    op->_data_re      = set_flag(op->_data_re,FLAG_F,f_out);
508    op->_exception    = EXCEPTION_ALU_NONE;
509    op->_no_sequence  = 0;
510  //op->_address      = 0;
511  };
512
513#undef  FUNCTION
514#define FUNCTION "Functionnal_unit::operation_l_sfltu"
515  void operation_l_sfltu       (execute_operation_t * op, execute_register_t * reg, execute_param_t * param)
516  {
517    log_printf(TRACE,Functionnal_unit,FUNCTION,"Operation : l_sfltu");
518
519    Tgeneral_data_t gpr1       = unsigned(param->_size_data,op->_data_ra);
520    Tgeneral_data_t gpr2       = unsigned(param->_size_data,(op->_has_immediat==1)?op->_immediat:op->_data_rb);
521
522    bool            f_out      = (gpr1 <  gpr2);
523
524    // Result
525    op->_timing       = param->_timing[op->_type][op->_operation];
526  //op->_data_rd      = 0;
527    op->_data_re      = set_flag(op->_data_re,FLAG_F,f_out);
528    op->_exception    = EXCEPTION_ALU_NONE;
529    op->_no_sequence  = 0;
530  //op->_address      = 0;
531  };
532
533#undef  FUNCTION
534#define FUNCTION "Functionnal_unit::operation_l_sfges"
535  void operation_l_sfges       (execute_operation_t * op, execute_register_t * reg, execute_param_t * param)
536  {
537    log_printf(TRACE,Functionnal_unit,FUNCTION,"Operation : l_sfges");
538
539    Tgeneral_data_t gpr1       =   op->_data_ra;
540    Tgeneral_data_t gpr2       =   (op->_has_immediat==1)?op->_immediat:op->_data_rb;
541   
542    log_printf(TRACE,Functionnal_unit,FUNCTION," * data_ra  : %.8x",unsigned(param->_size_data,op->_data_ra));
543    log_printf(TRACE,Functionnal_unit,FUNCTION," * data_ras : %.8x",  signed(param->_size_data,op->_data_ra));
544    log_printf(TRACE,Functionnal_unit,FUNCTION," * data_rb  : %.8x",unsigned(param->_size_data,(op->_has_immediat==1)?op->_immediat:op->_data_rb));
545    log_printf(TRACE,Functionnal_unit,FUNCTION," * data_rbs : %.8x",  signed(param->_size_data,(op->_has_immediat==1)?op->_immediat:op->_data_rb));
546   
547    bool            f_out;
548
549    switch (concatenation_bool(sign(param->_size_data,gpr1),sign(param->_size_data,gpr2)))
550      {
551      case 1 /*b01*/ : f_out = 1                               ; break;
552      case 2 /*b10*/ : f_out = 0                               ; break;
553      default        : f_out = signed(param->_size_data,gpr1) >= signed(param->_size_data,gpr2); break;
554      }
555
556    log_printf(TRACE,Functionnal_unit,FUNCTION," * f_out    : %.8x",f_out);
557
558    // Result
559    op->_timing       = param->_timing[op->_type][op->_operation];
560  //op->_data_rd      = 0;
561    op->_data_re      = set_flag(op->_data_re,FLAG_F,f_out);
562    op->_exception    = EXCEPTION_ALU_NONE;
563    op->_no_sequence  = 0;
564  //op->_address      = 0;
565  };
566
567#undef  FUNCTION
568#define FUNCTION "Functionnal_unit::operation_l_sfgts"
569  void operation_l_sfgts       (execute_operation_t * op, execute_register_t * reg, execute_param_t * param)
570  {
571    log_printf(TRACE,Functionnal_unit,FUNCTION,"Operation : l_sfgts");
572
573    Tgeneral_data_t gpr1       = op->_data_ra ;
574    Tgeneral_data_t gpr2       = (op->_has_immediat==1)?op->_immediat:op->_data_rb ;
575
576    bool            f_out;
577
578    switch (concatenation_bool(sign(param->_size_data,gpr1),sign(param->_size_data,gpr2)))
579      {
580      case 1 /*b01*/ : f_out = 1; break;
581      case 2 /*b10*/ : f_out = 0; break;
582      default        : f_out = signed(param->_size_data,gpr1) >  signed(param->_size_data,gpr2); break;
583      }
584
585    // Result
586    op->_timing       = param->_timing[op->_type][op->_operation];
587  //op->_data_rd      = 0;
588    op->_data_re      = set_flag(op->_data_re,FLAG_F,f_out);
589    op->_exception    = EXCEPTION_ALU_NONE;
590    op->_no_sequence  = 0;
591  //op->_address      = 0;
592  };
593
594#undef  FUNCTION
595#define FUNCTION "Functionnal_unit::operation_l_sfles"
596  void operation_l_sfles       (execute_operation_t * op, execute_register_t * reg, execute_param_t * param)
597  {
598    log_printf(TRACE,Functionnal_unit,FUNCTION,"Operation : l_sfles");
599
600    Tgeneral_data_t gpr1       = op->_data_ra ;
601    Tgeneral_data_t gpr2       = (op->_has_immediat==1)?op->_immediat:op->_data_rb ;
602
603    bool            f_out;
604
605    switch (concatenation_bool(sign(param->_size_data,gpr1),sign(param->_size_data,gpr2)))
606      {
607      case 1 /*b01*/ : f_out = 0; break;
608      case 2 /*b10*/ : f_out = 1; break;
609      default        : f_out = signed(param->_size_data,gpr1) <= signed(param->_size_data,gpr2); break;
610      }
611   
612    // Result
613    op->_timing       = param->_timing[op->_type][op->_operation];
614  //op->_data_rd      = 0;
615    op->_data_re      = set_flag(op->_data_re,FLAG_F,f_out);
616    op->_exception    = EXCEPTION_ALU_NONE;
617    op->_no_sequence  = 0;
618  //op->_address      = 0;
619  };
620
621#undef  FUNCTION
622#define FUNCTION "Functionnal_unit::operation_l_sflts"
623  void operation_l_sflts       (execute_operation_t * op, execute_register_t * reg, execute_param_t * param)
624  {
625    log_printf(TRACE,Functionnal_unit,FUNCTION,"Operation : l_sflts");
626
627    Tgeneral_data_t gpr1       = op->_data_ra ;
628    Tgeneral_data_t gpr2       = (op->_has_immediat==1)?op->_immediat:op->_data_rb;
629
630    bool            f_out;
631
632    switch (concatenation_bool(sign(param->_size_data,gpr1),sign(param->_size_data,gpr2)))
633      {
634      case 1 /*b01*/ : f_out = 0; break;
635      case 2 /*b10*/ : f_out = 1; break;
636      default        : f_out = signed(param->_size_data,gpr1) <  signed(param->_size_data,gpr2); break;
637      }
638
639    // Result
640    op->_timing       = param->_timing[op->_type][op->_operation];
641  //op->_data_rd      = 0;
642    op->_data_re      = set_flag(op->_data_re,FLAG_F,f_out);
643    op->_exception    = EXCEPTION_ALU_NONE;
644    op->_no_sequence  = 0;
645  //op->_address      = 0;
646  };
647
648#undef  FUNCTION
649#define FUNCTION "Functionnal_unit::operation_l_mtspr"
650  void operation_l_mtspr       (execute_operation_t * op, execute_register_t * reg, execute_param_t * param)
651  {
652    log_printf(TRACE,Functionnal_unit,FUNCTION,"Operation : l_mtspr");
653
654    Tgeneral_data_t imm        = unsigned(param->_size_data,op->_immediat);
655    Tgeneral_data_t gpr1       = unsigned(param->_size_data,op->_data_ra);
656    Tgeneral_data_t gpr2       = unsigned(param->_size_data,op->_data_rb);
657    Tgeneral_data_t addr       = range<Tgeneral_data_t>(gpr1|imm,16);
658
659    Texception_t    exception;
660
661    // HACK : use the field num_reg_re to pass the SM and SUMRA flag.
662    Tcontrol_t      flag_SM    = get_flag(op->_num_reg_re, 0x1);
663    Tcontrol_t      flag_SUMRA = get_flag(op->_num_reg_re, 0x2);
664
665    spr_address_t   spr_addr   = reg->_spr_access_mode->translate_address(addr);
666   
667    // Test if this group is implemented in this functionnal_unit
668    if (reg->_spr_access_mode->valid(spr_addr))
669      {
670        if (reg->_spr_access_mode->write(spr_addr, flag_SM, flag_SUMRA))
671          {
672            reg->_i_write_spr         = true;
673            reg->_access_num_group    = spr_addr._group;
674            reg->_access_num_register = spr_addr._register;
675            reg->_spr_old             = reg->_spr[spr_addr._group][spr_addr._register];
676            reg->_spr[spr_addr._group][spr_addr._register] = gpr2;
677
678            exception = EXCEPTION_ALU_NONE;
679          }
680        else
681          {
682            exception = EXCEPTION_ALU_SPR_ACCESS_INVALID;
683          }
684      }
685    else
686      {
687        exception = EXCEPTION_ALU_SPR_ACCESS_MUST_WRITE;
688      }
689   
690    // Result
691    op->_timing       = param->_timing[op->_type][op->_operation];
692    op->_data_rd      = gpr2; // data_rb
693  //op->_data_re      = 0;
694    op->_exception    = exception;
695    op->_no_sequence  = 0;
696    op->_address      = addr; // data_ra or imm
697  };
698
699#undef  FUNCTION
700#define FUNCTION "Functionnal_unit::operation_l_mfspr"
701  void operation_l_mfspr       (execute_operation_t * op, execute_register_t * reg, execute_param_t * param)
702  {
703    log_printf(TRACE,Functionnal_unit,FUNCTION,"Operation : l_mfspr");
704
705    Tgeneral_data_t imm        = unsigned(param->_size_data,op->_immediat);
706    Tgeneral_data_t gpr1       = unsigned(param->_size_data,op->_data_ra);
707    Tgeneral_data_t gpr2       = 0;
708    Tgeneral_data_t addr       = range<Tgeneral_data_t>(gpr1|imm,16);
709
710    Texception_t    exception;
711
712    // HACK : use the field num_reg_re to pass the SM and SUMRA flag.
713    Tcontrol_t      flag_SM    = get_flag(op->_num_reg_re, 0x1);
714    Tcontrol_t      flag_SUMRA = get_flag(op->_num_reg_re, 0x2);
715
716    spr_address_t   spr_addr   = reg->_spr_access_mode->translate_address(addr);
717   
718    // Test if this group is implemented in this functionnal_unit
719    if (reg->_spr_access_mode->valid(spr_addr))
720      {
721        if (reg->_spr_access_mode->read(spr_addr, flag_SM, flag_SUMRA))
722          {
723            reg->_i_read_spr          = true;
724            reg->_access_num_group    = spr_addr._group;
725            reg->_access_num_register = spr_addr._register;
726           
727            gpr2 = reg->_spr[spr_addr._group][spr_addr._register];
728
729            exception = EXCEPTION_ALU_NONE;
730          }
731        else
732          {
733            exception = EXCEPTION_ALU_SPR_ACCESS_INVALID;
734          }
735      }
736    else
737      {
738        exception = EXCEPTION_ALU_SPR_ACCESS_MUST_READ;
739      }
740
741    // Result
742    op->_timing       = param->_timing[op->_type][op->_operation];
743    op->_write_rd     = (exception == EXCEPTION_ALU_NONE);
744    op->_data_rd      = gpr2; // spr
745  //op->_data_re      = 0;
746    op->_exception    = exception;
747    op->_no_sequence  = 0;
748    op->_address      = addr; // data_ra or imm
749  };
750
751#undef  FUNCTION
752#define FUNCTION "Functionnal_unit::operation_l_macrc"
753  void operation_l_macrc        (execute_operation_t * op, execute_register_t * reg, execute_param_t * param)
754  {
755    log_printf(TRACE,Functionnal_unit,FUNCTION,"Operation : l_macrc");
756
757    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));
758
759    reg->_spr[GROUP_MAC][SPR_MACLO] = 0;
760    reg->_spr[GROUP_MAC][SPR_MACHI] = 0;
761
762    // Result
763    op->_timing       = param->_timing[op->_type][op->_operation];
764    op->_data_rd      = gpr;
765  //op->_data_re      = 0;
766    op->_exception    = EXCEPTION_ALU_NONE;
767    op->_no_sequence  = 0;
768  //op->_address      = 0;
769  };
770
771#undef  FUNCTION
772#define FUNCTION "Functionnal_unit::operation_l_mac"
773  void operation_l_mac          (execute_operation_t * op, execute_register_t * reg, execute_param_t * param)
774  {
775    log_printf(TRACE,Functionnal_unit,FUNCTION,"Operation : l_mac");
776
777    Tgeneral_data_t gpr1 = unsigned(param->_size_data,op->_data_ra);
778    Tgeneral_data_t gpr2 = unsigned(param->_size_data,(op->_has_immediat==1)?op->_immediat:op->_data_rb);
779    uint64_t        temp = range<uint64_t>(gpr1 * gpr2, 32);
780
781    temp = ((static_cast<uint64_t>(reg->_spr[GROUP_MAC][SPR_MACHI]) << 32) | static_cast<uint64_t>(reg->_spr[GROUP_MAC][SPR_MACLO])) + temp;
782
783    reg->_spr[GROUP_MAC][SPR_MACLO] = range<Tgeneral_data_t>(temp    ,32);
784    reg->_spr[GROUP_MAC][SPR_MACHI] = range<Tgeneral_data_t>(temp>>32,32);
785   
786    // Result
787    op->_timing       = param->_timing[op->_type][op->_operation];
788  //op->_data_rd      = 0;
789  //op->_data_re      = 0;
790    op->_exception    = EXCEPTION_ALU_NONE;
791    op->_no_sequence  = 0;
792  //op->_address      = 0;
793  };
794
795#undef  FUNCTION
796#define FUNCTION "Functionnal_unit::operation_l_msb"
797  void operation_l_msb          (execute_operation_t * op, execute_register_t * reg, execute_param_t * param)
798  {
799    log_printf(TRACE,Functionnal_unit,FUNCTION,"Operation : l_msb");
800
801    Tgeneral_data_t gpr1 = unsigned(param->_size_data,op->_data_ra);
802    Tgeneral_data_t gpr2 = unsigned(param->_size_data,(op->_has_immediat==1)?op->_immediat:op->_data_rb);
803    uint64_t        temp = range<uint64_t>(gpr1 * gpr2, 32);
804
805    temp = ((static_cast<uint64_t>(reg->_spr[GROUP_MAC][SPR_MACHI]) << 32) | static_cast<uint64_t>(reg->_spr[GROUP_MAC][SPR_MACLO])) - temp;
806
807    reg->_spr[GROUP_MAC][SPR_MACLO] = range<Tgeneral_data_t>(temp    ,32);
808    reg->_spr[GROUP_MAC][SPR_MACHI] = range<Tgeneral_data_t>(temp>>32,32);
809   
810    // Result
811    op->_timing       = param->_timing[op->_type][op->_operation];
812  //op->_data_rd      = 0;
813  //op->_data_re      = 0;
814    op->_exception    = EXCEPTION_ALU_NONE;
815    op->_no_sequence  = 0;
816  //op->_address      = 0;
817  };
818
819}; // end namespace functionnal_unit
820}; // end namespace execute_unit
821}; // end namespace multi_execute_unit
822}; // end namespace execute_loop
823}; // end namespace multi_execute_loop
824}; // end namespace core
825}; // end namespace behavioural
826}; // end namespace morpheo             
827#endif
Note: See TracBrowser for help on using the repository browser.