OpenCores
URL https://opencores.org/ocsvn/or2k/or2k/trunk

Subversion Repositories or2k

[/] [or2k/] [trunk/] [analysis-bin/] [insnanalysis/] [or1k-32-insn.c] - Blame information for rev 16

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 16 julius 
#include "stdio.h"
2 
#include "stdint.h"
3 
#include "stdlib.h"
4 
#include "string.h"
5 
#include "or1k-32-insn.h"
6 
 
7 
// These should also be in insnanalysis.h insnanalysis.h
8 
typedef uint32_t instruction;
9 
typedef struct or1k_32_instruction_properties instruction_properties ;
10 
 
11 
#include "insn-lists.h"
12 
 
13 
 
14 
int or1k_32_analyse_insn(uint32_t insn,
15 
                         struct or1k_32_instruction_properties  * insn_props)
16 
{
17 
 
18 
  switch(insn_or1k_opcode(insn))
19 
    {
20 
    case 0x00:
21 
      insn_props->insn_string="l.j";
22 
      insn_props->has_jumptarg = 1;
23 
      break;
24 
 
25 
    case 0x01:
26 
      insn_props->insn_string="l.jal";
27 
      insn_props->has_jumptarg = 1;
28 
      break;
29 
 
30 
     case 0x03:
31 
      insn_props->insn_string="l.bnf";
32 
      insn_props->has_branchtarg = 1;
33 
      break;
34 
 
35 
    case 0x04:
36 
      insn_props->insn_string="l.bf";
37 
      insn_props->has_branchtarg = 1;
38 
      break;
39 
 
40 
    case 0x05:
41 
      insn_props->insn_string="l.nop";
42 
      break;
43 
 
44 
    case 0x06:
45 
      if((insn_or1k_opcode_0x06_get_id(insn)))
46 
        insn_props->insn_string="l.macrc";
47 
      else
48 
        {
49 
          insn_props->insn_string="l.movhi";
50 
          insn_props->has_rD = 1;
51 
          insn_props->has_imm = 1;
52 
        }
53 
 
54 
      break;
55 
 
56 
    case 0x08:
57 
 
58 
      switch(insn_or1k_opcode_0x08_get_id(insn))
59 
        {
60 
        case 0x0:
61 
          insn_props->insn_string="l.sys";
62 
          break;
63 
        case 0x2:
64 
          insn_props->insn_string="l.trap";
65 
          break;
66 
        case 0x4:
67 
          insn_props->insn_string="l.msync";
68 
          break;
69 
        case 0x5:
70 
          insn_props->insn_string="l.psync";
71 
          break;
72 
        case 0x6:
73 
          insn_props->insn_string="l.csync";
74 
          break;
75 
        default:
76 
          printf("Unknown id (0x%x) in opcode 0x8",
77 
                 insn_or1k_opcode_0x08_get_id(insn) );
78 
          return 1;
79 
          break;
80 
        }
81 
      break;
82 
 
83 
    case 0x09:
84 
      insn_props->insn_string="l.rfe";
85 
      break;
86 
 
87 
    case 0x0a:
88 
      switch(insn_or1k_opcode_0x0a_get_op_hi(insn))
89 
        {
90 
        case 0x1:
91 
          switch(insn_or1k_opcode_0x0a_get_op_lo(insn))
92 
            {
93 
            case 0x0:
94 
              break;
95 
            case 0x1:
96 
              break;
97 
            case 0x2:
98 
              break;
99 
            case 0x3:
100 
              break;
101 
            case 0x4:
102 
              break;
103 
            case 0x5:
104 
              break;
105 
            case 0x6:
106 
              break;
107 
            case 0x7:
108 
              break;
109 
            case 0x8:
110 
              break;
111 
            case 0x9:
112 
              break;
113 
            case 0xa:
114 
              break;
115 
            case 0xb:
116 
              break;
117 
            default:
118 
              printf("Unknown lv.all_xx insn");
119 
            }
120 
        case 0x2:
121 
          switch(insn_or1k_opcode_0x0a_get_op_lo(insn))
122 
            {
123 
            case 0x0:
124 
              break;
125 
            case 0x1:
126 
              break;
127 
            case 0x2:
128 
              break;
129 
            case 0x3:
130 
              break;
131 
            case 0x4:
132 
              break;
133 
            case 0x5:
134 
              break;
135 
            case 0x6:
136 
              break;
137 
            case 0x7:
138 
              break;
139 
            case 0x8:
140 
              break;
141 
            case 0x9:
142 
              break;
143 
            case 0xa:
144 
              break;
145 
            case 0xb:
146 
              break;
147 
            default:
148 
              printf("Unknown lv.any_xx insn");
149 
            }
150 
          break;
151 
        case 0x3:
152 
          switch(insn_or1k_opcode_0x0a_get_op_lo(insn))
153 
            {
154 
            case 0x0:
155 
              break;
156 
            case 0x1:
157 
              break;
158 
            case 0x2:
159 
              break;
160 
            case 0x3:
161 
              break;
162 
            case 0x4:
163 
              break;
164 
            case 0x5:
165 
              break;
166 
            case 0x6:
167 
              break;
168 
            case 0x7:
169 
              break;
170 
            case 0x8:
171 
              break;
172 
            case 0x9:
173 
              break;
174 
            case 0xa:
175 
              break;
176 
            default:
177 
              printf("Unknown lv.add/and/avg_xx insn");
178 
            }
179 
          break;
180 
        case 0x4:
181 
          switch(insn_or1k_opcode_0x0a_get_op_lo(insn))
182 
            {
183 
            case 0x0:
184 
              break;
185 
            case 0x1:
186 
              break;
187 
            case 0x2:
188 
              break;
189 
            case 0x3:
190 
              break;
191 
            case 0x4:
192 
              break;
193 
            case 0x5:
194 
              break;
195 
            case 0x6:
196 
              break;
197 
            case 0x7:
198 
              break;
199 
            case 0x8:
200 
              break;
201 
            case 0x9:
202 
              break;
203 
            case 0xa:
204 
              break;
205 
            case 0xb:
206 
              break;
207 
            default:
208 
              printf("Unknown lv.cmp_xx insn");
209 
            }
210 
          break;
211 
        case 0x5:
212 
          switch(insn_or1k_opcode_0x0a_get_op_lo(insn))
213 
            {
214 
            case 0x4:
215 
              break;
216 
            case 0x5:
217 
              break;
218 
            case 0x6:
219 
              break;
220 
            case 0x7:
221 
              break;
222 
            case 0x8:
223 
              break;
224 
            case 0x9:
225 
              break;
226 
            case 0xa:
227 
              break;
228 
            case 0xb:
229 
              break;
230 
            case 0xc:
231 
              break;
232 
            case 0xd:
233 
              break;
234 
            case 0xe:
235 
              break;
236 
            case 0xf:
237 
              break;
238 
            default:
239 
              printf("Unknown lv.alu_xx insn");
240 
            }
241 
          break;
242 
        case 0x6:
243 
          switch(insn_or1k_opcode_0x0a_get_op_lo(insn))
244 
            {
245 
            case 0x0:
246 
              break;
247 
            case 0x1:
248 
              break;
249 
            case 0x2:
250 
              break;
251 
            case 0x3:
252 
              break;
253 
            case 0x4:
254 
              break;
255 
            case 0x5:
256 
              break;
257 
            case 0x6:
258 
              break;
259 
            case 0x7:
260 
              break;
261 
            case 0x8:
262 
              break;
263 
            case 0x9:
264 
              break;
265 
            case 0xa:
266 
              break;
267 
            case 0xb:
268 
              break;
269 
            case 0xc:
270 
              break;
271 
            case 0xd:
272 
              break;
273 
            case 0xe:
274 
              break;
275 
            case 0xf:
276 
              break;
277 
            default:
278 
              printf("Unknown lv.pack_xx insn");
279 
            }
280 
          break;
281 
        case 0x7:
282 
          switch(insn_or1k_opcode_0x0a_get_op_lo(insn))
283 
            {
284 
            case 0x0:
285 
              break;
286 
            case 0x1:
287 
              break;
288 
            case 0x2:
289 
              break;
290 
            case 0x3:
291 
              break;
292 
            case 0x4:
293 
              break;
294 
            case 0x5:
295 
              break;
296 
            case 0x6:
297 
              break;
298 
            case 0x7:
299 
              break;
300 
            case 0x8:
301 
              break;
302 
            case 0x9:
303 
              break;
304 
            case 0xa:
305 
              break;
306 
            case 0xb:
307 
              break;
308 
            default:
309 
              printf("Unknown lv.sub/unpack/xor_xx insn");
310 
            }
311 
          break;
312 
        case 0xc:
313 
          break;
314 
        case 0xd:
315 
          break;
316 
        case 0xe:
317 
          break;
318 
        case 0xf:
319 
          break;
320 
        default:
321 
          printf("Unknown lv.xxx insn hi op");
322 
          break;
323 
        }
324 
      break;
325 
 
326 
    case 0x11:
327 
      insn_props->insn_string="l.jr";
328 
      insn_props->has_rB = 1;
329 
      break;
330 
 
331 
    case 0x12:
332 
      insn_props->insn_string="l.jalr";
333 
      insn_props->has_rB = 1;
334 
      break;
335 
 
336 
    case 0x13:
337 
      insn_props->insn_string="l.maci";
338 
      break;
339 
 
340 
    case 0x1c:
341 
      insn_props->insn_string="l.cust1";
342 
      break;
343 
 
344 
    case 0x1d:
345 
      insn_props->insn_string="l.cust2";
346 
      break;
347 
 
348 
    case 0x1e:
349 
      insn_props->insn_string="l.cust3";
350 
      break;
351 
 
352 
    case 0x1f:
353 
      insn_props->insn_string="l.cust4";
354 
      break;
355 
 
356 
    case 0x20:
357 
      insn_props->insn_string="l.ld";
358 
      insn_props->has_rD = 1;
359 
      insn_props->has_rA = 1;
360 
      insn_props->has_imm = 1;
361 
      break;
362 
 
363 
    case 0x21:
364 
      insn_props->insn_string="l.lwz";
365 
      insn_props->has_rD = 1;
366 
      insn_props->has_rA = 1;
367 
      insn_props->has_imm = 1;
368 
      break;
369 
 
370 
    case 0x22:
371 
      insn_props->insn_string="l.lws";
372 
      insn_props->has_rD = 1;
373 
      insn_props->has_rA = 1;
374 
      insn_props->has_imm = 1;
375 
      break;
376 
 
377 
    case 0x23:
378 
      insn_props->insn_string="l.lbz";
379 
      insn_props->has_rD = 1;
380 
      insn_props->has_rA = 1;
381 
      insn_props->has_imm = 1;
382 
      break;
383 
 
384 
    case 0x24:
385 
      insn_props->insn_string="l.lbs";
386 
      insn_props->has_rD = 1;
387 
      insn_props->has_rA = 1;
388 
      insn_props->has_imm = 1;
389 
      break;
390 
 
391 
    case 0x25:
392 
      insn_props->insn_string="l.lhz";
393 
      insn_props->has_rD = 1;
394 
      insn_props->has_rA = 1;
395 
      insn_props->has_imm = 1;
396 
      break;
397 
 
398 
    case 0x26:
399 
      insn_props->insn_string="l.lhs";
400 
      insn_props->has_rD = 1;
401 
      insn_props->has_rA = 1;
402 
      insn_props->has_imm = 1;
403 
      break;
404 
 
405 
 
406 
    case 0x27:
407 
      insn_props->insn_string="l.addi";
408 
      insn_props->has_rD = 1;
409 
      insn_props->has_rA = 1;
410 
      insn_props->has_imm = 1;
411 
      break;
412 
 
413 
    case 0x28:
414 
      insn_props->insn_string="l.addic";
415 
      insn_props->has_rD = 1;
416 
      insn_props->has_rA = 1;
417 
      insn_props->has_imm = 1;
418 
      break;
419 
 
420 
    case 0x29:
421 
      insn_props->insn_string="l.andi";
422 
      insn_props->has_rD = 1;
423 
      insn_props->has_rA = 1;
424 
      insn_props->has_imm = 1;
425 
      break;
426 
 
427 
    case 0x2a:
428 
      insn_props->insn_string="l.ori";
429 
      insn_props->has_rD = 1;
430 
      insn_props->has_rA = 1;
431 
      insn_props->has_imm = 1;
432 
      break;
433 
 
434 
    case 0x2b:
435 
      insn_props->insn_string="l.xori";
436 
      insn_props->has_rD = 1;
437 
      insn_props->has_rA = 1;
438 
      insn_props->has_imm = 1;
439 
      break;
440 
 
441 
    case 0x2c:
442 
      insn_props->insn_string="l.muli";
443 
      insn_props->has_rD = 1;
444 
      insn_props->has_rA = 1;
445 
      insn_props->has_imm = 1;
446 
      break;
447 
 
448 
    case 0x2d:
449 
      insn_props->insn_string="l.mfspr";
450 
      insn_props->has_rD = 1;
451 
      insn_props->has_rA = 1;
452 
      insn_props->has_imm = 1;
453 
      break;
454 
 
455 
    case 0x2e:
456 
      switch(insn_or1k_opcode_0x2e_get_op(insn))
457 
        {
458 
        case 0x0:
459 
          insn_props->insn_string="l.slli";
460 
          break;
461 
        case 0x1:
462 
          insn_props->insn_string="l.srli";
463 
          break;
464 
        case 0x2:
465 
          insn_props->insn_string="l.srai";
466 
          break;
467 
        case 0x3:
468 
          insn_props->insn_string="l.rori";
469 
          break;
470 
        default:
471 
          printf("Unknown shift op (0x%x)",
472 
                 insn_or1k_opcode_0x2e_get_op(insn));
473 
          break;
474 
        }
475 
      break;
476 
 
477 
    case 0x2f:
478 
      switch(insn_or1k_opcode_0x2f_get_op(insn))
479 
        {
480 
        case 0x0:
481 
          insn_props->insn_string="l.sfeqi";
482 
          break;
483 
        case 0x1:
484 
          insn_props->insn_string="l.sfnei";
485 
          break;
486 
        case 0x2:
487 
          insn_props->insn_string="l.sfgtui";
488 
          break;
489 
        case 0x3:
490 
          insn_props->insn_string="l.sfgeui";
491 
          break;
492 
        case 0x4:
493 
          insn_props->insn_string="l.sfltui";
494 
          break;
495 
        case 0x5:
496 
          insn_props->insn_string="l.sfleui";
497 
          break;
498 
        case 0xa:
499 
          insn_props->insn_string="l.sfgtsi";
500 
          break;
501 
        case 0xb:
502 
          insn_props->insn_string="l.sfgesi";
503 
          break;
504 
        case 0xc:
505 
          insn_props->insn_string="l.sfltsi";
506 
          break;
507 
        case 0xd:
508 
          insn_props->insn_string="l.sflesi";
509 
          break;
510 
 
511 
        default:
512 
          printf("Unknown set flag op (0x%x)",
513 
                 insn_or1k_opcode_0x2f_get_op(insn));
514 
          break;
515 
        }
516 
      insn_props->has_rA = 1;
517 
      insn_props->has_imm = 1;
518 
      break;
519 
 
520 
 
521 
    case 0x30:
522 
      insn_props->insn_string="l.mtspr";
523 
      break;
524 
 
525 
    case 0x31:
526 
      switch (insn_or1k_opcode_0x31_get_op(insn))
527 
        {
528 
        case 0x1:
529 
          insn_props->insn_string="l.mac";
530 
          break;
531 
        case 0x2:
532 
          insn_props->insn_string="l.msb";
533 
          break;
534 
        default:
535 
          printf("Unknown mac op (0x%x)",
536 
                 insn_or1k_opcode_0x31_get_op(insn));
537 
        }
538 
      break;
539 
 
540 
    case 0x32:
541 
      switch(insn_or1k_opcode_0x32_get_op_hi(insn))
542 
        {
543 
        case 0x0:
544 
          switch(insn_or1k_opcode_0x32_get_op_lo(insn))
545 
            {
546 
            case 0x0:
547 
              insn_props->insn_string="lf.add.s";
548 
              break;
549 
            case 0x1:
550 
              insn_props->insn_string="lf.sub.s";
551 
              break;
552 
            case 0x2:
553 
              insn_props->insn_string="lf.mul.s";
554 
              break;
555 
            case 0x3:
556 
              insn_props->insn_string="lf.div.s";
557 
              break;
558 
            case 0x4:
559 
              insn_props->insn_string="lf.itof.s";
560 
              break;
561 
            case 0x5:
562 
              insn_props->insn_string="lf.ftoi.s";
563 
              break;
564 
            case 0x6:
565 
              insn_props->insn_string="lf.rem.s";
566 
              break;
567 
            case 0x7:
568 
              insn_props->insn_string="lf.madd.s";
569 
              break;
570 
            case 0x8:
571 
              insn_props->insn_string="lf.sfeq.s";
572 
              break;
573 
            case 0x9:
574 
              insn_props->insn_string="lf.sfne.s";
575 
              break;
576 
            case 0xa:
577 
              insn_props->insn_string="lf.sfgt.s";
578 
              break;
579 
            case 0xb:
580 
              insn_props->insn_string="lf.sfge.s";
581 
              break;
582 
            case 0xc:
583 
              insn_props->insn_string="lf.sflt.s";
584 
              break;
585 
            case 0xd:
586 
              insn_props->insn_string="lf.sfle.s";
587 
              break;
588 
            default:
589 
              printf("Unknown lf.xxx.s op (0x%x)",
590 
                     insn_or1k_opcode_0x32_get_op_lo(insn));
591 
              break;
592 
            }
593 
          break;
594 
 
595 
        case 0x1:
596 
          switch(insn_or1k_opcode_0x32_get_op_lo(insn))
597 
            {
598 
            case 0x0:
599 
              insn_props->insn_string="lf.add.d";
600 
              break;
601 
            case 0x1:
602 
              insn_props->insn_string="lf.sub.d";
603 
              break;
604 
            case 0x2:
605 
              insn_props->insn_string="lf.mul.d";
606 
              break;
607 
            case 0x3:
608 
              insn_props->insn_string="lf.div.d";
609 
              break;
610 
            case 0x4:
611 
              insn_props->insn_string="lf.itof.d";
612 
              break;
613 
            case 0x5:
614 
              insn_props->insn_string="lf.ftoi.d";
615 
              break;
616 
            case 0x6:
617 
              insn_props->insn_string="lf.rem.d";
618 
              break;
619 
            case 0x7:
620 
              insn_props->insn_string="lf.madd.d";
621 
              break;
622 
            case 0x8:
623 
              insn_props->insn_string="lf.sfeq.d";
624 
              break;
625 
            case 0x9:
626 
              insn_props->insn_string="lf.sfne.d";
627 
              break;
628 
            case 0xa:
629 
              insn_props->insn_string="lf.sfgt.d";
630 
              break;
631 
            case 0xb:
632 
              insn_props->insn_string="lf.sfge.d";
633 
              break;
634 
            case 0xc:
635 
              insn_props->insn_string="lf.sflt.d";
636 
              break;
637 
            case 0xd:
638 
              insn_props->insn_string="lf.sfle.d";
639 
              break;
640 
            default:
641 
              printf("Unknown lf.xxx.d op (0x%x)",
642 
                     insn_or1k_opcode_0x32_get_op_lo(insn));
643 
              break;
644 
            }
645 
          break;
646 
 
647 
        case 0xd:
648 
          insn_props->insn_string="lf.cust1.s";
649 
          break;
650 
 
651 
        case 0xe:
652 
          insn_props->insn_string="lf.cust1.d";
653 
          break;
654 
 
655 
        default:
656 
          printf("Unknown lf.xxx opcode hi (0x%x)",
657 
                 insn_or1k_opcode_0x32_get_op_hi(insn));
658 
          break;
659 
        }
660 
      break;
661 
 
662 
    case 0x34:
663 
      insn_props->insn_string="l.sd";
664 
      break;
665 
 
666 
    case 0x35:
667 
      insn_props->insn_string="l.sw";
668 
      break;
669 
 
670 
    case 0x36:
671 
      insn_props->insn_string="l.sb";
672 
      break;
673 
 
674 
    case 0x37:
675 
      insn_props->insn_string="l.sh";
676 
      break;
677 
 
678 
    case 0x38:
679 
      switch(insn_or1k_opcode_0x38_get_op_lo(insn))
680 
        {
681 
          insn_props->has_rD = 1;
682 
          insn_props->has_rA = 1;
683 
          insn_props->has_rB = 1;
684 
        case 0x0:
685 
          insn_props->insn_string="l.add";
686 
          break;
687 
        case 0x1:
688 
          insn_props->insn_string="l.addc";
689 
          break;
690 
        case 0x2:
691 
          insn_props->insn_string="l.sub";
692 
          break;
693 
        case 0x3:
694 
          insn_props->insn_string="l.and";
695 
          break;
696 
        case 0x4:
697 
          insn_props->insn_string="l.or";
698 
          break;
699 
        case 0x5:
700 
          insn_props->insn_string="l.xor";
701 
          break;
702 
        case 0x6:
703 
          insn_props->insn_string="l.mul";
704 
          break;
705 
        case 0x8:
706 
          switch (insn_or1k_opcode_0x38_get_op_hi_4bit(insn))
707 
            {
708 
            case 0x0:
709 
              insn_props->insn_string="l.sll";
710 
              break;
711 
            case 0x1:
712 
              insn_props->insn_string="l.srl";
713 
              break;
714 
            case 0x2:
715 
              insn_props->insn_string="l.sra";
716 
              break;
717 
            case 0x3:
718 
              insn_props->insn_string="l.ror";
719 
              break;
720 
            default:
721 
              printf("Unknown ALU op 0x8 hi op (0x%x)",
722 
                     insn_or1k_opcode_0x38_get_op_hi_4bit(insn));
723 
              break;
724 
            }
725 
          break;
726 
        case 0x9:
727 
          insn_props->insn_string="l.div";
728 
          break;
729 
        case 0xa:
730 
          insn_props->insn_string="l.divu";
731 
          break;
732 
        case 0xb:
733 
          insn_props->insn_string="l.mulu";
734 
          break;
735 
        case 0xc:
736 
          switch(insn_or1k_opcode_0x38_get_op_hi_4bit(insn))
737 
            {
738 
            case 0x0:
739 
              insn_props->insn_string="l.exths";
740 
              break;
741 
            case 0x1:
742 
              insn_props->insn_string="l.extbs";
743 
              break;
744 
            case 0x2:
745 
              insn_props->insn_string="l.exthz";
746 
              break;
747 
            case 0x3:
748 
              insn_props->insn_string="l.extbz";
749 
              break;
750 
            }
751 
          insn_props->has_rB = 0;
752 
          break;
753 
 
754 
        case 0xd:
755 
          insn_props->insn_string="l.extws";
756 
          insn_props->has_rB = 0;
757 
          break;
758 
 
759 
        case 0xe:
760 
          insn_props->insn_string="l.cmov";
761 
          break;
762 
 
763 
        case 0xf:
764 
          if (insn_or1k_opcode_0x38_get_op_hi_2bit(insn) & 0x1)
765 
            insn_props->insn_string="l.fl1";
766 
          else
767 
            insn_props->insn_string="l.ff1";
768 
          insn_props->has_rB = 0;
769 
          break;
770 
 
771 
        default:
772 
          printf("Unknown ALU lo op (0x%x)",
773 
                 insn_or1k_opcode_0x38_get_op_lo(insn));
774 
          break;
775 
        }
776 
      break;
777 
 
778 
    case 0x39:
779 
      switch (insn_or1k_opcode_0x39_get_op(insn))
780 
        {
781 
          insn_props->has_rA = 0;
782 
          insn_props->has_rB = 0;
783 
        case 0x0:
784 
          insn_props->insn_string="l.sfeq";
785 
          break;
786 
        case 0x1:
787 
          insn_props->insn_string="l.sfne";
788 
          break;
789 
        case 0x2:
790 
          insn_props->insn_string="l.sfgtu";
791 
          break;
792 
        case 0x3:
793 
          insn_props->insn_string="l.sfgeu";
794 
          break;
795 
        case 0x4:
796 
          insn_props->insn_string="l.sfltu";
797 
          break;
798 
        case 0x5:
799 
          insn_props->insn_string="l.sfleu";
800 
          break;
801 
        case 0xa:
802 
          insn_props->insn_string="l.sfgts";
803 
          break;
804 
        case 0xb:
805 
          insn_props->insn_string="l.sfges";
806 
          break;
807 
        case 0xc:
808 
          insn_props->insn_string="l.sflts";
809 
          break;
810 
        case 0xd:
811 
          insn_props->insn_string="l.sfles";
812 
          break;
813 
        default:
814 
          printf("Unknown opcode for l.sfxxx opcode (0x%x)",
815 
                 insn_or1k_opcode_0x39_get_op(insn));
816 
          break;
817 
        }
818 
      break;
819 
 
820 
    default:
821 
      printf("Unknown opcode 0x%x",insn_or1k_opcode(insn));
822 
      return 1;
823 
      break;
824 
    }
825 
 
826 
  return 0;
827 
}
828 
 
829 
 
830 
 
831 
void or1k_32_collect_stats(uint32_t insn,
832 
                         struct or1k_32_instruction_properties  * insn_props)
833 
{
834 
  // First calculate frequency
835 
  int index = insn_lists_check(insn, insn_props);
836 
 
837 
  // Create new entry in list
838 
  if (index == IS_UNIQUE)
839 
    index = insn_lists_add_unique_insn(insn, insn_props);
840 
 
841 
  // Now count it
842 
  insn_lists_add(index, insn, insn_props);
843 
 
844 
}
845 
 
846 
 
847 
 
848 
struct or1k_value_list
849 
{
850 
 
851 
#define OR1K_VALUE_MAX_ENTRIES 64
852 
  int count;
853 
  // [value][occurances_of_value]
854 
  int values[OR1K_VALUE_MAX_ENTRIES][2];
855 
 
856 
};
857 
 
858 
 
859 
struct or1k_insn_info
860 
{
861 
  char* insn_string;
862 
 
863 
  int count;
864 
 
865 
  int has_branchtarg;
866 
  struct or1k_value_list branch_info;
867 
 
868 
  int has_imm;
869 
 
870 
  struct or1k_value_list imm_info;
871 
 
872 
  int has_rD;
873 
  int rD_use_freq[32];
874 
  int has_rA;
875 
  int rA_use_freq[32];
876 
  int has_rB;
877 
  int rB_use_freq[32];
878 
 
879 
};
880 
 
881 
#define OR1K_32_MAX_INSNS 120
882 
struct or1k_insn_info * or1k_32_insns[OR1K_32_MAX_INSNS];
883 
 
884 
 
885 
// List management/analysis functions - accessed through insn_lists() set of
886 
// functions
887 
 
888 
// Variable to keep track of unique instructions we have
889 
int num_unique_insns;
890 
int num_seen_insns;
891 
 
892 
 
893 
void or1k_32_insn_lists_init(void)
894 
{
895 
  num_unique_insns = 0;
896 
  num_seen_insns = 0;
897 
}
898 
 
899 
// List management/analysis functions
900 
int or1k_32_insn_lists_check(uint32_t insn,
901 
                             struct or1k_32_instruction_properties *insn_props)
902 
{
903 
 
904 
  int num_to_check = num_unique_insns;
905 
  int insn_strlen = strlen(insn_props->insn_string);
906 
  while (num_to_check)
907 
    {
908 
 
909 
      --num_to_check;
910 
 
911 
      if ((strncmp(insn_props->insn_string,
912 
                   or1k_32_insns[num_to_check]->insn_string, insn_strlen) == 0)
913 
          && (insn_strlen == strlen(or1k_32_insns[num_to_check]->insn_string)))
914 
        {
915 
          // Found match by string
916 
          return num_to_check;
917 
        }
918 
    }
919 
 
920 
  return IS_UNIQUE;
921 
}
922 
 
923 
// Add a unique instruction
924 
int or1k_32_insn_lists_add_unique_insn(uint32_t insn,
925 
                           struct or1k_32_instruction_properties *insn_props)
926 
{
927 
  // Add an instruction in or1k_32_insns[num_unique_instructions];
928 
  // use calloc() so it clears it all first (hopefully!).. assumption!
929 
  struct or1k_insn_info * new_insn
930 
    = (struct or1k_insn_info *) calloc (sizeof(struct or1k_insn_info), 1);
931 
 
932 
  // Calloc() space for the string
933 
  new_insn->insn_string = (char *) calloc(strlen(insn_props->insn_string), 1);
934 
 
935 
  // Copy in the instruction string
936 
  strncpy(new_insn->insn_string, insn_props->insn_string,
937 
          strlen(insn_props->insn_string));
938 
 
939 
  // Install the pointer for this new instruction in the list
940 
  or1k_32_insns[num_unique_insns] = new_insn;;
941 
 
942 
  // Increment number of instructions we have
943 
  num_unique_insns++;
944 
 
945 
  // Return index of newly created instruction
946 
  return (num_unique_insns - 1);
947 
 
948 
}
949 
 
950 
// Add to, or increment incidences of, value in the value list
951 
void or1k_add_in_list(struct or1k_value_list * list, int value)
952 
{
953 
  int i;
954 
  // See if it's already in the list
955 
  i=list->count;
956 
 
957 
  while(i)
958 
    {
959 
      i--;
960 
      if(list->values[i][0] == value)
961 
        {
962 
          (list->values[i][1])++;
963 
          return;
964 
        }
965 
    }
966 
  // Not found, add it to the list
967 
  list->values[(list->count)][0] = value;
968 
  list->values[(list->count)][1] = 1;
969 
 
970 
}
971 
 
972 
 
973 
// Add stats for this instruction
974 
void or1k_32_insn_lists_add(int index, uint32_t insn,
975 
                            struct or1k_32_instruction_properties *insn_props)
976 
{
977 
  // Add stats for this instruction
978 
 
979 
  // Increment count
980 
  ((or1k_32_insns[index])->count)++;
981 
 
982 
  // Add branch target value information, if instruction has it
983 
  if (insn_props->has_branchtarg)
984 
    {
985 
      (or1k_32_insns[index])->has_branchtarg = 1;
986 
      or1k_add_in_list(&((or1k_32_insns[index])->branch_info),
987 
                       (int)insn_or1k_opcode_0x03_get_branchoff(insn));
988 
    }
989 
 
990 
  // Add immediate value if it's got one
991 
  if (insn_props->has_imm)
992 
    {
993 
      (or1k_32_insns[index])->has_imm = 1;
994 
      or1k_add_in_list(&((or1k_32_insns[index])->imm_info),
995 
                       (int)insn_or1k_32_imm(insn));
996 
    }
997 
 
998 
  // Add split immediate value if it's got one
999 
  if (insn_props->has_split_imm)
1000 
    {
1001 
      (or1k_32_insns[index])->has_imm = 1;
1002 
      or1k_add_in_list(&((or1k_32_insns[index])->imm_info),
1003 
                       (int)insn_or1k_32_split_imm(insn));
1004 
    }
1005 
 
1006 
 
1007 
  // Increment count of use for particular rD
1008 
  if (insn_props->has_rD)
1009 
    {
1010 
      (or1k_32_insns[index])->has_rD = 1;
1011 
      ((or1k_32_insns[index])->rD_use_freq[insn_or1k_32_rD(insn)])++;
1012 
    }
1013 
 
1014 
  // Increment count of use for particular rA
1015 
  if (insn_props->has_rA)
1016 
    {
1017 
      (or1k_32_insns[index])->has_rA = 1;
1018 
      ((or1k_32_insns[index])->rA_use_freq[insn_or1k_32_rA(insn)])++;
1019 
    }
1020 
 
1021 
  // Increment count of use for particular rB
1022 
  if (insn_props->has_rB)
1023 
    {
1024 
      (or1k_32_insns[index])->has_rB = 1;
1025 
      ((or1k_32_insns[index])->rB_use_freq[insn_or1k_32_rB(insn)])++;
1026 
    }
1027 
 
1028 
  // Finished adding to stats for this instruction
1029 
 
1030 
  // Increment overall instructions "seen" counter
1031 
  num_seen_insns++;
1032 
 
1033 
}
1034 
 
1035 
 
1036 
// Free up all added instruction statistic tracking structs
1037 
void or1k_32_insn_lists_free(void)
1038 
{
1039 
  while (num_unique_insns)
1040 
    {
1041 
 
1042 
      num_unique_insns--;
1043 
 
1044 
      free(or1k_32_insns[num_unique_insns]);
1045 
 
1046 
    }
1047 
}
1048 
 

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.