Quelle  inst.h   Sprache: C

/* SPDX-License-Identifier: GPL-2.0 */
/*
 * Copyright (C) 2020-2022 Loongson Technology Corporation Limited
 */
#ifndef _ASM_INST_H
#define _ASM_INST_H

#include <linux/bitops.h>
#include <linux/types.h>
#include <asm/asm.h>
#include <asm/ptrace.h>

#define INSN_NOP  0x03400000
#define INSN_BREAK  0x002a0000
#define INSN_HVCL  0x002b8000

#define ADDR_IMMMASK_LU52ID 0xFFF0000000000000
#define ADDR_IMMMASK_LU32ID 0x000FFFFF00000000
#define ADDR_IMMMASK_LU12IW 0x00000000FFFFF000
#define ADDR_IMMMASK_ORI 0x0000000000000FFF
#define ADDR_IMMMASK_ADDU16ID 0x00000000FFFF0000

#define ADDR_IMMSHIFT_LU52ID 52
#define ADDR_IMMSBIDX_LU52ID 11
#define ADDR_IMMSHIFT_LU32ID 32
#define ADDR_IMMSBIDX_LU32ID 19
#define ADDR_IMMSHIFT_LU12IW 12
#define ADDR_IMMSBIDX_LU12IW 19
#define ADDR_IMMSHIFT_ORI 0
#define ADDR_IMMSBIDX_ORI 63
#define ADDR_IMMSHIFT_ADDU16ID 16
#define ADDR_IMMSBIDX_ADDU16ID 15

#define ADDR_IMM(addr, INSN) \
 (sign_extend64(((addr & ADDR_IMMMASK_##INSN) >> ADDR_IMMSHIFT_##INSN), ADDR_IMMSBIDX_##INSN))

enum reg0i15_op {
 break_op = 0x54,
};

enum reg0i26_op {
 b_op  = 0x14,
 bl_op  = 0x15,
};

enum reg1i20_op {
 lu12iw_op = 0x0a,
 lu32id_op = 0x0b,
 pcaddi_op = 0x0c,
 pcalau12i_op = 0x0d,
 pcaddu12i_op = 0x0e,
 pcaddu18i_op = 0x0f,
};

enum reg1i21_op {
 beqz_op  = 0x10,
 bnez_op  = 0x11,
 bceqz_op = 0x12, /* bits[9:8] = 0x00 */
 bcnez_op = 0x12, /* bits[9:8] = 0x01 */
};

enum reg2_op {
 revb2h_op = 0x0c,
 revb4h_op = 0x0d,
 revb2w_op = 0x0e,
 revbd_op = 0x0f,
 revh2w_op = 0x10,
 revhd_op = 0x11,
 extwh_op = 0x16,
 extwb_op = 0x17,
 cpucfg_op = 0x1b,
 iocsrrdb_op     = 0x19200,
 iocsrrdh_op     = 0x19201,
 iocsrrdw_op     = 0x19202,
 iocsrrdd_op     = 0x19203,
 iocsrwrb_op     = 0x19204,
 iocsrwrh_op     = 0x19205,
 iocsrwrw_op     = 0x19206,
 iocsrwrd_op     = 0x19207,
 llacqw_op = 0xe15e0,
 screlw_op = 0xe15e1,
 llacqd_op = 0xe15e2,
 screld_op = 0xe15e3,
};

enum reg2i5_op {
 slliw_op = 0x81,
 srliw_op = 0x89,
 sraiw_op = 0x91,
};

enum reg2i6_op {
 sllid_op = 0x41,
 srlid_op = 0x45,
 sraid_op = 0x49,
};

enum reg2i12_op {
 addiw_op = 0x0a,
 addid_op = 0x0b,
 lu52id_op = 0x0c,
 andi_op  = 0x0d,
 ori_op  = 0x0e,
 xori_op  = 0x0f,
 ldb_op  = 0xa0,
 ldh_op  = 0xa1,
 ldw_op  = 0xa2,
 ldd_op  = 0xa3,
 stb_op  = 0xa4,
 sth_op  = 0xa5,
 stw_op  = 0xa6,
 std_op  = 0xa7,
 ldbu_op  = 0xa8,
 ldhu_op  = 0xa9,
 ldwu_op  = 0xaa,
 flds_op  = 0xac,
 fsts_op  = 0xad,
 fldd_op  = 0xae,
 fstd_op  = 0xaf,
};

enum reg2i14_op {
 llw_op  = 0x20,
 scw_op  = 0x21,
 lld_op  = 0x22,
 scd_op  = 0x23,
 ldptrw_op = 0x24,
 stptrw_op = 0x25,
 ldptrd_op = 0x26,
 stptrd_op = 0x27,
};

enum reg2i16_op {
 jirl_op  = 0x13,
 beq_op  = 0x16,
 bne_op  = 0x17,
 blt_op  = 0x18,
 bge_op  = 0x19,
 bltu_op  = 0x1a,
 bgeu_op  = 0x1b,
};

enum reg2bstrd_op {
 bstrinsd_op = 0x2,
 bstrpickd_op = 0x3,
};

enum reg3_op {
 asrtle_op = 0x02,
 asrtgt_op = 0x03,
 addw_op  = 0x20,
 addd_op  = 0x21,
 subw_op  = 0x22,
 subd_op  = 0x23,
 nor_op  = 0x28,
 and_op  = 0x29,
 or_op  = 0x2a,
 xor_op  = 0x2b,
 orn_op  = 0x2c,
 andn_op  = 0x2d,
 sllw_op  = 0x2e,
 srlw_op  = 0x2f,
 sraw_op  = 0x30,
 slld_op  = 0x31,
 srld_op  = 0x32,
 srad_op  = 0x33,
 mulw_op  = 0x38,
 mulhw_op = 0x39,
 mulhwu_op = 0x3a,
 muld_op  = 0x3b,
 mulhd_op = 0x3c,
 mulhdu_op = 0x3d,
 divw_op  = 0x40,
 modw_op  = 0x41,
 divwu_op = 0x42,
 modwu_op = 0x43,
 divd_op  = 0x44,
 modd_op  = 0x45,
 divdu_op = 0x46,
 moddu_op = 0x47,
 ldxb_op  = 0x7000,
 ldxh_op  = 0x7008,
 ldxw_op  = 0x7010,
 ldxd_op  = 0x7018,
 stxb_op  = 0x7020,
 stxh_op  = 0x7028,
 stxw_op  = 0x7030,
 stxd_op  = 0x7038,
 ldxbu_op = 0x7040,
 ldxhu_op = 0x7048,
 ldxwu_op = 0x7050,
 fldxs_op = 0x7060,
 fldxd_op = 0x7068,
 fstxs_op = 0x7070,
 fstxd_op = 0x7078,
 scq_op  = 0x70ae,
 amswapw_op = 0x70c0,
 amswapd_op = 0x70c1,
 amaddw_op = 0x70c2,
 amaddd_op = 0x70c3,
 amandw_op = 0x70c4,
 amandd_op = 0x70c5,
 amorw_op = 0x70c6,
 amord_op = 0x70c7,
 amxorw_op = 0x70c8,
 amxord_op = 0x70c9,
 ammaxw_op = 0x70ca,
 ammaxd_op = 0x70cb,
 amminw_op = 0x70cc,
 ammind_op = 0x70cd,
 ammaxwu_op = 0x70ce,
 ammaxdu_op = 0x70cf,
 amminwu_op = 0x70d0,
 ammindu_op = 0x70d1,
 amswapdbw_op = 0x70d2,
 amswapdbd_op = 0x70d3,
 amadddbw_op = 0x70d4,
 amadddbd_op = 0x70d5,
 amanddbw_op = 0x70d6,
 amanddbd_op = 0x70d7,
 amordbw_op = 0x70d8,
 amordbd_op = 0x70d9,
 amxordbw_op = 0x70da,
 amxordbd_op = 0x70db,
 ammaxdbw_op = 0x70dc,
 ammaxdbd_op = 0x70dd,
 ammindbw_op = 0x70de,
 ammindbd_op = 0x70df,
 ammaxdbwu_op = 0x70e0,
 ammaxdbdu_op = 0x70e1,
 ammindbwu_op = 0x70e2,
 ammindbdu_op = 0x70e3,
 fldgts_op = 0x70e8,
 fldgtd_op = 0x70e9,
 fldles_op = 0x70ea,
 fldled_op = 0x70eb,
 fstgts_op = 0x70ec,
 fstgtd_op = 0x70ed,
 fstles_op = 0x70ee,
 fstled_op = 0x70ef,
 ldgtb_op = 0x70f0,
 ldgth_op = 0x70f1,
 ldgtw_op = 0x70f2,
 ldgtd_op = 0x70f3,
 ldleb_op = 0x70f4,
 ldleh_op = 0x70f5,
 ldlew_op = 0x70f6,
 ldled_op = 0x70f7,
 stgtb_op = 0x70f8,
 stgth_op = 0x70f9,
 stgtw_op = 0x70fa,
 stgtd_op = 0x70fb,
 stleb_op = 0x70fc,
 stleh_op = 0x70fd,
 stlew_op = 0x70fe,
 stled_op = 0x70ff,
};

enum reg3sa2_op {
 alslw_op = 0x02,
 alslwu_op = 0x03,
 alsld_op = 0x16,
};

struct reg0i15_format {
 unsigned int immediate : 15;
 unsigned int opcode : 17;
};

struct reg0i26_format {
 unsigned int immediate_h : 10;
 unsigned int immediate_l : 16;
 unsigned int opcode : 6;
};

struct reg1i20_format {
 unsigned int rd : 5;
 unsigned int immediate : 20;
 unsigned int opcode : 7;
};

struct reg1i21_format {
 unsigned int immediate_h  : 5;
 unsigned int rj : 5;
 unsigned int immediate_l : 16;
 unsigned int opcode : 6;
};

struct reg2_format {
 unsigned int rd : 5;
 unsigned int rj : 5;
 unsigned int opcode : 22;
};

struct reg2i5_format {
 unsigned int rd : 5;
 unsigned int rj : 5;
 unsigned int immediate : 5;
 unsigned int opcode : 17;
};

struct reg2i6_format {
 unsigned int rd : 5;
 unsigned int rj : 5;
 unsigned int immediate : 6;
 unsigned int opcode : 16;
};

struct reg2i12_format {
 unsigned int rd : 5;
 unsigned int rj : 5;
 unsigned int immediate : 12;
 unsigned int opcode : 10;
};

struct reg2i14_format {
 unsigned int rd : 5;
 unsigned int rj : 5;
 unsigned int immediate : 14;
 unsigned int opcode : 8;
};

struct reg2i16_format {
 unsigned int rd : 5;
 unsigned int rj : 5;
 unsigned int immediate : 16;
 unsigned int opcode : 6;
};

struct reg2bstrd_format {
 unsigned int rd : 5;
 unsigned int rj : 5;
 unsigned int lsbd : 6;
 unsigned int msbd : 6;
 unsigned int opcode : 10;
};

struct reg2csr_format {
 unsigned int rd : 5;
 unsigned int rj : 5;
 unsigned int csr : 14;
 unsigned int opcode : 8;
};

struct reg3_format {
 unsigned int rd : 5;
 unsigned int rj : 5;
 unsigned int rk : 5;
 unsigned int opcode : 17;
};

struct reg3sa2_format {
 unsigned int rd : 5;
 unsigned int rj : 5;
 unsigned int rk : 5;
 unsigned int immediate : 2;
 unsigned int opcode : 15;
};

union loongarch_instruction {
 unsigned int word;
 struct reg0i15_format reg0i15_format;
 struct reg0i26_format reg0i26_format;
 struct reg1i20_format reg1i20_format;
 struct reg1i21_format reg1i21_format;
 struct reg2_format reg2_format;
 struct reg2i5_format reg2i5_format;
 struct reg2i6_format reg2i6_format;
 struct reg2i12_format reg2i12_format;
 struct reg2i14_format reg2i14_format;
 struct reg2i16_format reg2i16_format;
 struct reg2bstrd_format reg2bstrd_format;
 struct reg2csr_format   reg2csr_format;
 struct reg3_format reg3_format;
 struct reg3sa2_format reg3sa2_format;
};

#define LOONGARCH_INSN_SIZE sizeof(union loongarch_instruction)

enum loongarch_gpr {
 LOONGARCH_GPR_ZERO = 0,
 LOONGARCH_GPR_RA = 1,
 LOONGARCH_GPR_TP = 2,
 LOONGARCH_GPR_SP = 3,
 LOONGARCH_GPR_A0 = 4, /* Reused as V0 for return value */
 LOONGARCH_GPR_A1, /* Reused as V1 for return value */
 LOONGARCH_GPR_A2,
 LOONGARCH_GPR_A3,
 LOONGARCH_GPR_A4,
 LOONGARCH_GPR_A5,
 LOONGARCH_GPR_A6,
 LOONGARCH_GPR_A7,
 LOONGARCH_GPR_T0 = 12,
 LOONGARCH_GPR_T1,
 LOONGARCH_GPR_T2,
 LOONGARCH_GPR_T3,
 LOONGARCH_GPR_T4,
 LOONGARCH_GPR_T5,
 LOONGARCH_GPR_T6,
 LOONGARCH_GPR_T7,
 LOONGARCH_GPR_T8,
 LOONGARCH_GPR_FP = 22,
 LOONGARCH_GPR_S0 = 23,
 LOONGARCH_GPR_S1,
 LOONGARCH_GPR_S2,
 LOONGARCH_GPR_S3,
 LOONGARCH_GPR_S4,
 LOONGARCH_GPR_S5,
 LOONGARCH_GPR_S6,
 LOONGARCH_GPR_S7,
 LOONGARCH_GPR_S8,
 LOONGARCH_GPR_MAX
};

#define is_imm12_negative(val) is_imm_negative(val, 12)

static inline bool is_imm_negative(unsigned long val, unsigned int bit)
{
 return val & (1UL << (bit - 1));
}

static inline bool is_break_ins(union loongarch_instruction *ip)
{
 return ip->reg0i15_format.opcode == break_op;
}

static inline bool is_pc_ins(union loongarch_instruction *ip)
{
 return ip->reg1i20_format.opcode >= pcaddi_op &&
   ip->reg1i20_format.opcode <= pcaddu18i_op;
}

static inline bool is_branch_ins(union loongarch_instruction *ip)
{
 return ip->reg1i21_format.opcode >= beqz_op &&
  ip->reg1i21_format.opcode <= bgeu_op;
}

static inline bool is_ra_save_ins(union loongarch_instruction *ip)
{
 /* st.d $ra, $sp, offset */
 return ip->reg2i12_format.opcode == std_op &&
  ip->reg2i12_format.rj == LOONGARCH_GPR_SP &&
  ip->reg2i12_format.rd == LOONGARCH_GPR_RA &&
  !is_imm12_negative(ip->reg2i12_format.immediate);
}

static inline bool is_stack_alloc_ins(union loongarch_instruction *ip)
{
 /* addi.d $sp, $sp, -imm */
 return ip->reg2i12_format.opcode == addid_op &&
  ip->reg2i12_format.rj == LOONGARCH_GPR_SP &&
  ip->reg2i12_format.rd == LOONGARCH_GPR_SP &&
  is_imm12_negative(ip->reg2i12_format.immediate);
}

static inline bool is_self_loop_ins(union loongarch_instruction *ip, struct pt_regs *regs)
{
 switch (ip->reg0i26_format.opcode) {
 case b_op:
 case bl_op:
  if (ip->reg0i26_format.immediate_l == 0
      && ip->reg0i26_format.immediate_h == 0)
   return true;
 }

 switch (ip->reg1i21_format.opcode) {
 case beqz_op:
 case bnez_op:
 case bceqz_op:
  if (ip->reg1i21_format.immediate_l == 0
      && ip->reg1i21_format.immediate_h == 0)
   return true;
 }

 switch (ip->reg2i16_format.opcode) {
 case beq_op:
 case bne_op:
 case blt_op:
 case bge_op:
 case bltu_op:
 case bgeu_op:
  if (ip->reg2i16_format.immediate == 0)
   return true;
  break;
 case jirl_op:
  if (regs->regs[ip->reg2i16_format.rj] +
      ((unsigned long)ip->reg2i16_format.immediate << 2) == (unsigned long)ip)
   return true;
 }

 return false;
}

void simu_pc(struct pt_regs *regs, union loongarch_instruction insn);
void simu_branch(struct pt_regs *regs, union loongarch_instruction insn);

bool insns_not_supported(union loongarch_instruction insn);
bool insns_need_simulation(union loongarch_instruction insn);
void arch_simulate_insn(union loongarch_instruction insn, struct pt_regs *regs);

int larch_insn_read(void *addr, u32 *insnp);
int larch_insn_write(void *addr, u32 insn);
int larch_insn_patch_text(void *addr, u32 insn);
int larch_insn_text_copy(void *dst, void *src, size_t len);

u32 larch_insn_gen_nop(void);
u32 larch_insn_gen_b(unsigned long pc, unsigned long dest);
u32 larch_insn_gen_bl(unsigned long pc, unsigned long dest);

u32 larch_insn_gen_break(int imm);

u32 larch_insn_gen_or(enum loongarch_gpr rd, enum loongarch_gpr rj, enum loongarch_gpr rk);
u32 larch_insn_gen_move(enum loongarch_gpr rd, enum loongarch_gpr rj);

u32 larch_insn_gen_lu12iw(enum loongarch_gpr rd, int imm);
u32 larch_insn_gen_lu32id(enum loongarch_gpr rd, int imm);
u32 larch_insn_gen_lu52id(enum loongarch_gpr rd, enum loongarch_gpr rj, int imm);
u32 larch_insn_gen_beq(enum loongarch_gpr rd, enum loongarch_gpr rj, int imm);
u32 larch_insn_gen_bne(enum loongarch_gpr rd, enum loongarch_gpr rj, int imm);
u32 larch_insn_gen_jirl(enum loongarch_gpr rd, enum loongarch_gpr rj, int imm);

static inline bool signed_imm_check(long val, unsigned int bit)
{
 return -(1L << (bit - 1)) <= val && val < (1L << (bit - 1));
}

static inline bool unsigned_imm_check(unsigned long val, unsigned int bit)
{
 return val < (1UL << bit);
}

#define DEF_EMIT_REG0I15_FORMAT(NAME, OP)    \
static inline void emit_##NAME(union loongarch_instruction *insn, \
          int imm)     \
{         \
 insn->reg0i15_format.opcode = OP;    \
 insn->reg0i15_format.immediate = imm;    \
}

DEF_EMIT_REG0I15_FORMAT(break, break_op)

/* like emit_break(imm) but returns a constant expression */
#define __emit_break(imm) ((u32)((imm) | (break_op << 15)))

#define DEF_EMIT_REG0I26_FORMAT(NAME, OP)    \
static inline void emit_##NAME(union loongarch_instruction *insn, \
          int offset)    \
{         \
 unsigned int immediate_l, immediate_h;    \
         \
 immediate_l = offset & 0xffff;     \
 offset >>= 16;       \
 immediate_h = offset & 0x3ff;     \
         \
 insn->reg0i26_format.opcode = OP;    \
 insn->reg0i26_format.immediate_l = immediate_l;   \
 insn->reg0i26_format.immediate_h = immediate_h;   \
}

DEF_EMIT_REG0I26_FORMAT(b, b_op)
DEF_EMIT_REG0I26_FORMAT(bl, bl_op)

#define DEF_EMIT_REG1I20_FORMAT(NAME, OP)    \
static inline void emit_##NAME(union loongarch_instruction *insn, \
          enum loongarch_gpr rd, int imm)  \
{         \
 insn->reg1i20_format.opcode = OP;    \
 insn->reg1i20_format.immediate = imm;    \
 insn->reg1i20_format.rd = rd;     \
}

DEF_EMIT_REG1I20_FORMAT(lu12iw, lu12iw_op)
DEF_EMIT_REG1I20_FORMAT(lu32id, lu32id_op)
DEF_EMIT_REG1I20_FORMAT(pcaddu18i, pcaddu18i_op)

#define DEF_EMIT_REG2_FORMAT(NAME, OP)     \
static inline void emit_##NAME(union loongarch_instruction *insn, \
          enum loongarch_gpr rd,   \
          enum loongarch_gpr rj)   \
{         \
 insn->reg2_format.opcode = OP;     \
 insn->reg2_format.rd = rd;     \
 insn->reg2_format.rj = rj;     \
}

DEF_EMIT_REG2_FORMAT(revb2h, revb2h_op)
DEF_EMIT_REG2_FORMAT(revb2w, revb2w_op)
DEF_EMIT_REG2_FORMAT(revbd, revbd_op)
DEF_EMIT_REG2_FORMAT(extwh, extwh_op)
DEF_EMIT_REG2_FORMAT(extwb, extwb_op)

#define DEF_EMIT_REG2I5_FORMAT(NAME, OP)    \
static inline void emit_##NAME(union loongarch_instruction *insn, \
          enum loongarch_gpr rd,   \
          enum loongarch_gpr rj,   \
          int imm)     \
{         \
 insn->reg2i5_format.opcode = OP;    \
 insn->reg2i5_format.immediate = imm;    \
 insn->reg2i5_format.rd = rd;     \
 insn->reg2i5_format.rj = rj;     \
}

DEF_EMIT_REG2I5_FORMAT(slliw, slliw_op)
DEF_EMIT_REG2I5_FORMAT(srliw, srliw_op)
DEF_EMIT_REG2I5_FORMAT(sraiw, sraiw_op)

#define DEF_EMIT_REG2I6_FORMAT(NAME, OP)    \
static inline void emit_##NAME(union loongarch_instruction *insn, \
          enum loongarch_gpr rd,   \
          enum loongarch_gpr rj,   \
          int imm)     \
{         \
 insn->reg2i6_format.opcode = OP;    \
 insn->reg2i6_format.immediate = imm;    \
 insn->reg2i6_format.rd = rd;     \
 insn->reg2i6_format.rj = rj;     \
}

DEF_EMIT_REG2I6_FORMAT(sllid, sllid_op)
DEF_EMIT_REG2I6_FORMAT(srlid, srlid_op)
DEF_EMIT_REG2I6_FORMAT(sraid, sraid_op)

#define DEF_EMIT_REG2I12_FORMAT(NAME, OP)    \
static inline void emit_##NAME(union loongarch_instruction *insn, \
          enum loongarch_gpr rd,   \
          enum loongarch_gpr rj,   \
          int imm)     \
{         \
 insn->reg2i12_format.opcode = OP;    \
 insn->reg2i12_format.immediate = imm;    \
 insn->reg2i12_format.rd = rd;     \
 insn->reg2i12_format.rj = rj;     \
}

DEF_EMIT_REG2I12_FORMAT(addiw, addiw_op)
DEF_EMIT_REG2I12_FORMAT(addid, addid_op)
DEF_EMIT_REG2I12_FORMAT(lu52id, lu52id_op)
DEF_EMIT_REG2I12_FORMAT(andi, andi_op)
DEF_EMIT_REG2I12_FORMAT(ori, ori_op)
DEF_EMIT_REG2I12_FORMAT(xori, xori_op)
DEF_EMIT_REG2I12_FORMAT(ldb, ldb_op)
DEF_EMIT_REG2I12_FORMAT(ldh, ldh_op)
DEF_EMIT_REG2I12_FORMAT(ldw, ldw_op)
DEF_EMIT_REG2I12_FORMAT(ldbu, ldbu_op)
DEF_EMIT_REG2I12_FORMAT(ldhu, ldhu_op)
DEF_EMIT_REG2I12_FORMAT(ldwu, ldwu_op)
DEF_EMIT_REG2I12_FORMAT(ldd, ldd_op)
DEF_EMIT_REG2I12_FORMAT(stb, stb_op)
DEF_EMIT_REG2I12_FORMAT(sth, sth_op)
DEF_EMIT_REG2I12_FORMAT(stw, stw_op)
DEF_EMIT_REG2I12_FORMAT(std, std_op)

#define DEF_EMIT_REG2I14_FORMAT(NAME, OP)    \
static inline void emit_##NAME(union loongarch_instruction *insn, \
          enum loongarch_gpr rd,   \
          enum loongarch_gpr rj,   \
          int imm)     \
{         \
 insn->reg2i14_format.opcode = OP;    \
 insn->reg2i14_format.immediate = imm;    \
 insn->reg2i14_format.rd = rd;     \
 insn->reg2i14_format.rj = rj;     \
}

DEF_EMIT_REG2I14_FORMAT(llw, llw_op)
DEF_EMIT_REG2I14_FORMAT(scw, scw_op)
DEF_EMIT_REG2I14_FORMAT(lld, lld_op)
DEF_EMIT_REG2I14_FORMAT(scd, scd_op)
DEF_EMIT_REG2I14_FORMAT(ldptrw, ldptrw_op)
DEF_EMIT_REG2I14_FORMAT(stptrw, stptrw_op)
DEF_EMIT_REG2I14_FORMAT(ldptrd, ldptrd_op)
DEF_EMIT_REG2I14_FORMAT(stptrd, stptrd_op)

#define DEF_EMIT_REG2I16_FORMAT(NAME, OP)    \
static inline void emit_##NAME(union loongarch_instruction *insn, \
          enum loongarch_gpr rj,   \
          enum loongarch_gpr rd,   \
          int offset)    \
{         \
 insn->reg2i16_format.opcode = OP;    \
 insn->reg2i16_format.immediate = offset;   \
 insn->reg2i16_format.rj = rj;     \
 insn->reg2i16_format.rd = rd;     \
}

DEF_EMIT_REG2I16_FORMAT(beq, beq_op)
DEF_EMIT_REG2I16_FORMAT(bne, bne_op)
DEF_EMIT_REG2I16_FORMAT(blt, blt_op)
DEF_EMIT_REG2I16_FORMAT(bge, bge_op)
DEF_EMIT_REG2I16_FORMAT(bltu, bltu_op)
DEF_EMIT_REG2I16_FORMAT(bgeu, bgeu_op)

static inline void emit_jirl(union loongarch_instruction *insn,
        enum loongarch_gpr rd,
        enum loongarch_gpr rj,
        int offset)
{
 insn->reg2i16_format.opcode = jirl_op;
 insn->reg2i16_format.immediate = offset;
 insn->reg2i16_format.rd = rd;
 insn->reg2i16_format.rj = rj;
}

#define DEF_EMIT_REG2BSTRD_FORMAT(NAME, OP)    \
static inline void emit_##NAME(union loongarch_instruction *insn, \
          enum loongarch_gpr rd,   \
          enum loongarch_gpr rj,   \
          int msbd,    \
          int lsbd)    \
{         \
 insn->reg2bstrd_format.opcode = OP;    \
 insn->reg2bstrd_format.msbd = msbd;    \
 insn->reg2bstrd_format.lsbd = lsbd;    \
 insn->reg2bstrd_format.rj = rj;     \
 insn->reg2bstrd_format.rd = rd;     \
}

DEF_EMIT_REG2BSTRD_FORMAT(bstrpickd, bstrpickd_op)

#define DEF_EMIT_REG3_FORMAT(NAME, OP)     \
static inline void emit_##NAME(union loongarch_instruction *insn, \
          enum loongarch_gpr rd,   \
          enum loongarch_gpr rj,   \
          enum loongarch_gpr rk)   \
{         \
 insn->reg3_format.opcode = OP;     \
 insn->reg3_format.rd = rd;     \
 insn->reg3_format.rj = rj;     \
 insn->reg3_format.rk = rk;     \
}

DEF_EMIT_REG3_FORMAT(addw, addw_op)
DEF_EMIT_REG3_FORMAT(addd, addd_op)
DEF_EMIT_REG3_FORMAT(subd, subd_op)
DEF_EMIT_REG3_FORMAT(muld, muld_op)
DEF_EMIT_REG3_FORMAT(divd, divd_op)
DEF_EMIT_REG3_FORMAT(modd, modd_op)
DEF_EMIT_REG3_FORMAT(divdu, divdu_op)
DEF_EMIT_REG3_FORMAT(moddu, moddu_op)
DEF_EMIT_REG3_FORMAT(and, and_op)
DEF_EMIT_REG3_FORMAT(or, or_op)
DEF_EMIT_REG3_FORMAT(xor, xor_op)
DEF_EMIT_REG3_FORMAT(sllw, sllw_op)
DEF_EMIT_REG3_FORMAT(slld, slld_op)
DEF_EMIT_REG3_FORMAT(srlw, srlw_op)
DEF_EMIT_REG3_FORMAT(srld, srld_op)
DEF_EMIT_REG3_FORMAT(sraw, sraw_op)
DEF_EMIT_REG3_FORMAT(srad, srad_op)
DEF_EMIT_REG3_FORMAT(ldxb, ldxb_op)
DEF_EMIT_REG3_FORMAT(ldxh, ldxh_op)
DEF_EMIT_REG3_FORMAT(ldxw, ldxw_op)
DEF_EMIT_REG3_FORMAT(ldxbu, ldxbu_op)
DEF_EMIT_REG3_FORMAT(ldxhu, ldxhu_op)
DEF_EMIT_REG3_FORMAT(ldxwu, ldxwu_op)
DEF_EMIT_REG3_FORMAT(ldxd, ldxd_op)
DEF_EMIT_REG3_FORMAT(stxb, stxb_op)
DEF_EMIT_REG3_FORMAT(stxh, stxh_op)
DEF_EMIT_REG3_FORMAT(stxw, stxw_op)
DEF_EMIT_REG3_FORMAT(stxd, stxd_op)
DEF_EMIT_REG3_FORMAT(amaddw, amaddw_op)
DEF_EMIT_REG3_FORMAT(amaddd, amaddd_op)
DEF_EMIT_REG3_FORMAT(amandw, amandw_op)
DEF_EMIT_REG3_FORMAT(amandd, amandd_op)
DEF_EMIT_REG3_FORMAT(amorw, amorw_op)
DEF_EMIT_REG3_FORMAT(amord, amord_op)
DEF_EMIT_REG3_FORMAT(amxorw, amxorw_op)
DEF_EMIT_REG3_FORMAT(amxord, amxord_op)
DEF_EMIT_REG3_FORMAT(amswapw, amswapw_op)
DEF_EMIT_REG3_FORMAT(amswapd, amswapd_op)

#define DEF_EMIT_REG3SA2_FORMAT(NAME, OP)    \
static inline void emit_##NAME(union loongarch_instruction *insn, \
          enum loongarch_gpr rd,   \
          enum loongarch_gpr rj,   \
          enum loongarch_gpr rk,   \
          int imm)     \
{         \
 insn->reg3sa2_format.opcode = OP;    \
 insn->reg3sa2_format.immediate = imm;    \
 insn->reg3sa2_format.rd = rd;     \
 insn->reg3sa2_format.rj = rj;     \
 insn->reg3sa2_format.rk = rk;     \
}

DEF_EMIT_REG3SA2_FORMAT(alsld, alsld_op)

struct pt_regs;

void emulate_load_store_insn(struct pt_regs *regs, void __user *addr, unsigned int *pc);
unsigned long unaligned_read(void __user *addr, void *value, unsigned long n, bool sign);
unsigned long unaligned_write(void __user *addr, unsigned long value, unsigned long n);

#endif /* _ASM_INST_H */