/* Copyright 2009-2020 Free Software Foundation, Inc.

   This file is part of the Xilinx MicroBlaze simulator.

   This library is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 3 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, see <http://www.gnu.org/licenses/>.  */

/*
 *  MICROBLAZE Instruction Set Architecture
 *
 *  INSTRUCTION(NAME,
 *              OPCODE,
 *              TYPE,
 *              SEMANTICS)
 *
 */

INSTRUCTION(add,
	    0x00,
	    INST_TYPE_RD_RA_RB,
	    CARRY = C_calc(RA, RB, 0);
	    RD = RA + RB;
	    C_wr(CARRY);
	    PC += INST_SIZE)

INSTRUCTION(rsub,
	    0x01,
            INST_TYPE_RD_RA_RB, 
	    CARRY = C_calc(RB, ~RA, 1);
	    RD = RB + ~RA + 1;
            C_wr(CARRY);
	    PC += INST_SIZE)

INSTRUCTION(addc,
	    0x02,
            INST_TYPE_RD_RA_RB,
	    CARRY = C_calc(RA, RB, C_rd);
	    RD = RA + RB + C_rd;
	    C_wr(CARRY);
	    PC += INST_SIZE)

INSTRUCTION(rsubc,
	    0x03,
            INST_TYPE_RD_RA_RB,
	    CARRY = C_calc(RB, ~RA, C_rd);
	    RD = RB + ~RA + C_rd;
            C_wr(CARRY);
	    PC += INST_SIZE)

INSTRUCTION(addk,
	    0x04,
            INST_TYPE_RD_RA_RB,
	    RD = RA + RB;
	    PC += INST_SIZE)

INSTRUCTION(rsubk,
	    0x05,
            INST_TYPE_RD_RA_RB,
	    RD = RB + ~RA + 1;
	    PC += INST_SIZE)

INSTRUCTION(cmp,
            0x05,
            INST_TYPE_RD_RA_RB,
            {
	      int tmp_reg = RB + ~RA + 1;
	      if ((RB & 0x80000000) ^ (RA & 0x80000000)) {
		tmp_reg = ((tmp_reg & 0x7fffffff) | (RB & 0x80000000));
	      }
	      RD = tmp_reg;
	      PC += INST_SIZE;
	    })

INSTRUCTION(cmpu,
            0x05,
            INST_TYPE_RD_RA_RB,
            {
	      int tmp_reg = RB + ~RA + 1;
	      if ((RB & 0x80000000) ^ (RA & 0x80000000)) {
		tmp_reg = ((tmp_reg & 0x7fffffff) | (RA & 0x80000000));
	      }
	      RD = tmp_reg;
	      PC += INST_SIZE;
	    })

INSTRUCTION(addkc,
	    0x06,
            INST_TYPE_RD_RA_RB,
	    RD = RA + RB + C_rd;
	    PC += INST_SIZE)

INSTRUCTION(rsubkc,
	    0x07,
            INST_TYPE_RD_RA_RB,
	    RD = RB + ~RA + C_rd;
	    PC += INST_SIZE)

INSTRUCTION(addi,
	    0x08,
	    INST_TYPE_RD_RA_IMM,
            CARRY = C_calc(RA, IMM, 0);
	    RD = RA + IMM;
	    C_wr(CARRY);
	    PC += INST_SIZE)

INSTRUCTION(rsubi,
	    0x09,
	    INST_TYPE_RD_RA_IMM,
            CARRY = C_calc(IMM, ~RA, 1);
	    RD = IMM + ~RA + 1;
            C_wr(CARRY);
	    PC += INST_SIZE)

INSTRUCTION(addic,
	    0x0A,
            INST_TYPE_RD_RA_IMM,
            CARRY = C_calc(RA, IMM, C_rd);
	    RD = RA + IMM + C_rd;
            C_wr(CARRY);
	    PC += INST_SIZE)

INSTRUCTION(rsubic,
	    0x0B,
            INST_TYPE_RD_RA_IMM,
            CARRY = C_calc(IMM, ~RA, C_rd);
	    RD = IMM + ~RA + C_rd;
            C_wr(CARRY);
	    PC += INST_SIZE)

INSTRUCTION(addik,
	    0x0C,
            INST_TYPE_RD_RA_IMM,
	    RD = RA + IMM;
	    PC += INST_SIZE)

INSTRUCTION(rsubik,
	    0x0D,
            INST_TYPE_RD_RA_IMM,
	    RD = IMM + ~RA + 1;
	    PC += INST_SIZE)

INSTRUCTION(addikc,
	    0x0E,
            INST_TYPE_RD_RA_IMM,
	    RD = RA + IMM + C_rd;
	    PC += INST_SIZE)

INSTRUCTION(rsubikc,
	    0x0F,
            INST_TYPE_RD_RA_IMM,
            RD = IMM + ~RA + C_rd;
	    PC += INST_SIZE)

INSTRUCTION(mul,
	    0x10,
            INST_TYPE_RD_RA_RB, 
	    RD = RA * RB;
	    PC += INST_SIZE)

INSTRUCTION(bsrl,
	    0x11,
	    INST_TYPE_RD_RA_RB,
	    RD = (uword)RA >> RB;
	    PC += INST_SIZE)

INSTRUCTION(bsra,
	    0x11,
	    INST_TYPE_RD_RA_RB,
	    RD = (word)RA >> RB;
	    PC += INST_SIZE)

INSTRUCTION(bsll,
	    0x11,
	    INST_TYPE_RD_RA_RB,
	    RD = (uword)RA << RB;
	    PC += INST_SIZE)

INSTRUCTION(idiv,
	    0x12,
	    INST_TYPE_RD_RA_RB,
	    RD = (word) RB / (word) RA;
	    PC += INST_SIZE)

INSTRUCTION(idivu,
	    0x12,
	    INST_TYPE_RD_RA_RB,
	    RD = (uword) RB / (uword) RA;
	    PC += INST_SIZE)

INSTRUCTION(muli,
	    0x18,
            INST_TYPE_RD_RA_IMM,
	    RD = RA * IMM;
	    PC += INST_SIZE)

INSTRUCTION(bsrli,
	    0x19,
	    INST_TYPE_RD_RA_IMM5,
	    RD = (uword)RA >> (IMM & 0x1F);
	    PC += INST_SIZE)

INSTRUCTION(bsrai,
	    0x19,
	    INST_TYPE_RD_RA_IMM5,
	    RD = (word)RA >> (IMM & 0x1F);
	    PC += INST_SIZE)

INSTRUCTION(bslli,
	    0x19,
	    INST_TYPE_RD_RA_IMM5,
	    RD = (uword)RA << (IMM & 0x1F);
	    PC += INST_SIZE)

INSTRUCTION(get,
            0x1b,
            INST_TYPE_RD_IMM12,
            PC += INST_SIZE)

INSTRUCTION(put,
            0x1b,
            INST_TYPE_R1_IMM12,
            PC += INST_SIZE)

INSTRUCTION(nget,
            0x1b,
            INST_TYPE_RD_IMM12,
            PC += INST_SIZE)

INSTRUCTION(nput,
            0x1b,
            INST_TYPE_R1_IMM12,
            PC += INST_SIZE)

INSTRUCTION(cget,
            0x1b,
            INST_TYPE_RD_IMM12,
            PC += INST_SIZE)

INSTRUCTION(cput,
            0x1b,
            INST_TYPE_R1_IMM12,
            PC += INST_SIZE)

INSTRUCTION(ncget,
            0x1b,
            INST_TYPE_RD_IMM12,
            PC += INST_SIZE)

INSTRUCTION(ncput,
            0x1b,
            INST_TYPE_R1_IMM12,
            PC += INST_SIZE) 

INSTRUCTION(microblaze_or,
	    0x20,
            INST_TYPE_RD_RA_RB,
	    RD = RA | RB;
	    PC += INST_SIZE)

INSTRUCTION(microblaze_and,
	    0x21,
            INST_TYPE_RD_RA_RB,
	    RD = RA & RB;
	    PC += INST_SIZE)

INSTRUCTION(microblaze_xor,
	    0x22,
            INST_TYPE_RD_RA_RB,
	    RD = RA ^ RB;
	    PC += INST_SIZE)

INSTRUCTION(andn,
	    0x23,
            INST_TYPE_RD_RA_RB,
	    RD = RA & ~RB;
	    PC += INST_SIZE)

INSTRUCTION(sra,
	    0x24,
	    INST_TYPE_RD_RA,
	    CARRY = (RA & 0x1);
	    RD = (int) (RA >> 1);
	    C_wr(CARRY);
	    PC += INST_SIZE)

INSTRUCTION(src,
	    0x24,
            INST_TYPE_RD_RA,
	    CARRY = (RA & 0x1);
            RD = ((((int) (RA >> 1)) & 0x7FFFFFFF) | (uword)(C_rd << 31));
            C_wr(CARRY);
	    PC += INST_SIZE)

INSTRUCTION(srl,
	    0x24,
            INST_TYPE_RD_RA,
            CARRY = (RA & 0x1);
	    RD = (uword) ((RA >> 1) & 0x7FFFFFFF);
            C_wr(CARRY);
	    PC += INST_SIZE)

INSTRUCTION(sext8,
	    0x24,
            INST_TYPE_RD_RA,
	    RD = MICROBLAZE_SEXT8(RA);
	    PC += INST_SIZE)

INSTRUCTION(sext16,
            0x24,
            INST_TYPE_RD_RA,
	    RD = MICROBLAZE_SEXT16(RA);
            PC += INST_SIZE)

INSTRUCTION(wdc,
            0x24,
            INST_TYPE_RA_RB,
            PC += INST_SIZE)

INSTRUCTION(wic,
            0x24,
            INST_TYPE_RA_RB,
            PC += INST_SIZE)

INSTRUCTION(mts,
	    0x25,
	    INST_TYPE_SA_RA,
	    SA = RA;
	    PC += INST_SIZE)

INSTRUCTION(mfs,
	    0x25,
            INST_TYPE_RD_SA,
	    RD = SA;
	    PC += INST_SIZE)

INSTRUCTION(br,
	    0x26,
	    INST_TYPE_RB,
	    PC += RB;
	    BRANCH)

INSTRUCTION(brd,
            0x26,
            INST_TYPE_RB,
            PC += RB;
	    BRANCH;
            DELAY_SLOT)

INSTRUCTION(brld,
	    0x26,
	    INST_TYPE_RD_RB,
	    RD = PC;
	    PC += RB;
	    BRANCH;
	    DELAY_SLOT)

INSTRUCTION(bra,
	    0x26,
            INST_TYPE_RB,
	    PC = RB;
	    BRANCH)

INSTRUCTION(brad,
            0x26,
            INST_TYPE_RB,
            PC = RB;
	    BRANCH;
            DELAY_SLOT)

INSTRUCTION(brald,
	    0x26,
            INST_TYPE_RD_RB,
	    RD = PC;
	    PC = RB;
	    BRANCH;
	    DELAY_SLOT)

INSTRUCTION(microblaze_brk,
	    0x26,
            INST_TYPE_RD_RB,
	    RD = PC;
	    PC = RB;
            MSR = MSR | BIP_MASK;
	    BRANCH)

INSTRUCTION(beq,
	    0x27,
            INST_TYPE_RA_RB,
	    if (RA == 0) {
	      PC += RB;
	      BRANCH;
            } else {
	      PC += INST_SIZE;
	    })

INSTRUCTION(beqd,
            0x27,
            INST_TYPE_RA_RB,
            if (RA == 0) {
	      PC += RB;
	      BRANCH;
	    } else {
	      PC += INST_SIZE;
	    }
	    DELAY_SLOT)

INSTRUCTION(bne,
	    0x27,
            INST_TYPE_RA_RB,
	    if (RA != 0) {
	      PC += RB;
	      BRANCH;
	    } else {
	      PC += INST_SIZE;
	    })

INSTRUCTION(bned,
            0x27,
            INST_TYPE_RA_RB,
            if (RA != 0) {
	      PC += RB;
	      BRANCH;
	    } else {
	      PC += INST_SIZE;
	    }
	    DELAY_SLOT)

INSTRUCTION(blt,
	    0x27,
            INST_TYPE_RA_RB,
	    if (RA < 0) {
	      PC += RB;
	      BRANCH;
	    } else {
	      PC += INST_SIZE;
	    })

INSTRUCTION(bltd,
            0x27,
            INST_TYPE_RA_RB,
            if (RA < 0) {
	      PC += RB;
	      BRANCH;
	    } else {
	      PC += INST_SIZE;
	    }
	    DELAY_SLOT)

INSTRUCTION(ble,
	    0x27,
            INST_TYPE_RA_RB,
	    if (RA <= 0) {
	      PC += RB;
	      BRANCH;
	    } else {
	      PC += INST_SIZE;
	    })

INSTRUCTION(bled,
            0x27,
            INST_TYPE_RA_RB,
            if (RA <= 0) {
	      PC += RB;
	      BRANCH;
	    } else {
	      PC += INST_SIZE;
	    }
	    DELAY_SLOT)

INSTRUCTION(bgt,
	    0x27,
            INST_TYPE_RA_RB,
	    if (RA > 0) {
	      PC += RB;
	      BRANCH;
	    } else {
	      PC += INST_SIZE;
	    })

INSTRUCTION(bgtd,
            0x27,
            INST_TYPE_RA_RB,
            if (RA > 0) {
	      PC += RB;
	      BRANCH;
	    } else {
	      PC += INST_SIZE;
	    }
	    DELAY_SLOT)

INSTRUCTION(bge,
	    0x27,
            INST_TYPE_RA_RB,
	    if (RA >= 0) {
	      PC += RB;
	      BRANCH;
	    } else {
	      PC += INST_SIZE;
	    })

INSTRUCTION(bged,
            0x27,
            INST_TYPE_RA_RB,
            if (RA >= 0) {
	      PC += RB;
	      BRANCH;
	    } else {
	      PC += INST_SIZE;
	    }
	    DELAY_SLOT)

INSTRUCTION(ori,
	    0x28,
            INST_TYPE_RD_RA_IMM,
	    RD = RA | IMM;
	    PC += INST_SIZE)

INSTRUCTION(andi,
	    0x29,
            INST_TYPE_RD_RA_IMM,
	    RD = RA & IMM;
	    PC += INST_SIZE)

INSTRUCTION(xori,
	    0x2A,
            INST_TYPE_RD_RA_IMM,
	    RD = RA ^ IMM;
	    PC += INST_SIZE)

INSTRUCTION(andni,
	    0x2B,
            INST_TYPE_RD_RA_IMM,
	    RD = RA & ~IMM;
	    PC += INST_SIZE)

INSTRUCTION(imm,
	    0x2C,
	    INST_TYPE_IMM,
	    IMM_H = IMM_L;
	    PC += INST_SIZE)

INSTRUCTION(rtsd,
	    0x2D,
            INST_TYPE_RA_IMM,
	    PC = RA + IMM;
    	    BRANCH;
	    DELAY_SLOT)

INSTRUCTION(rtid,
	    0x2D,
            INST_TYPE_RA_IMM,
	    PC = RA + IMM;
	    MSR = MSR | INTR_EN_MASK;
	    BRANCH;
	    DELAY_SLOT)

INSTRUCTION(rtbd,
	    0x2D,
	    INST_TYPE_RA_IMM,
	    PC = RA + IMM;
	    MSR = MSR & ~BIP_MASK;
	    BRANCH;
            DELAY_SLOT;)

INSTRUCTION(bri,
	    0x2E,
            INST_TYPE_IMM,
	    PC += IMM;
	    BRANCH)

INSTRUCTION(brid,
            0x2E,
            INST_TYPE_IMM,
            PC += IMM;
	    BRANCH;
            DELAY_SLOT)

INSTRUCTION(brlid,
	    0x2E,
            INST_TYPE_RD_IMM,
	    RD = PC;
	    PC += IMM;
	    BRANCH;
	    DELAY_SLOT)

INSTRUCTION(brai,
	    0x2E,
            INST_TYPE_IMM,
	    PC = IMM;
	    BRANCH)

INSTRUCTION(braid,
            0x2E,
            INST_TYPE_IMM,
            PC = IMM;
	    BRANCH;
            DELAY_SLOT)

INSTRUCTION(bralid,
	    0x2E,
	    INST_TYPE_RD_IMM,
	    RD = PC;
	    PC = IMM;
	    BRANCH;
	    DELAY_SLOT)

INSTRUCTION(brki,
	    0x2E,
            INST_TYPE_RD_IMM,
	    RD = PC;
	    PC = IMM;
            MSR = MSR | BIP_MASK;
	    BRANCH)

INSTRUCTION(beqi,
	    0x2F,
            INST_TYPE_RA_IMM,
	    if (RA == 0) {
	      PC += IMM;
	      BRANCH;
	    } else {
	      PC += INST_SIZE;
	    })

INSTRUCTION(beqid,
            0x2F,
            INST_TYPE_RA_IMM,
            if (RA == 0) {
	      PC += IMM;
	      BRANCH;
	    } else {
	      PC += INST_SIZE;
	    }
	    DELAY_SLOT)

INSTRUCTION(bnei,
	    0x2F,
            INST_TYPE_RA_IMM,
	    if (RA != 0) {
	      PC += IMM;
	      BRANCH;
	    } else {
	      PC += INST_SIZE;
	    })

INSTRUCTION(bneid,
            0x2F,
            INST_TYPE_RA_IMM,
            if (RA != 0) {
	      PC += IMM;
	      BRANCH;
	    } else {
	      PC += INST_SIZE;
	    }
	    DELAY_SLOT)

INSTRUCTION(blti,
	    0x2F,
            INST_TYPE_RA_IMM,
	    if (RA < 0) {
	      PC += IMM;
	      BRANCH;
	    } else {
	      PC += INST_SIZE;
	    })

INSTRUCTION(bltid,
            0x2F,
            INST_TYPE_RA_IMM,
            if (RA < 0) {
	      PC += IMM;
	      BRANCH;
	    } else {
	      PC += INST_SIZE;
	    }
	    DELAY_SLOT)

INSTRUCTION(blei,
	    0x2F,
            INST_TYPE_RA_IMM,
	    if (RA <= 0) {
	      PC += IMM;
	      BRANCH;
	    } else {
	      PC += INST_SIZE;
	    })

INSTRUCTION(bleid,
            0x2F,
            INST_TYPE_RA_IMM,
            if (RA <= 0) {
	      PC += IMM;
	      BRANCH;
	    } else {
	      PC += INST_SIZE;
	    }
	    DELAY_SLOT)

INSTRUCTION(bgti,
	    0x2F,
            INST_TYPE_RA_IMM,
	    if (RA > 0) {
	      PC += IMM;
	      BRANCH;
	    } else {
	      PC += INST_SIZE;
	    })

INSTRUCTION(bgtid,
            0x2F,
            INST_TYPE_RA_IMM,
            if (RA > 0) {
	      PC += IMM;
	      BRANCH;
	    } else {
	      PC += INST_SIZE;
	    }
	    DELAY_SLOT)

INSTRUCTION(bgei,
	    0x2F,
            INST_TYPE_RA_IMM,
	    if (RA >= 0) {
	      PC += IMM;
	      BRANCH;
	    } else {
	      PC += INST_SIZE;
	    })

INSTRUCTION(bgeid,
            0x2F,
            INST_TYPE_RA_IMM,
            if (RA >= 0) {
	      PC += IMM;
	      BRANCH;
	    } else {
	      PC += INST_SIZE;
	    }
	    DELAY_SLOT)

INSTRUCTION(lbu,
	    0x30,
            INST_TYPE_RD_RA_RB,
	    RD = (MEM_RD_UBYTE(RA + RB));
	    PC += INST_SIZE)

INSTRUCTION(lhu,
	    0x31,
	    INST_TYPE_RD_RA_RB,
	    RD = (MEM_RD_UHALF((RA + RB) & ~0x1));
	    PC += INST_SIZE)

INSTRUCTION(lw,
	    0x32,
            INST_TYPE_RD_RA_RB, 
	    RD = (MEM_RD_WORD((RA + RB) & ~0x3));
	    PC += INST_SIZE)

INSTRUCTION(sb,
	    0x34,
            INST_TYPE_RD_RA_RB,
	    MEM_WR_BYTE(RA + RB, RD);
	    PC += INST_SIZE)

INSTRUCTION(sh,
	    0x35,
            INST_TYPE_RD_RA_RB,
	    MEM_WR_HALF((RA + RB) & ~0x1, RD);
	    PC += INST_SIZE)

INSTRUCTION(sw,
	    0x36,
            INST_TYPE_RD_RA_RB,
	    MEM_WR_WORD((RA + RB) & ~0x3, RD);
	    PC += INST_SIZE)

INSTRUCTION(lbui,
	    0x38,
            INST_TYPE_RD_RA_IMM,
	    RD = (MEM_RD_UBYTE(RA + IMM));
	    PC += INST_SIZE)

INSTRUCTION(lhui,
	    0x39,
            INST_TYPE_RD_RA_IMM,
	    RD = (MEM_RD_UHALF((RA+IMM) & ~0x1));
	    PC += INST_SIZE)

INSTRUCTION(lwi,
	    0x3A,
            INST_TYPE_RD_RA_IMM, 
	    RD = (MEM_RD_WORD((RA+IMM) & ~0x3));
	    PC += INST_SIZE)

INSTRUCTION(sbi,
	    0x3C,
            INST_TYPE_RD_RA_IMM,
	    MEM_WR_BYTE(RA + IMM, RD);
	    PC += INST_SIZE)

INSTRUCTION(shi,
	    0x3D,
            INST_TYPE_RD_RA_IMM,
	    MEM_WR_HALF((RA + IMM) & ~0x1, RD);
	    PC += INST_SIZE)

INSTRUCTION(swi,
	    0x3E,
            INST_TYPE_RD_RA_IMM,
	    MEM_WR_WORD((RA + IMM) & ~0x3, RD);
	    PC += INST_SIZE)