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

Subversion Repositories or2k

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

Details | Compare with Previous | View Log


/*
  Or1K instruction set-specific decoding and analysis functions.
 
  Julius Baxter, julius.baxter@orsoc.se
 
*/
 
 
#include "stdio.h"
#include "stdint.h"
#include "stdlib.h"
#include "string.h"
#include "assert.h"
#include "or1k-32-insn.h"
 
// Define the appropriate instruction type, and instruction_properties type
// These should also be defined in insnanalysis.h
typedef uint32_t instruction;
typedef struct or1k_32_instruction_properties instruction_properties ;
 
#include "insn-lists.h"
 
// Variable to keep track of unique instructions we have
int num_setup_insns;
int num_seen_insns;
 
struct or1k_insn_info * or1k_32_insns[OR1K_32_MAX_INSNS];
 
// Keep enough instructions required to do the maximum n-tuple set
// analysis.
int or1k_32_recent_insns[OR1K_MAX_GROUPINGS_ANALYSIS];
 
// Function to take the raw binary instruction, and configure the insn_props
// struct with the appropriate settings for that instruction (string, attributes
// etc.)
// TODO: vector instructions aren't picked up - but compiler never generates
// them, so not a big issue.
int or1k_32_analyse_insn(uint32_t insn,
                         struct or1k_32_instruction_properties  * insn_props)
{
 
  switch(insn_or1k_opcode(insn))
    {
    case 0x00:
      insn_props->insn_string="l.j";
      insn_props->insn_index=0;
      insn_props->has_jumptarg = 1;
      break;
 
    case 0x01:
      insn_props->insn_string="l.jal";
      insn_props->insn_index=1;
      insn_props->has_jumptarg = 1;
      break;
 
     case 0x03:
      insn_props->insn_string="l.bnf";
      insn_props->insn_index=2;
      insn_props->has_branchtarg = 1;
      break;
 
    case 0x04:
      insn_props->insn_string="l.bf";
      insn_props->insn_index=3;
      insn_props->has_branchtarg = 1;
      break;
 
    case 0x05:
      insn_props->insn_string="l.nop";
      insn_props->insn_index=4;
      break;
 
    case 0x06:
      if((insn_or1k_opcode_0x06_get_id(insn)))
        {
          insn_props->insn_string="l.macrc";
          insn_props->insn_index=5;
        }
      else
        {
          insn_props->insn_string="l.movhi";
          insn_props->insn_index=6;
          insn_props->has_rD = 1;
          insn_props->has_imm = 1;
        }
 
      break;
 
    case 0x08:
 
      switch(insn_or1k_opcode_0x08_get_id(insn))
        {
        case 0x0:
          insn_props->insn_string="l.sys";
          insn_props->insn_index=7;
          insn_props->has_imm = 1;
          break;
        case 0x2:
          insn_props->insn_string="l.trap";
          insn_props->insn_index=8;
          break;
        case 0x4:
          insn_props->insn_string="l.msync";
          insn_props->insn_index=9;
          break;
        case 0x5:
          insn_props->insn_string="l.psync";
          insn_props->insn_index=10;
          break;
        case 0x6:
          insn_props->insn_string="l.csync";
          insn_props->insn_index=11;
          break;
        default:
          printf("Unknown id (0x%x) in opcode 0x8",
                 insn_or1k_opcode_0x08_get_id(insn) );
          return 1;
          break;
        }
      break;
 
    case 0x09:
      insn_props->insn_string="l.rfe";
      insn_props->insn_index=12;
      break;
 
    case 0x0a:
      switch(insn_or1k_opcode_0x0a_get_op_hi(insn))
        {
        case 0x1:
          switch(insn_or1k_opcode_0x0a_get_op_lo(insn))
            {
            case 0x0:
              break;
            case 0x1:
              break;
            case 0x2:
              break;
            case 0x3:
              break;
            case 0x4:
              break;
            case 0x5:
              break;
            case 0x6:
              break;
            case 0x7:
              break;
            case 0x8:
              break;
            case 0x9:
              break;
            case 0xa:
              break;
            case 0xb:
              break;
            default:
              printf("Unknown lv.all_xx insn");
              return 1;
            }
        case 0x2:
          switch(insn_or1k_opcode_0x0a_get_op_lo(insn))
            {
            case 0x0:
              break;
            case 0x1:
              break;
            case 0x2:
              break;
            case 0x3:
              break;
            case 0x4:
              break;
            case 0x5:
              break;
            case 0x6:
              break;
            case 0x7:
              break;
            case 0x8:
              break;
            case 0x9:
              break;
            case 0xa:
              break;
            case 0xb:
              break;
            default:
              printf("Unknown lv.any_xx insn");
              return 1;
            }
          break;
        case 0x3:
          switch(insn_or1k_opcode_0x0a_get_op_lo(insn))
            {
            case 0x0:
              break;
            case 0x1:
              break;
            case 0x2:
              break;
            case 0x3:
              break;
            case 0x4:
              break;
            case 0x5:
              break;
            case 0x6:
              break;
            case 0x7:
              break;
            case 0x8:
              break;
            case 0x9:
              break;
            case 0xa:
              break;
            default:
              printf("Unknown lv.add/and/avg_xx insn");
              return 1;
            }
          break;
        case 0x4:
          switch(insn_or1k_opcode_0x0a_get_op_lo(insn))
            {
            case 0x0:
              break;
            case 0x1:
              break;
            case 0x2:
              break;
            case 0x3:
              break;
            case 0x4:
              break;
            case 0x5:
              break;
            case 0x6:
              break;
            case 0x7:
              break;
            case 0x8:
              break;
            case 0x9:
              break;
            case 0xa:
              break;
            case 0xb:
              break;
            default:
              printf("Unknown lv.cmp_xx insn");
              return 1;
            }
          break;
        case 0x5:
          switch(insn_or1k_opcode_0x0a_get_op_lo(insn))
            {
            case 0x4:
              break;
            case 0x5:
              break;
            case 0x6:
              break;
            case 0x7:
              break;
            case 0x8:
              break;
            case 0x9:
              break;
            case 0xa:
              break;
            case 0xb:
              break;
            case 0xc:
              break;
            case 0xd:
              break;
            case 0xe:
              break;
            case 0xf:
              break;
            default:
              printf("Unknown lv.alu_xx insn");
              return 1;
            }
          break;
        case 0x6:
          switch(insn_or1k_opcode_0x0a_get_op_lo(insn))
            {
            case 0x0:
              break;
            case 0x1:
              break;
            case 0x2:
              break;
            case 0x3:
              break;
            case 0x4:
              break;
            case 0x5:
              break;
            case 0x6:
              break;
            case 0x7:
              break;
            case 0x8:
              break;
            case 0x9:
              break;
            case 0xa:
              break;
            case 0xb:
              break;
            case 0xc:
              break;
            case 0xd:
              break;
            case 0xe:
              break;
            case 0xf:
              break;
            default:
              printf("Unknown lv.pack_xx insn");
              return 1;
            }
          break;
        case 0x7:
          switch(insn_or1k_opcode_0x0a_get_op_lo(insn))
            {
            case 0x0:
              break;
            case 0x1:
              break;
            case 0x2:
              break;
            case 0x3:
              break;
            case 0x4:
              break;
            case 0x5:
              break;
            case 0x6:
              break;
            case 0x7:
              break;
            case 0x8:
              break;
            case 0x9:
              break;
            case 0xa:
              break;
            case 0xb:
              break;
            default:
              printf("Unknown lv.sub/unpack/xor_xx insn");
              return 1;
            }
          break;
        case 0xc:
          break;
        case 0xd:
          break;
        case 0xe:
          break;
        case 0xf:
          break;
        default:
          printf("Unknown lv.xxx insn hi op");
          return 1;
          break;
        }
      break;
 
    case 0x11:
      insn_props->insn_string="l.jr";
      insn_props->insn_index=13;
      insn_props->has_rB = 1;
      break;
 
    case 0x12:
      insn_props->insn_string="l.jalr";
      insn_props->insn_index=14;
      insn_props->has_rB = 1;
      break;
 
    case 0x13:
      insn_props->insn_string="l.maci";
      insn_props->insn_index=15;
      break;
 
    case 0x1c:
      insn_props->insn_string="l.cust1";
      insn_props->insn_index=16;
      break;
 
    case 0x1d:
      insn_props->insn_string="l.cust2";
      insn_props->insn_index=17;
      break;
 
    case 0x1e:
      insn_props->insn_string="l.cust3";
      insn_props->insn_index=18;
      break;
 
    case 0x1f:
      insn_props->insn_string="l.cust4";
      insn_props->insn_index=19;
      break;
 
    case 0x20:
      insn_props->insn_string="l.ld";
      insn_props->insn_index=20;
      insn_props->has_rD = 1;
      insn_props->has_rA = 1;
      insn_props->has_imm = 1;
      break;
 
    case 0x21:
      insn_props->insn_string="l.lwz";
      insn_props->insn_index=21;
      insn_props->has_rD = 1;
      insn_props->has_rA = 1;
      insn_props->has_imm = 1;
      break;
 
    case 0x22:
      insn_props->insn_string="l.lws";
      insn_props->insn_index=22;
      insn_props->has_rD = 1;
      insn_props->has_rA = 1;
      insn_props->has_imm = 1;
      break;
 
    case 0x23:
      insn_props->insn_string="l.lbz";
      insn_props->insn_index=23;
      insn_props->has_rD = 1;
      insn_props->has_rA = 1;
      insn_props->has_imm = 1;
      break;
 
    case 0x24:
      insn_props->insn_string="l.lbs";
      insn_props->insn_index=24;
      insn_props->has_rD = 1;
      insn_props->has_rA = 1;
      insn_props->has_imm = 1;
      break;
 
    case 0x25:
      insn_props->insn_string="l.lhz";
      insn_props->insn_index=25;
      insn_props->has_rD = 1;
      insn_props->has_rA = 1;
      insn_props->has_imm = 1;
      break;
 
    case 0x26:
      insn_props->insn_string="l.lhs";
      insn_props->insn_index=26;
      insn_props->has_rD = 1;
      insn_props->has_rA = 1;
      insn_props->has_imm = 1;
      break;
 
 
    case 0x27:
      insn_props->insn_string="l.addi";
      insn_props->insn_index=27;
      insn_props->has_rD = 1;
      insn_props->has_rA = 1;
      insn_props->has_imm = 1;
      break;
 
    case 0x28:
      insn_props->insn_string="l.addic";
      insn_props->insn_index=28;
      insn_props->has_rD = 1;
      insn_props->has_rA = 1;
      insn_props->has_imm = 1;
      break;
 
    case 0x29:
      insn_props->insn_string="l.andi";
      insn_props->insn_index=29;
      insn_props->has_rD = 1;
      insn_props->has_rA = 1;
      insn_props->has_imm = 1;
      break;
 
    case 0x2a:
      insn_props->insn_string="l.ori";
      insn_props->insn_index=30;
      insn_props->has_rD = 1;
      insn_props->has_rA = 1;
      insn_props->has_imm = 1;
      break;
 
    case 0x2b:
      insn_props->insn_string="l.xori";
      insn_props->insn_index=31;
      insn_props->has_rD = 1;
      insn_props->has_rA = 1;
      insn_props->has_imm = 1;
      break;
 
    case 0x2c:
      insn_props->insn_string="l.muli";
      insn_props->insn_index=32;
      insn_props->has_rD = 1;
      insn_props->has_rA = 1;
      insn_props->has_imm = 1;
      break;
 
    case 0x2d:
      insn_props->insn_string="l.mfspr";
      insn_props->insn_index=33;
      insn_props->has_rD = 1;
      insn_props->has_rA = 1;
      insn_props->has_imm = 1;
      break;
 
    case 0x2e:
      switch(insn_or1k_opcode_0x2e_get_op(insn))
        {
        case 0x0:
          insn_props->insn_string="l.slli";
          insn_props->insn_index=34;
          break;
        case 0x1:
          insn_props->insn_string="l.srli";
          insn_props->insn_index=35;
          break;
        case 0x2:
          insn_props->insn_string="l.srai";
          insn_props->insn_index=36;
          break;
        case 0x3:
          insn_props->insn_string="l.rori";
          insn_props->insn_index=37;
          break;
        default:
          printf("Unknown shift op (0x%x)",
                 insn_or1k_opcode_0x2e_get_op(insn));
          return 1;
          break;
        }
      break;
 
    case 0x2f:
      switch(insn_or1k_opcode_0x2f_get_op(insn))
        {
        case 0x0:
          insn_props->insn_string="l.sfeqi";
          insn_props->insn_index=38;
          break;
        case 0x1:
          insn_props->insn_string="l.sfnei";
          insn_props->insn_index=39;
          break;
        case 0x2:
          insn_props->insn_string="l.sfgtui";
          insn_props->insn_index=40;
          break;
        case 0x3:
          insn_props->insn_string="l.sfgeui";
          insn_props->insn_index=41;
          break;
        case 0x4:
          insn_props->insn_string="l.sfltui";
          insn_props->insn_index=42;
          break;
        case 0x5:
          insn_props->insn_string="l.sfleui";
          insn_props->insn_index=43;
          break;
        case 0xa:
          insn_props->insn_string="l.sfgtsi";
          insn_props->insn_index=44;
          break;
        case 0xb:
          insn_props->insn_string="l.sfgesi";
          insn_props->insn_index=45;
          break;
        case 0xc:
          insn_props->insn_string="l.sfltsi";
          insn_props->insn_index=46;
          break;
        case 0xd:
          insn_props->insn_string="l.sflesi";
          insn_props->insn_index=47;
          break;
 
        default:
          printf("Unknown set flag op (0x%x)",
                 insn_or1k_opcode_0x2f_get_op(insn));
          return 1;
          break;
        }
      insn_props->has_rA = 1;
      insn_props->has_imm = 1;
      break;
 
 
    case 0x30:
      insn_props->insn_string="l.mtspr";
      insn_props->insn_index=48;
      break;
 
    case 0x31:
      switch (insn_or1k_opcode_0x31_get_op(insn))
        {
        case 0x1:
          insn_props->insn_string="l.mac";
          insn_props->insn_index=49;
          break;
        case 0x2:
          insn_props->insn_string="l.msb";
          insn_props->insn_index=50;
          break;
        default:
          printf("Unknown mac op (0x%x)",
                 insn_or1k_opcode_0x31_get_op(insn));
          return 1;
        }
      break;
 
    case 0x32:
      switch(insn_or1k_opcode_0x32_get_op_hi(insn))
        {
        case 0x0:
          switch(insn_or1k_opcode_0x32_get_op_lo(insn))
            {
            case 0x0:
              insn_props->insn_string="lf.add.s";
              insn_props->insn_index=51;
              break;
            case 0x1:
              insn_props->insn_string="lf.sub.s";
              insn_props->insn_index=52;
              break;
            case 0x2:
              insn_props->insn_string="lf.mul.s";
              insn_props->insn_index=53;
              break;
            case 0x3:
              insn_props->insn_string="lf.div.s";
              insn_props->insn_index=54;
              break;
            case 0x4:
              insn_props->insn_string="lf.itof.s";
              insn_props->insn_index=55;
              break;
            case 0x5:
              insn_props->insn_string="lf.ftoi.s";
              insn_props->insn_index=56;
              break;
            case 0x6:
              insn_props->insn_string="lf.rem.s";
              insn_props->insn_index=57;
              break;
            case 0x7:
              insn_props->insn_string="lf.madd.s";
              insn_props->insn_index=58;
              break;
            case 0x8:
              insn_props->insn_string="lf.sfeq.s";
              insn_props->insn_index=59;
              break;
            case 0x9:
              insn_props->insn_string="lf.sfne.s";
              insn_props->insn_index=60;
              break;
            case 0xa:
              insn_props->insn_string="lf.sfgt.s";
              insn_props->insn_index=61;
              break;
            case 0xb:
              insn_props->insn_string="lf.sfge.s";
              insn_props->insn_index=62;
              break;
            case 0xc:
              insn_props->insn_string="lf.sflt.s";
              insn_props->insn_index=63;
              break;
            case 0xd:
              insn_props->insn_string="lf.sfle.s";
              insn_props->insn_index=64;
              break;
            default:
              printf("Unknown lf.xxx.s op (0x%x)",
                     insn_or1k_opcode_0x32_get_op_lo(insn));
              break;
            }
          break;
 
        case 0x1:
          switch(insn_or1k_opcode_0x32_get_op_lo(insn))
            {
            case 0x0:
              insn_props->insn_string="lf.add.d";
              insn_props->insn_index=65;
              break;
            case 0x1:
              insn_props->insn_string="lf.sub.d";
              insn_props->insn_index=66;
              break;
            case 0x2:
              insn_props->insn_string="lf.mul.d";
              insn_props->insn_index=67;
              break;
            case 0x3:
              insn_props->insn_string="lf.div.d";
              insn_props->insn_index=68;
              break;
            case 0x4:
              insn_props->insn_string="lf.itof.d";
              insn_props->insn_index=69;
              break;
            case 0x5:
              insn_props->insn_string="lf.ftoi.d";
              insn_props->insn_index=70;
              break;
            case 0x6:
              insn_props->insn_string="lf.rem.d";
              insn_props->insn_index=71;
              break;
            case 0x7:
              insn_props->insn_string="lf.madd.d";
              insn_props->insn_index=72;
              break;
            case 0x8:
              insn_props->insn_string="lf.sfeq.d";
              insn_props->insn_index=73;
              break;
            case 0x9:
              insn_props->insn_string="lf.sfne.d";
              insn_props->insn_index=74;
              break;
            case 0xa:
              insn_props->insn_string="lf.sfgt.d";
              insn_props->insn_index=75;
              break;
            case 0xb:
              insn_props->insn_string="lf.sfge.d";
              insn_props->insn_index=76;
              break;
            case 0xc:
              insn_props->insn_string="lf.sflt.d";
              insn_props->insn_index=77;
              break;
            case 0xd:
              insn_props->insn_string="lf.sfle.d";
              insn_props->insn_index=78;
              break;
            default:
              printf("Unknown lf.xxx.d op (0x%x)",
                     insn_or1k_opcode_0x32_get_op_lo(insn));
              break;
            }
          break;
 
        case 0xd:
          insn_props->insn_string="lf.cust1.s";
          insn_props->insn_index=79;
          break;
 
        case 0xe:
          insn_props->insn_string="lf.cust1.d";
          insn_props->insn_index=80;
          break;
 
        default:
          printf("Unknown lf.xxx opcode hi (0x%x)",
                 insn_or1k_opcode_0x32_get_op_hi(insn));
          return 1;
          break;
        }
      break;
      // The l.sx instructions'd rD is actually in the location rA is for 
      // every other instruction - so we specify has_rA, but really that's 
      // the rD, so it's l.sx imm(rA), rB
    case 0x34:
      insn_props->insn_string="l.sd";
      insn_props->insn_index=81;
      insn_props->has_rA = 1;
      insn_props->has_rB = 1;
      break;
 
    case 0x35:
      insn_props->insn_string="l.sw";
      insn_props->has_rA = 1;
      insn_props->has_rB = 1;
      insn_props->has_split_imm = 1;
      insn_props->insn_index=82;
      break;
 
    case 0x36:
      insn_props->insn_string="l.sb";
      insn_props->has_rA = 1;
      insn_props->has_rB = 1;
      insn_props->has_split_imm = 1;
      insn_props->insn_index=83;
      break;
 
    case 0x37:
      insn_props->insn_string="l.sh";
      insn_props->has_rA = 1;
      insn_props->has_rB = 1;
      insn_props->has_split_imm = 1;
      insn_props->insn_index=84;
      break;
 
    case 0x38:
       insn_props->has_rD = 1;
       insn_props->has_rA = 1;
       insn_props->has_rB = 1;
       switch(insn_or1k_opcode_0x38_get_op_lo(insn))
         {
         case 0x0:
          insn_props->insn_string="l.add";
          insn_props->insn_index=85;
          break;
        case 0x1:
          insn_props->insn_string="l.addc";
          insn_props->insn_index=86;
          break;
        case 0x2:
          insn_props->insn_string="l.sub";
          insn_props->insn_index=87;
          break;
        case 0x3:
          insn_props->insn_string="l.and";
          insn_props->insn_index=88;
          break;
        case 0x4:
          insn_props->insn_string="l.or";
          insn_props->insn_index=89;
          break;
        case 0x5:
          insn_props->insn_string="l.xor";
          insn_props->insn_index=90;
          break;
        case 0x6:
          insn_props->insn_string="l.mul";
          insn_props->insn_index=91;
          break;
        case 0x8:
          switch (insn_or1k_opcode_0x38_get_op_hi_4bit(insn))
            {
            case 0x0:
              insn_props->insn_string="l.sll";
              insn_props->insn_index=92;
              break;
            case 0x1:
              insn_props->insn_string="l.srl";
              insn_props->insn_index=93;
              break;
            case 0x2:
              insn_props->insn_string="l.sra";
              insn_props->insn_index=94;
              break;
            case 0x3:
              insn_props->insn_string="l.ror";
              insn_props->insn_index=95;
              break;
            default:
              printf("Unknown ALU op 0x8 hi op (0x%x)",
                     insn_or1k_opcode_0x38_get_op_hi_4bit(insn));
              return 1;
              break;
            }
          break;
        case 0x9:
          insn_props->insn_string="l.div";
          insn_props->insn_index=96;
          break;
        case 0xa:
          insn_props->insn_string="l.divu";
          insn_props->insn_index=97;
          break;
        case 0xb:
          insn_props->insn_string="l.mulu";
          insn_props->insn_index=98;
          break;
        case 0xc:
          switch(insn_or1k_opcode_0x38_get_op_hi_4bit(insn))
            {
            case 0x0:
              insn_props->insn_string="l.exths";
              insn_props->insn_index=99;
              break;
            case 0x1:
              insn_props->insn_string="l.extbs";
              insn_props->insn_index=100;
              break;
            case 0x2:
              insn_props->insn_string="l.exthz";
              insn_props->insn_index=101;
              break;
            case 0x3:
              insn_props->insn_string="l.extbz";
              insn_props->insn_index=102;
              break;
            }
          insn_props->has_rB = 0;
          break;
 
        case 0xd:
          switch(insn_or1k_opcode_0x38_get_op_hi_4bit(insn))
            {
            case 0x0:
              insn_props->insn_string="l.extws";
              insn_props->insn_index=103;
              break;
            case 0x1:
              insn_props->insn_string="l.extwz";
              insn_props->insn_index=104;
              break;
            }
          insn_props->has_rB = 0;
          break;
 
        case 0xe:
          insn_props->insn_string="l.cmov";
          insn_props->insn_index=105;
          break;
 
        case 0xf:
          if (insn_or1k_opcode_0x38_get_op_hi_2bit(insn) & 0x1)
            {
              insn_props->insn_string="l.fl1";
              insn_props->insn_index=106;
            }
          else
            {
              insn_props->insn_string="l.ff1";
              insn_props->insn_index=107;
            }
          insn_props->has_rB = 0;
          break;
 
        default:
          printf("Unknown ALU lo op (0x%x)",
                 insn_or1k_opcode_0x38_get_op_lo(insn));
          return 1;
          break;
        }
      break;
 
    case 0x39:
      insn_props->has_rA = 1;
      insn_props->has_rB = 1;
      switch (insn_or1k_opcode_0x39_get_op(insn))
        {
        case 0x0:
          insn_props->insn_string="l.sfeq";
          insn_props->insn_index=108;
          break;
        case 0x1:
          insn_props->insn_string="l.sfne";
          insn_props->insn_index=109;
          break;
        case 0x2:
          insn_props->insn_string="l.sfgtu";
          insn_props->insn_index=110;
          break;
        case 0x3:
          insn_props->insn_string="l.sfgeu";
          insn_props->insn_index=111;
          break;
        case 0x4:
          insn_props->insn_string="l.sfltu";
          insn_props->insn_index=112;
          break;
        case 0x5:
          insn_props->insn_string="l.sfleu";
          insn_props->insn_index=113;
          break;
        case 0xa:
          insn_props->insn_string="l.sfgts";
          insn_props->insn_index=114;
          break;
        case 0xb:
          insn_props->insn_string="l.sfges";
          insn_props->insn_index=115;
          break;
        case 0xc:
          insn_props->insn_string="l.sflts";
          insn_props->insn_index=116;
          break;
        case 0xd:
          insn_props->insn_string="l.sfles";
          insn_props->insn_index=117;
          break;
        default:
          printf("Unknown opcode for l.sfxxx opcode (0x%x)",
                 insn_or1k_opcode_0x39_get_op(insn));
          return 1;
          break;
        }
      break;
 
    default:
      printf("Unknown opcode 0x%x",insn_or1k_opcode(insn));
      return 1;
      break;
    }
 
  return 0;
}
 
// Function to track entire instructions, regardless of architecture
// Storage list:
// Format: [0] - binary copy of instruction
//         [1] - occurrence count
uint32_t (*bin_insn_list)[2] = NULL;
int bin_insn_list_count = -1;
#define NUM_EXPECTED_UNIQUE_INSNS 50000
void record_bin_insn(uint32_t insn)
{
  // Check if the array has been initialised yet
  if (bin_insn_list_count == -1)
    {
      bin_insn_list = calloc((NUM_EXPECTED_UNIQUE_INSNS*2)*sizeof(uint32_t),1);
      bin_insn_list_count = 0;
    }
 
  int list_check_itr;
  // Go through the list, check if we've seen this one before
  for(list_check_itr=0;list_check_itr<bin_insn_list_count;list_check_itr++)
    if (bin_insn_list[list_check_itr][0] == insn)
      {
        // Seen it before, just increment count
        bin_insn_list[list_check_itr][1]++;
        return;
      }
 
 
  // If we're here, we've not seen this one before, it's new
 
  // No room left in list to add new ones
  if ( bin_insn_list_count == NUM_EXPECTED_UNIQUE_INSNS )
    return;
 
  // Add it to the list
  bin_insn_list[bin_insn_list_count][0] = insn;
  bin_insn_list[bin_insn_list_count][1] = 1;
 
  bin_insn_list_count++;
 
  // No room left in list to add new ones
  if ( bin_insn_list_count == NUM_EXPECTED_UNIQUE_INSNS )
    fprintf(stderr, "Warning: bin_insn_list[][] full (%d entries)\n",
            NUM_EXPECTED_UNIQUE_INSNS);
 
 
}
 
// Entry point for statistics collection.
// Passed binary copy of instruction, and pointer to properties struct
// Each function that can collect staistics is called.
void or1k_32_collect_stats(uint32_t insn,
                           struct or1k_32_instruction_properties  * insn_props,
                           int record_bin_insns)
{
  // Add this instruction's occurrence to our data
  insn_lists_add(insn, insn_props);
 
  // n-tuple groupings stats recording here!  
  // only if we've seen enough to do all the sequence analysis
  if (num_seen_insns > OR1K_MAX_GROUPINGS_ANALYSIS+1)
    {
      int n;
      for(n=2;n<OR1K_MAX_GROUPINGS_ANALYSIS+1;n++)
        insn_lists_group_add(n, insn_props);
    }
 
  if (record_bin_insns)
    record_bin_insn(insn);
 
  // Finished adding to stats for this instruction
 
}
 
// Function to add entry to, or increment incidences of, value in the value list
void or1k_add_in_list(struct or1k_value_list * list, int32_t value)
{
  int i;
  // See if it's already in the list
  i=list->count;
 
  while(i)
    {
      i--;
      if(list->values[i][0] == value)
        {
          (list->values[i][1])++;
          return;
        }
    }
 
  if (list->count < OR1K_VALUE_MAX_ENTRIES)
    {
      // Not found, add it to the list
      list->values[(list->count)][0] = value;
      list->values[(list->count)][1] = 1;
      list->count++;
    }
}
 
// List management/analysis functions - accessed through insn_lists() set of
// functions
 
// Clear the list structs
void or1k_32_insn_lists_init(void)
{
  num_setup_insns = 0;
  num_seen_insns = 0;
  // Clear the pointer array so we can tell if things are used or not
  memset(or1k_32_insns, '\0',
         sizeof(struct or1k_insn_info *)*OR1K_32_MAX_INSNS);
}
 
// Alloc struct and put it into the list
void or1k_32_insn_lists_init_insn(uint32_t insn,
                        struct or1k_32_instruction_properties *insn_props)
{
  // Add an instruction in or1k_32_insns[num_unique_instructions];
  // use calloc() so it clears it all first (hopefully!).. assumption!
  struct or1k_insn_info * new_insn
    = (struct or1k_insn_info *) calloc (sizeof(struct or1k_insn_info), 1);
 
  // Copy the string pointer
  new_insn->insn_string = insn_props->insn_string,
 
  // Install the pointer for this newly allocated struct in its corresponding
  // index, as set when we decode the instruction
  or1k_32_insns[insn_props->insn_index] = new_insn;
 
  // Clear the set statistics counters
  int set_itr;
  for(set_itr=0;set_itr<OR1K_MAX_GROUPINGS_ANALYSIS;set_itr++)
    or1k_32_insns[insn_props->insn_index]->groupings[set_itr][0][0] = 0;
 
  // Increment number of instructions we have set up
  num_setup_insns++;
 
  // Debugging:
  //printf("Adding %dth instruction - %s\n",
  //num_setup_insns, new_insn->insn_string);
 
}
 
 
 
// Add stats for this instruction
void or1k_32_insn_lists_add(uint32_t insn,
                            struct or1k_32_instruction_properties *insn_props)
{
  // Check if the entry for this instruction has been setup yet
  if (or1k_32_insns[insn_props->insn_index] == NULL)
    {
      // Here we allocate space for the instruction's stats
      or1k_32_insn_lists_init_insn(insn, insn_props);
    }
 
  // Increment occurrence count
  ((or1k_32_insns[insn_props->insn_index])->count)++;
 
  // Add branch target value information, if instruction has it
  if (insn_props->has_branchtarg)
    {
      (or1k_32_insns[insn_props->insn_index])->has_branchtarg = 1;
      or1k_add_in_list(&((or1k_32_insns[insn_props->insn_index])->branch_info),
                       (int32_t)insn_or1k_opcode_0x03_get_branchoff(insn));
    }
 
  // Add immediate value if it's got one
  if (insn_props->has_imm)
    {
      (or1k_32_insns[insn_props->insn_index])->has_imm = 1;
      or1k_add_in_list(&((or1k_32_insns[insn_props->insn_index])->imm_info),
                       (int32_t)insn_or1k_32_imm(insn));
    }
 
  // Add split immediate value if it's got one
  if (insn_props->has_split_imm)
    {
      (or1k_32_insns[insn_props->insn_index])->has_imm = 1;
      or1k_add_in_list(&((or1k_32_insns[insn_props->insn_index])->imm_info),
                       (int32_t)insn_or1k_32_split_imm(insn));
    }
 
 
  // Increment count of use for particular rD
  if (insn_props->has_rD)
    {
      (or1k_32_insns[insn_props->insn_index])->has_rD = 1;
      ((or1k_32_insns[insn_props->insn_index])->rD_use_freq[insn_or1k_32_rD(insn)])++;
    }
 
  // Increment count of use for particular rA
  if (insn_props->has_rA)
    {
      (or1k_32_insns[insn_props->insn_index])->has_rA = 1;
      ((or1k_32_insns[insn_props->insn_index])->rA_use_freq[insn_or1k_32_rA(insn)])++;
    }
 
  // Increment count of use for particular rB
  if (insn_props->has_rB)
    {
      (or1k_32_insns[insn_props->insn_index])->has_rB = 1;
      ((or1k_32_insns[insn_props->insn_index])->rB_use_freq[insn_or1k_32_rB(insn)])++;
    }
 
  // Increment overall instructions "seen" counter
  num_seen_insns++;
 
  // Shift along the recently seen instructions
  int i;
  for(i=OR1K_MAX_GROUPINGS_ANALYSIS-1;i>0;i--)
    or1k_32_recent_insns[i] = or1k_32_recent_insns[i-1];
  or1k_32_recent_insns[0] = insn_props->insn_index;
 
}
 
 
 
 
// Do the n-tuple set checking for the current instruction
void or1k_32_ntuple_add(int n,
                        struct or1k_32_instruction_properties *insn_props)
{
 
  if (n<2)
    {
      fprintf(stderr,"or1k_32_ntuple_add: tuple number < 2 (%d)",n);
      return;
    }
 
  struct or1k_insn_info * insn_info = or1k_32_insns[insn_props->insn_index];
 
  // Get the number of sets for these n-tuple groups we've seen so far.
  int sets_for_ntuple = insn_info->groupings[n-1][0][0];
#if DEBUG_PRINT
  printf("%s\t:\t%d-tuple add - sets so far : %d\n",
         insn_info->insn_string, n, sets_for_ntuple);
#endif
 
  int set_match_index;
  int tuple_set_itr, tuple_set_match;
 
  tuple_set_match = 0;
 
  // now find if the current n instructions in or1k_32_recent_insns[] matches
  // any set of n instructions we're keeping track of in groupings[][][].
#if DEBUG_PRINT
  printf("%s\tChecking\t%d\tsets for ntuple:\t",
         insn_info->insn_string,sets_for_ntuple);
  for(tuple_set_itr=0;tuple_set_itr<n;tuple_set_itr++)
    printf("%s ",
           or1k_32_insns[(or1k_32_recent_insns[n - 1 - tuple_set_itr])]->insn_string);
  printf("\n");
#endif  
  for (set_match_index=0; set_match_index<sets_for_ntuple; set_match_index++)
    {
      // Check this set for a match with our existing trace
      // Example:
      // In case of a triple (n=3), 1st set, [3][1][0] corresponds to the third
      // instruction in the trace (or1k_32_recent_insns[2]), [3][1][1] should 
      // be the second in the trace, and [3][1][2] should be the first in the 
      // trace (same index as insn_props->insn_index)
 
#if DEBUG_PRINT
      printf("Chk:\t");
      for(tuple_set_itr=0;tuple_set_itr<n;tuple_set_itr++)
        printf("%s ",
               or1k_32_insns[(insn_info->groupings[n-1][set_match_index+1][tuple_set_itr])]->insn_string);
      printf("\t(%d)\n", insn_info->groupings[n-1][set_match_index+1][n]);
#endif      
      tuple_set_match = 1;
      // Presuppose a match, de-assert and break out of the loop as soon as we
      // detect a mismatch.
      for(tuple_set_itr=0;tuple_set_itr<n;tuple_set_itr++)
        {
 
          if (insn_info->groupings[n-1][set_match_index+1][tuple_set_itr]
              != or1k_32_recent_insns[n - 1 - tuple_set_itr])
            {
              tuple_set_match = 0;
              break; // No match, so break out of this for() loop
            }
        }
 
      if (!tuple_set_match)
        continue; // go again...
      else
        break; // Bail out, we've found our match
    }
 
  if (tuple_set_match)
    {
      // Found a match - just increment the counter (set_match_index should
      // be pointing at the right set)            
#if DEBUG_PRINT
      printf("Match!\n");
#endif
 
      (insn_info->groupings[n-1][set_match_index+1][n])++;
    }
  else
    {
      // If we can record a new set
      if (sets_for_ntuple < OR1K_MAX_ENTRIES_PER_GROUP)
        {
#if DEBUG_PRINT
          printf("New entry\n");
#endif
 
          // Increment the number of sets we have for this n-tuple starting
          // on the current instruction  
          sets_for_ntuple++;
          // Add new set to the end (all n instructions, copy in)
          for(tuple_set_itr=0;tuple_set_itr<n;tuple_set_itr++)
            insn_info->groupings[n-1][sets_for_ntuple][tuple_set_itr]
              = or1k_32_recent_insns[n - 1 - tuple_set_itr];
          // Set the count for this set to 1
          (insn_info->groupings[n-1][sets_for_ntuple][n]) = 1;
          // Increment the counter of these n-tuple sets
          insn_info->groupings[n-1][0][0] = sets_for_ntuple;
        }
    }
 
#if DEBUG_PRINT
  // Verbose announcement of found instruction
   if (tuple_set_match)
  {
     printf("%s\t:\tMatch for %d-tuple - set %d - cnt: %d - ",
      insn_info->insn_string, n, set_match_index,
             insn_info->groupings[n-1][set_match_index+1][n]);
    for(tuple_set_itr=0;tuple_set_itr<n;tuple_set_itr++)
        printf("%s ",
               or1k_32_insns[(insn_info->groupings[n-1][sets_for_ntuple][tuple_set_itr])]->insn_string);
    printf("\n");
  }
  else
    {
     printf("%s\t:\tNew %d-tuple - set %d - cnt: %d - ",
             insn_info->insn_string, n, sets_for_ntuple,
             insn_info->groupings[n-1][sets_for_ntuple][n]);
    for(tuple_set_itr=0;tuple_set_itr<n;tuple_set_itr++)
        printf("%s ",
               or1k_32_insns[(insn_info->groupings[n-1][sets_for_ntuple][tuple_set_itr])]->insn_string);
    printf("\n");
  }
#endif
 
}
 
// Generate a list for the most-frequently seen instructions
void or1k_32_most_freq_insn(FILE * stream)
{
  // Print out most frequent instruction
  int i, largest, largest_index;
  int instructions_to_print = num_setup_insns;
 
#ifdef DISPLAY_CSV
  fprintf(stream,"\"Most frequent instructions, descending\",\n");
  fprintf(stream,"\"Instruction\",\"Occurrences\",\"Frequency\",\n");
#endif
 
  while (instructions_to_print)
    {
      --instructions_to_print;
      largest=0;
      // Go through the list, find the largest, print it, eliminate it
      for(i=0;i<OR1K_32_MAX_INSNS;i++)
        if (or1k_32_insns[i]!=NULL){
          if(((or1k_32_insns[i])->count) > largest)
            {
              largest = ((or1k_32_insns[i])->count);
              largest_index = i;
            }
        }
      fprintf(stream,
#ifdef DISPLAY_STRING      
             "Insn:\t%s\t\tCount:\t\t%d\t(%f%%)\n",
#endif
#ifdef DISPLAY_CSV
             // CSV format - "opcode string",frequency,percentage
             "\"%s\",%d,%f\n",
#endif
             ((or1k_32_insns[largest_index])->insn_string),
             ((or1k_32_insns[largest_index])->count),
             (float)(((float)((or1k_32_insns[largest_index])->count))/
                     ((float)num_seen_insns)));
 
 
      ((or1k_32_insns[largest_index])->count) = -1; // Eliminate this one
 
    }
}
 
 
// Generate a list for the most-frequently seen n-tuple set
void or1k_32_most_freq_ntuple(int n, FILE * stream, int max_stats)
{
 
  fprintf(stream,
#ifdef DISPLAY_STRING
          "Top %d %d-tuple groupings of instructions\n",
#endif
#ifdef DISPLAY_CSV
          "\"Top %d %d-tuple groupings of instructions\",\n",
#endif
          max_stats, n);
 
  // First get a copy of all the n-tuple values for each applicable
  // instruction.
  int set_counts[OR1K_32_MAX_INSNS][OR1K_MAX_ENTRIES_PER_GROUP];
  int insn_index;
  int set_index;
  int num_sets;
  struct or1k_insn_info *insn_info;
 
  // Copy each instruction's set totals into our local array
  for(insn_index=0;insn_index<OR1K_32_MAX_INSNS;insn_index++)
    {
      if (or1k_32_insns[insn_index] != NULL)
        {
          insn_info = or1k_32_insns[insn_index];
          num_sets = insn_info->groupings[n-1][0][0];
          for(set_index=0;set_index<num_sets;set_index++)
            set_counts[insn_index][set_index] =
              insn_info->groupings[n-1][set_index+1][n];
        }
    }
 
  // Go through the set numbers, look at the most frequent one, print it out
  // clear its count and continue
 
 
  int largest_insn_index, largest_set_index, largest_count;
  int tuple_set_itr;
 
 
#ifdef DISPLAY_CSV
  for(tuple_set_itr=0;tuple_set_itr<n;tuple_set_itr++)
    fprintf(stream, "\"insn%d\",",n-1-tuple_set_itr);
  fprintf(stream, "\"count\",\n");
#endif
 
  while(max_stats--)
    {
      largest_count = 0;
      // Go through each instruction we have
      for(insn_index=0;insn_index<OR1K_32_MAX_INSNS;insn_index++)
        {
          if (or1k_32_insns[insn_index] != NULL)
            {
              insn_info = or1k_32_insns[insn_index];
              // Get the total number of sets for the n-tup. of this instruction
              num_sets = insn_info->groupings[n-1][0][0];
              for(set_index=0;set_index<num_sets;set_index++)
                {
                  // Go through each set, check if it's largest
                  if (set_counts[insn_index][set_index] >
                      largest_count)
                    {
                      largest_insn_index = insn_index;
                      largest_set_index = set_index;
                      largest_count = set_counts[insn_index][set_index];
                    }
                }
            }
        }
 
      // We now have indexes of the next largest n-tuple, print it out.
 
      insn_info = or1k_32_insns[largest_insn_index];
 
#ifdef DISPLAY_STRING
      fprintf(stream,"set :");
#endif
 
      for(tuple_set_itr=0;tuple_set_itr<n;tuple_set_itr++)
        fprintf(stream,
#ifdef DISPLAY_STRING
                " %s",
#endif
#ifdef DISPLAY_CSV
                "\"%s\",",
#endif
                or1k_32_insns[(insn_info->groupings[n-1][largest_set_index+1][tuple_set_itr])]->insn_string);
 
      fprintf(stream,
#ifdef DISPLAY_STRING
              "\tcount: %d\n",
#endif
#ifdef DISPLAY_CSV
              "%d,\n",
#endif
              set_counts[largest_insn_index][largest_set_index]);
 
        // Remove this value from getting selected from largest again
        set_counts[largest_insn_index][largest_set_index] = -1;
    }
 
}
 
 
 
 
// Print out top n of each kept statistic for the requested instruction
void or1k_32_insn_top_n(struct or1k_insn_info *insn_info, FILE * stream,
                        int max_stats)
{
  int i, j, largest_i;
 
  fprintf(stream,
#ifdef DISPLAY_STRING
          "Insn: \"%s\" statistics (%d times (%f%%))\n",
#endif
#ifdef DISPLAY_CSV
          "\"Instruction:\",\"%s\",\"occurrences:\",%d,%f%%\n",
#endif
          insn_info->insn_string,
          insn_info->count,
          (float)(((float)((insn_info)->count))/
                  ((float)num_seen_insns))
          );
 
 
 
  // Start dumping applicable stats
 
  // Print out top max_stats branch targets
  if (insn_info->has_branchtarg)
    {
      fprintf(stream,
#ifdef DISPLAY_STRING
              "Branch immediates:\n"
#endif
#ifdef DISPLAY_CSV
              "\"branch imm\",\"occurrences\",\"frequency\"\n"
#endif
              );
      i = 0;
      while(i<insn_info->branch_info.count && i < max_stats)
        {
          largest_i=0;
          for(j=0;j<insn_info->branch_info.count;j++)
            largest_i = (insn_info->branch_info.values[j][1] >
                         insn_info->branch_info.values[largest_i][1]) ?
              j : largest_i;
 
          // largest_i has index of most frequent value
          fprintf(stream,
#ifdef DISPLAY_STRING
                  "value:\t0x%x\tcount:\t%d,\tfreq:\t%f%%\n",
#endif
#ifdef DISPLAY_CSV
                  "0x%x,%d,%f\n",
#endif
                  insn_info->branch_info.values[largest_i][0],
                  insn_info->branch_info.values[largest_i][1],
                  (float)(((float)insn_info->branch_info.values[largest_i][1])
                          /((float)((insn_info)->count))));
          insn_info->branch_info.values[largest_i][1] = -1; // clear this one
          i++;
        }
    }
  if (insn_info->has_imm)
    {
      fprintf(stream,
#ifdef DISPLAY_STRING
              "Immediate values:\n"
#endif
#ifdef DISPLAY_CSV
              "\"immediate value\",\"count\",\"frequency\"\n"
#endif
              );
      i = 0;
      while(i<insn_info->imm_info.count && i < max_stats)
        {
          largest_i=0;
          for(j=0;j<insn_info->imm_info.count;j++)
            largest_i = (insn_info->imm_info.values[j][1] >
                         insn_info->imm_info.values[largest_i][1]) ?
              j : largest_i;
 
          // largest_i has index of most frequent value
          fprintf(stream,
#ifdef DISPLAY_STRING
                  "value:\t0x%x\tcount:\t%d\tfreq:\t%f%%\n",
#endif
#ifdef DISPLAY_CSV
                  "0x%x,%d,%f\n",
#endif
                  insn_info->imm_info.values[largest_i][0],
                  insn_info->imm_info.values[largest_i][1],
                  (float)(((float)insn_info->imm_info.values[largest_i][1])
                          /((float)((insn_info)->count))));
          insn_info->imm_info.values[largest_i][1] = -1; // clear this one
          i++;
        }
    }
 
  if (insn_info->has_rD)
    {
      fprintf(stream,
#ifdef DISPLAY_STRING
              "rD usage:\n"
#endif
#ifdef DISPLAY_CSV
              "\"rD\",\"count\",\"frequency\"\n"
#endif
              );
      i = 0;
      while(i<32 && i < max_stats)
        {
          largest_i=0;
          for(j=0;j<32;j++)
            largest_i = (insn_info->rD_use_freq[j] >
                         insn_info->rD_use_freq[largest_i]) ?
              j : largest_i;
 
          // No more interesting numbers
          if (insn_info->rD_use_freq[largest_i] == 0)
            break;
 
          // largest_i has index of most frequent value
          fprintf(stream,
#ifdef DISPLAY_STRING
                  "r%d\tcount:\t%d\tfreq:\t%f%%\n",
#endif
#ifdef DISPLAY_CSV
                  "\"r%d\",%d,%f\n",
#endif
                  largest_i,
                  insn_info->rD_use_freq[largest_i],
                  (float)(((float)insn_info->rD_use_freq[largest_i])
                          /((float)((insn_info)->count))));
          insn_info->rD_use_freq[largest_i] = -1; // clear this one
          i++;
        }
    }
 
  if (insn_info->has_rA)
    {
      fprintf(stream,
#ifdef DISPLAY_STRING
              "rA usage:\n"
#endif
#ifdef DISPLAY_CSV
              "\"rA\",\"count\",\"frequency\"\n"
#endif
              );
      i = 0;
      while(i<32 && i < max_stats)
        {
          largest_i=0;
          for(j=0;j<32;j++)
            largest_i = (insn_info->rA_use_freq[j] >
                         insn_info->rA_use_freq[largest_i]) ?
              j : largest_i;
 
          // No more interesting numbers
          if (insn_info->rA_use_freq[largest_i] == 0)
            break;
 
 
          // largest_i has index of most frequent value
          fprintf(stream,
#ifdef DISPLAY_STRING
                  "r%d\tcount:\t%d\tfreq:\t%f%%\n",
#endif
#ifdef DISPLAY_CSV
                  "\"r%d\",%d,%f\n",
#endif
                  largest_i,
                  insn_info->rA_use_freq[largest_i],
                  (float)(((float)insn_info->rA_use_freq[largest_i])
                          /((float)((insn_info)->count))));
          insn_info->rA_use_freq[largest_i] = -1; // clear this one
          i++;
        }
    }
 
  if (insn_info->has_rB)
    {
      fprintf(stream,
#ifdef DISPLAY_STRING
              "rB usage:\n"
#endif
#ifdef DISPLAY_CSV
              "\"rB\",\"count\",\"frequency\"\n"
#endif
              );
      i = 0;
      while(i<32 && i < max_stats)
        {
          largest_i=0;
          for(j=0;j<32;j++)
            largest_i = (insn_info->rB_use_freq[j] >
                         insn_info->rB_use_freq[largest_i]) ?
              j : largest_i;
 
          // No more interesting numbers
          if (insn_info->rB_use_freq[largest_i] == 0)
            break;
 
 
          // largest_i has index of most frequent value
          fprintf(stream,
#ifdef DISPLAY_STRING
                  "r%d\tcount:\t%d\tfreq:\t%f%%\n",
#endif
#ifdef DISPLAY_CSV
                  "\"r%d\",%d,%f\n",
#endif
                  largest_i,
                  insn_info->rB_use_freq[largest_i],
                  (float)(((float)insn_info->rB_use_freq[largest_i])
                          /((float)((insn_info)->count))));
          insn_info->rB_use_freq[largest_i] = -1; // clear this one
          i++;
        }
    }
}
 
 
 
// Print out the most common n-tuple groupings for an instruction
void or1k_32_generate_ntuple_stats(int n, struct or1k_insn_info *insn_info,
                                   FILE * stream)
{
  // Maximum number we'll print out
#define MAX_NTUPLE_LISTING 5
 
  int (*ntuplelist)[OR1K_MAX_GROUPINGS_ANALYSIS+1];
  int *set;
  int set_count, set_count2;
 
  // Get total number of sets for this n-tuple, eg:
  // if n=2 (pairs) then groupings[1] is where our list is, and we store the 
  // number of sets in [0][0] of that n-tuple data.
  int total_sets_for_ntuple =  insn_info->groupings[n-1][0][0];
 
  if (total_sets_for_ntuple == 0)
    return;
 
  fprintf(stream,
#ifdef DISPLAY_STRING     
          "%d-tuple groupings finishing with %s (%d)\n",
#endif
#ifdef DISPLAY_CSV
          "\"%d-tuple groupings\",\n",
#endif     
          n, insn_info->insn_string, total_sets_for_ntuple);
 
 
  // Debug - dump out all of the info for the sets
#if DEBUG_PRINT
  for (set_count = 0;set_count <total_sets_for_ntuple;set_count++)
    {
 
      printf("set: %d - count %d - set: ", set_count,
             insn_info->groupings[n-1][set_count+1][n]);
 
      for(set_count2=0;set_count2<n;set_count2++)
        fprintf(stream, "%s\t",
                or1k_32_insns[(insn_info->groupings[n-1][set_count+1][set_count2])]->insn_string);
      printf("\n");
    }
#endif
 
  // A pointer to the n-tuple sets
  // This is actually a pointer to a 2-dimensional integer array, looking like:
  // [OR1K_MAX_ENTRIES_PER_GROUP+1][OR1K_MAX_GROUPINGS_ANALYSIS+1], so in 
  // 2-dimensional array pointer fashion, we should provide the "column" sizing.
      ntuplelist = insn_info->groupings[n-1];
 
  // Let's make a copy of the counts for each... so we don't trash them
  int set_count_copy[OR1K_MAX_ENTRIES_PER_GROUP+1];
 
  assert(total_sets_for_ntuple <= OR1K_MAX_ENTRIES_PER_GROUP);
 
  // Go through the list, copy the counts for each
  for (set_count = 0;set_count <total_sets_for_ntuple;set_count++)
    {
      // Pointer to a set's data
      set = ntuplelist[set_count+1];
      // Fish out the copy (0 to n-1 will be the instruction index, n will be 
      // the count)
      set_count_copy[set_count+1] = set[n];
    }
 
 
#ifdef DISPLAY_CSV
      for(set_count2=0;set_count2<n;set_count2++)
        fprintf(stream, "\"insn%d\",",n-1-set_count2);
      fprintf(stream, "\"count\",\n");
#endif
 
 
  // Now go through, finding the most frequent n-tuple of instructions and
  // print it out
  int largest_indx = 0;
  set_count=0;
  while(set_count < total_sets_for_ntuple && set_count < MAX_NTUPLE_LISTING)
    {
      largest_indx = 0;
      for(set_count2=0;set_count2<total_sets_for_ntuple;set_count2++)
        largest_indx = (set_count_copy[set_count2 + 1] >
                        set_count_copy[largest_indx + 1]) ?
          set_count2 : largest_indx;
      // largest_indx is the index of the set with the highest occurrence, so
      // let's print it out, but first get a pointer to the set's data
      set = (int*)ntuplelist[largest_indx+1];
 
      // Print out the sequence of prior isntructions
#ifdef DISPLAY_STRING
      fprintf(stream,"Seq:\t");
#endif
      // Go through the indexes of the previous instructions, get their
      // strings, and print them out
      for(set_count2=0;set_count2<n;set_count2++)
        fprintf(stream,
#ifdef DISPLAY_STRING
                "%s\t",
#endif
#ifdef DISPLAY_CSV
                "\"%s\",",
#endif
                or1k_32_insns[(set[set_count2])]->insn_string);
 
      // now print out the occurrences
      fprintf(stream,
#ifdef DISPLAY_STRING
              "\t%d\ttimes (%f%%)\n",
#endif
#ifdef DISPLAY_CSV
              "%d,\n",
#endif
              set[n],
              (float)((float)set[n]/(float)insn_info->count));
 
      // done printing this one out.. let's clear its count
      set_count_copy[largest_indx + 1] = -1;
 
      set_count++;
    }
 
  return;
 
}
 
 
// Print out the top n seen entire instructions
void print_top_bin_insn(FILE * stream, int n)
{
  int largest_indx = 0;
  int bin_insn_list_itr;
 
  // Copy the counts, so we can trash them as needed
  int bin_insn_counts[NUM_EXPECTED_UNIQUE_INSNS];
 
  // An instruction properties object
  struct or1k_32_instruction_properties insn_props;
 
  for(bin_insn_list_itr=0;bin_insn_list_itr<bin_insn_list_count;
      bin_insn_list_itr++)
    bin_insn_counts[bin_insn_list_itr] = bin_insn_list[bin_insn_list_itr][1];
 
#ifdef DISPLAY_STRING
  fprintf(stream, "Top %d seen instructions\n", n);
  fprintf(stream, "Saw %d unique instructions\n", bin_insn_list_count);
#endif
#ifdef DISPLAY_CSV
  fprintf(stream, ",\n");
  fprintf(stream,"\"Top %d instructions\",\n\"Total unique instructions\",%d\n",
          n, bin_insn_list_count);
  fprintf(stream,
          "\"Instruction (bin)\",\"Dissassembly\",\"Occurrences\",\"Freq\"\n");
#endif
 
  while (n--)
    {
      // Search for the largest count
      for(bin_insn_list_itr=0;bin_insn_list_itr<bin_insn_list_count;
          bin_insn_list_itr++)
        largest_indx = (bin_insn_counts[bin_insn_list_itr] >
                        bin_insn_counts[largest_indx]) ?
          bin_insn_list_itr : largest_indx;
 
      // Gone through list, largest_indx is the biggest index
 
      // Clear the instruction properties struct
      memset(&insn_props, 0, sizeof(struct or1k_32_instruction_properties));
 
      // Get the string for this instruction
      or1k_32_analyse_insn(bin_insn_list[largest_indx][0], &insn_props);
 
      // Print out the instruction
#ifdef DISPLAY_STRING
      fprintf(stream, "Insn:\t0x%.8x\t%s",bin_insn_list[largest_indx][0],
              insn_props.insn_string);
#endif
#ifdef DISPLAY_CSV
      fprintf(stream, "\"0x%.8x\",\"%s",bin_insn_list[largest_indx][0],
              insn_props.insn_string);
#endif
 
      if (insn_props.has_jumptarg || insn_props.has_branchtarg)
#ifdef DISPLAY_STRING
        fprintf(stream, " 0x%x", (bin_insn_list[largest_indx][0] & JUMPTARG_MASK) << 2 );
#endif
#ifdef DISPLAY_CSV
        fprintf(stream, " 0x%x",  (bin_insn_list[largest_indx][0] & JUMPTARG_MASK) << 2 );
#endif
 
 
      if (insn_props.has_rD)
#ifdef DISPLAY_STRING
        fprintf(stream, " r%d",
                insn_or1k_32_rD(bin_insn_list[largest_indx][0]));
#endif
#ifdef DISPLAY_CSV
        fprintf(stream, " r%d",
                insn_or1k_32_rD(bin_insn_list[largest_indx][0]));
#endif
 
      if (insn_props.has_rA)
#ifdef DISPLAY_STRING
        fprintf(stream, " r%d",
                insn_or1k_32_rA(bin_insn_list[largest_indx][0]));
#endif
#ifdef DISPLAY_CSV
        fprintf(stream, " r%d",
                insn_or1k_32_rA(bin_insn_list[largest_indx][0]));
#endif
 
      if (insn_props.has_rB)
#ifdef DISPLAY_STRING
        fprintf(stream, " r%d",
                insn_or1k_32_rB(bin_insn_list[largest_indx][0]));
#endif
#ifdef DISPLAY_CSV
        fprintf(stream, " r%d",
                insn_or1k_32_rB(bin_insn_list[largest_indx][0]));
#endif
 
 
      if (insn_props.has_imm)
#ifdef DISPLAY_STRING
        fprintf(stream, " 0x%x",
                insn_or1k_32_imm(bin_insn_list[largest_indx][0]));
#endif
#ifdef DISPLAY_CSV
        fprintf(stream, " 0x%x",
                insn_or1k_32_imm(bin_insn_list[largest_indx][0]));
#endif
 
      if (insn_props.has_split_imm)
#ifdef DISPLAY_STRING
        fprintf(stream, " 0x%x",
                insn_or1k_32_split_imm(bin_insn_list[largest_indx][0]));
#endif
#ifdef DISPLAY_CSV
        fprintf(stream, " 0x%x",
                insn_or1k_32_split_imm(bin_insn_list[largest_indx][0]));
#endif
 
#ifdef DISPLAY_STRING
        fprintf(stream, "\tcount:\t%d (%f%%)\n",bin_insn_list[largest_indx][1],
                (float)((float)bin_insn_list[largest_indx][1])/
                ((float)num_seen_insns));
#endif
#ifdef DISPLAY_CSV
        fprintf(stream, "\",%d,%f\n",bin_insn_list[largest_indx][1],
                (float)((float)bin_insn_list[largest_indx][1])/
                ((float)num_seen_insns));
#endif
 
        // Finished printing out its instruction
        bin_insn_counts[largest_indx] = -1;
 
    }
}
 
 
// Print out the stats relating to the sequences of instructions most
// common before seeing this instruction
void or1k_32_generate_groupings_stats(struct or1k_insn_info *insn_info,
                                      FILE * stream)
{
  int n;
  for(n=2;n<OR1K_MAX_GROUPINGS_ANALYSIS+1;n++)
    or1k_32_generate_ntuple_stats(n, insn_info, stream);
 
}
 
// Entry point for statistics generation.    
void or1k_32_generate_stats(FILE * stream)
{
#ifdef DISPLAY_STRING
  // Generate some useful things
  fprintf(stream, "Analysis output:\n");
#endif  
  // 
 
  // Print out all stats for every instruction we saw!
  int insn_index;
  for(insn_index=0;insn_index<OR1K_32_MAX_INSNS;insn_index++)
    {
      if (or1k_32_insns[insn_index] != NULL)
        {
#ifdef DISPLAY_STRING
          fprintf(stream, "\t---\t---\t---\t---\n");
#endif
#ifdef DISPLAY_CSV
          fprintf(stream, ",\n");
#endif
          or1k_32_insn_top_n(or1k_32_insns[insn_index],stream,10);
          or1k_32_generate_groupings_stats(or1k_32_insns[insn_index],stream);
 
        }
    }
 
#ifdef DISPLAY_STRING
          fprintf(stream, "\t---\t---\t---\t---\n");
#endif
#ifdef DISPLAY_CSV
          fprintf(stream, ",\n");
#endif
 
 
  // print out most frequent n-tuple
  int ntuple;
  for(ntuple=2;ntuple<5;ntuple++)
    or1k_32_most_freq_ntuple(ntuple, stream, 10);
 
 
#ifdef DISPLAY_STRING
          fprintf(stream, "\t---\t---\t---\t---\n");
#endif
#ifdef DISPLAY_CSV
          fprintf(stream, ",\n");
#endif
 
 
  // Do most frequent instruction analysis -- note this trashes instruction
  // frequency count - should be fixed
#ifdef DISPLAY_STRING
  fprintf(stream, "Individual instruction frequency:\n");
#endif
  or1k_32_most_freq_insn(stream);
 
  // If we did the binary instruction frequency counting, print it out
  if (bin_insn_list_count != -1)
    print_top_bin_insn(stream, 20);
 
}
 
 
 
// Free up all added instruction statistic tracking structs
void or1k_32_insn_lists_free(void)
{
  // Free all entries we m/calloc()'d
  int insn_index;
  for(insn_index=0;insn_index<OR1K_32_MAX_INSNS;insn_index++)
    {
      if (or1k_32_insns[insn_index] != NULL)
        free(or1k_32_insns[insn_index]);
    }
 
  if (bin_insn_list_count != -1)
    free(bin_insn_list);
}

Line No.	Rev	Author	Line
1	17	julius	`/*`
2			`Or1K instruction set-specific decoding and analysis functions.`
3
4			`Julius Baxter, julius.baxter@orsoc.se`
5
6			`*/`
7
8
9	16	julius	`#include "stdio.h"`
10			`#include "stdint.h"`
11			`#include "stdlib.h"`
12			`#include "string.h"`
13	20	julius	`#include "assert.h"`
14	16	julius	`#include "or1k-32-insn.h"`
15
16	22	julius	`// Define the appropriate instruction type, and instruction_properties type`
17			`// These should also be defined in insnanalysis.h`
18	16	julius	`typedef uint32_t instruction;`
19			`typedef struct or1k_32_instruction_properties instruction_properties ;`
20
21			`#include "insn-lists.h"`
22
23	19	julius	`// Variable to keep track of unique instructions we have`
24			`int num_setup_insns;`
25			`int num_seen_insns;`
26
27			`struct or1k_insn_info * or1k_32_insns[OR1K_32_MAX_INSNS];`
28
29			`// Keep enough instructions required to do the maximum n-tuple set`
30			`// analysis.`
31			`int or1k_32_recent_insns[OR1K_MAX_GROUPINGS_ANALYSIS];`
32
33	22	julius	`// Function to take the raw binary instruction, and configure the insn_props`
34			`// struct with the appropriate settings for that instruction (string, attributes`
35			`// etc.)`
36			`// TODO: vector instructions aren't picked up - but compiler never generates`
37			`// them, so not a big issue.`
38	16	julius	`int or1k_32_analyse_insn(uint32_t insn,`
39			`struct or1k_32_instruction_properties * insn_props)`
40			`{`
41
42			`switch(insn_or1k_opcode(insn))`
43			`{`
44			`case 0x00:`
45			`insn_props->insn_string="l.j";`
46	18	julius	`insn_props->insn_index=0;`
47	16	julius	`insn_props->has_jumptarg = 1;`
48			`break;`
49
50			`case 0x01:`
51			`insn_props->insn_string="l.jal";`
52	18	julius	`insn_props->insn_index=1;`
53	16	julius	`insn_props->has_jumptarg = 1;`
54			`break;`
55
56			`case 0x03:`
57			`insn_props->insn_string="l.bnf";`
58	18	julius	`insn_props->insn_index=2;`
59	16	julius	`insn_props->has_branchtarg = 1;`
60			`break;`
61
62			`case 0x04:`
63			`insn_props->insn_string="l.bf";`
64	18	julius	`insn_props->insn_index=3;`
65	16	julius	`insn_props->has_branchtarg = 1;`
66			`break;`
67
68			`case 0x05:`
69			`insn_props->insn_string="l.nop";`
70	18	julius	`insn_props->insn_index=4;`
71	16	julius	`break;`
72
73			`case 0x06:`
74			`if((insn_or1k_opcode_0x06_get_id(insn)))`
75	18	julius	`{`
76			`insn_props->insn_string="l.macrc";`
77			`insn_props->insn_index=5;`
78			`}`
79	16	julius	`else`
80			`{`
81			`insn_props->insn_string="l.movhi";`
82	18	julius	`insn_props->insn_index=6;`
83	16	julius	`insn_props->has_rD = 1;`
84			`insn_props->has_imm = 1;`
85			`}`
86
87			`break;`
88
89			`case 0x08:`
90
91			`switch(insn_or1k_opcode_0x08_get_id(insn))`
92			`{`
93			`case 0x0:`
94			`insn_props->insn_string="l.sys";`
95	18	julius	`insn_props->insn_index=7;`
96	20	julius	`insn_props->has_imm = 1;`
97	16	julius	`break;`
98			`case 0x2:`
99			`insn_props->insn_string="l.trap";`
100	18	julius	`insn_props->insn_index=8;`
101	16	julius	`break;`
102			`case 0x4:`
103			`insn_props->insn_string="l.msync";`
104	18	julius	`insn_props->insn_index=9;`
105	16	julius	`break;`
106			`case 0x5:`
107			`insn_props->insn_string="l.psync";`
108	18	julius	`insn_props->insn_index=10;`
109	16	julius	`break;`
110			`case 0x6:`
111			`insn_props->insn_string="l.csync";`
112	18	julius	`insn_props->insn_index=11;`
113	16	julius	`break;`
114			`default:`
115			`printf("Unknown id (0x%x) in opcode 0x8",`
116			`insn_or1k_opcode_0x08_get_id(insn) );`
117			`return 1;`
118			`break;`
119			`}`
120			`break;`
121
122			`case 0x09:`
123			`insn_props->insn_string="l.rfe";`
124	18	julius	`insn_props->insn_index=12;`
125	16	julius	`break;`
126
127			`case 0x0a:`
128			`switch(insn_or1k_opcode_0x0a_get_op_hi(insn))`
129			`{`
130			`case 0x1:`
131			`switch(insn_or1k_opcode_0x0a_get_op_lo(insn))`
132			`{`
133			`case 0x0:`
134			`break;`
135			`case 0x1:`
136			`break;`
137			`case 0x2:`
138			`break;`
139			`case 0x3:`
140			`break;`
141			`case 0x4:`
142			`break;`
143			`case 0x5:`
144			`break;`
145			`case 0x6:`
146			`break;`
147			`case 0x7:`
148			`break;`
149			`case 0x8:`
150			`break;`
151			`case 0x9:`
152			`break;`
153			`case 0xa:`
154			`break;`
155			`case 0xb:`
156			`break;`
157			`default:`
158			`printf("Unknown lv.all_xx insn");`
159	17	julius	`return 1;`
160	16	julius	`}`
161			`case 0x2:`
162			`switch(insn_or1k_opcode_0x0a_get_op_lo(insn))`
163			`{`
164			`case 0x0:`
165			`break;`
166			`case 0x1:`
167			`break;`
168			`case 0x2:`
169			`break;`
170			`case 0x3:`
171			`break;`
172			`case 0x4:`
173			`break;`
174			`case 0x5:`
175			`break;`
176			`case 0x6:`
177			`break;`
178			`case 0x7:`
179			`break;`
180			`case 0x8:`
181			`break;`
182			`case 0x9:`
183			`break;`
184			`case 0xa:`
185			`break;`
186			`case 0xb:`
187			`break;`
188			`default:`
189			`printf("Unknown lv.any_xx insn");`
190	17	julius	`return 1;`
191	16	julius	`}`
192			`break;`
193			`case 0x3:`
194			`switch(insn_or1k_opcode_0x0a_get_op_lo(insn))`
195			`{`
196			`case 0x0:`
197			`break;`
198			`case 0x1:`
199			`break;`
200			`case 0x2:`
201			`break;`
202			`case 0x3:`
203			`break;`
204			`case 0x4:`
205			`break;`
206			`case 0x5:`
207			`break;`
208			`case 0x6:`
209			`break;`
210			`case 0x7:`
211			`break;`
212			`case 0x8:`
213			`break;`
214			`case 0x9:`
215			`break;`
216			`case 0xa:`
217			`break;`
218			`default:`
219			`printf("Unknown lv.add/and/avg_xx insn");`
220	17	julius	`return 1;`
221	16	julius	`}`
222			`break;`
223			`case 0x4:`
224			`switch(insn_or1k_opcode_0x0a_get_op_lo(insn))`
225			`{`
226			`case 0x0:`
227			`break;`
228			`case 0x1:`
229			`break;`
230			`case 0x2:`
231			`break;`
232			`case 0x3:`
233			`break;`
234			`case 0x4:`
235			`break;`
236			`case 0x5:`
237			`break;`
238			`case 0x6:`
239			`break;`
240			`case 0x7:`
241			`break;`
242			`case 0x8:`
243			`break;`
244			`case 0x9:`
245			`break;`
246			`case 0xa:`
247			`break;`
248			`case 0xb:`
249			`break;`
250			`default:`
251			`printf("Unknown lv.cmp_xx insn");`
252	17	julius	`return 1;`
253	16	julius	`}`
254			`break;`
255			`case 0x5:`
256			`switch(insn_or1k_opcode_0x0a_get_op_lo(insn))`
257			`{`
258			`case 0x4:`
259			`break;`
260			`case 0x5:`
261			`break;`
262			`case 0x6:`
263			`break;`
264			`case 0x7:`
265			`break;`
266			`case 0x8:`
267			`break;`
268			`case 0x9:`
269			`break;`
270			`case 0xa:`
271			`break;`
272			`case 0xb:`
273			`break;`
274			`case 0xc:`
275			`break;`
276			`case 0xd:`
277			`break;`
278			`case 0xe:`
279			`break;`
280			`case 0xf:`
281			`break;`
282			`default:`
283			`printf("Unknown lv.alu_xx insn");`
284	17	julius	`return 1;`
285	16	julius	`}`
286			`break;`
287			`case 0x6:`
288			`switch(insn_or1k_opcode_0x0a_get_op_lo(insn))`
289			`{`
290			`case 0x0:`
291			`break;`
292			`case 0x1:`
293			`break;`
294			`case 0x2:`
295			`break;`
296			`case 0x3:`
297			`break;`
298			`case 0x4:`
299			`break;`
300			`case 0x5:`
301			`break;`
302			`case 0x6:`
303			`break;`
304			`case 0x7:`
305			`break;`
306			`case 0x8:`
307			`break;`
308			`case 0x9:`
309			`break;`
310			`case 0xa:`
311			`break;`
312			`case 0xb:`
313			`break;`
314			`case 0xc:`
315			`break;`
316			`case 0xd:`
317			`break;`
318			`case 0xe:`
319			`break;`
320			`case 0xf:`
321			`break;`
322			`default:`
323			`printf("Unknown lv.pack_xx insn");`
324	17	julius	`return 1;`
325	16	julius	`}`
326			`break;`
327			`case 0x7:`
328			`switch(insn_or1k_opcode_0x0a_get_op_lo(insn))`
329			`{`
330			`case 0x0:`
331			`break;`
332			`case 0x1:`
333			`break;`
334			`case 0x2:`
335			`break;`
336			`case 0x3:`
337			`break;`
338			`case 0x4:`
339			`break;`
340			`case 0x5:`
341			`break;`
342			`case 0x6:`
343			`break;`
344			`case 0x7:`
345			`break;`
346			`case 0x8:`
347			`break;`
348			`case 0x9:`
349			`break;`
350			`case 0xa:`
351			`break;`
352			`case 0xb:`
353			`break;`
354			`default:`
355			`printf("Unknown lv.sub/unpack/xor_xx insn");`
356	17	julius	`return 1;`
357	16	julius	`}`
358			`break;`
359			`case 0xc:`
360			`break;`
361			`case 0xd:`
362			`break;`
363			`case 0xe:`
364			`break;`
365			`case 0xf:`
366			`break;`
367			`default:`
368			`printf("Unknown lv.xxx insn hi op");`
369	17	julius	`return 1;`
370	16	julius	`break;`
371			`}`
372			`break;`
373
374			`case 0x11:`
375			`insn_props->insn_string="l.jr";`
376	18	julius	`insn_props->insn_index=13;`
377	16	julius	`insn_props->has_rB = 1;`
378			`break;`
379
380			`case 0x12:`
381			`insn_props->insn_string="l.jalr";`
382	18	julius	`insn_props->insn_index=14;`
383	16	julius	`insn_props->has_rB = 1;`
384			`break;`
385
386			`case 0x13:`
387			`insn_props->insn_string="l.maci";`
388	18	julius	`insn_props->insn_index=15;`
389	16	julius	`break;`
390
391			`case 0x1c:`
392			`insn_props->insn_string="l.cust1";`
393	18	julius	`insn_props->insn_index=16;`
394	16	julius	`break;`
395
396			`case 0x1d:`
397			`insn_props->insn_string="l.cust2";`
398	18	julius	`insn_props->insn_index=17;`
399	16	julius	`break;`
400
401			`case 0x1e:`
402			`insn_props->insn_string="l.cust3";`
403	18	julius	`insn_props->insn_index=18;`
404	16	julius	`break;`
405
406			`case 0x1f:`
407			`insn_props->insn_string="l.cust4";`
408	18	julius	`insn_props->insn_index=19;`
409	16	julius	`break;`
410
411			`case 0x20:`
412			`insn_props->insn_string="l.ld";`
413	18	julius	`insn_props->insn_index=20;`
414	16	julius	`insn_props->has_rD = 1;`
415			`insn_props->has_rA = 1;`
416			`insn_props->has_imm = 1;`
417			`break;`
418
419			`case 0x21:`
420			`insn_props->insn_string="l.lwz";`
421	18	julius	`insn_props->insn_index=21;`
422	16	julius	`insn_props->has_rD = 1;`
423			`insn_props->has_rA = 1;`
424			`insn_props->has_imm = 1;`
425			`break;`
426
427			`case 0x22:`
428			`insn_props->insn_string="l.lws";`
429	18	julius	`insn_props->insn_index=22;`
430	16	julius	`insn_props->has_rD = 1;`
431			`insn_props->has_rA = 1;`
432			`insn_props->has_imm = 1;`
433			`break;`
434
435			`case 0x23:`
436			`insn_props->insn_string="l.lbz";`
437	18	julius	`insn_props->insn_index=23;`
438	16	julius	`insn_props->has_rD = 1;`
439			`insn_props->has_rA = 1;`
440			`insn_props->has_imm = 1;`
441			`break;`
442
443			`case 0x24:`
444			`insn_props->insn_string="l.lbs";`
445	18	julius	`insn_props->insn_index=24;`
446	16	julius	`insn_props->has_rD = 1;`
447			`insn_props->has_rA = 1;`
448			`insn_props->has_imm = 1;`
449			`break;`
450
451			`case 0x25:`
452			`insn_props->insn_string="l.lhz";`
453	18	julius	`insn_props->insn_index=25;`
454	16	julius	`insn_props->has_rD = 1;`
455			`insn_props->has_rA = 1;`
456			`insn_props->has_imm = 1;`
457			`break;`
458
459			`case 0x26:`
460			`insn_props->insn_string="l.lhs";`
461	18	julius	`insn_props->insn_index=26;`
462	16	julius	`insn_props->has_rD = 1;`
463			`insn_props->has_rA = 1;`
464			`insn_props->has_imm = 1;`
465			`break;`
466
467
468			`case 0x27:`
469			`insn_props->insn_string="l.addi";`
470	18	julius	`insn_props->insn_index=27;`
471	16	julius	`insn_props->has_rD = 1;`
472			`insn_props->has_rA = 1;`
473			`insn_props->has_imm = 1;`
474			`break;`
475
476			`case 0x28:`
477			`insn_props->insn_string="l.addic";`
478	18	julius	`insn_props->insn_index=28;`
479	16	julius	`insn_props->has_rD = 1;`
480			`insn_props->has_rA = 1;`
481			`insn_props->has_imm = 1;`
482			`break;`
483
484			`case 0x29:`
485			`insn_props->insn_string="l.andi";`
486	18	julius	`insn_props->insn_index=29;`
487	16	julius	`insn_props->has_rD = 1;`
488			`insn_props->has_rA = 1;`
489			`insn_props->has_imm = 1;`
490			`break;`
491
492			`case 0x2a:`
493			`insn_props->insn_string="l.ori";`
494	18	julius	`insn_props->insn_index=30;`
495	16	julius	`insn_props->has_rD = 1;`
496			`insn_props->has_rA = 1;`
497			`insn_props->has_imm = 1;`
498			`break;`
499
500			`case 0x2b:`

Browse

Tools

Subversion Repositories or2k

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