gen_riscv_new_nodes.h

#ifndef FIRM_BE_RISCV_GEN_RISCV_NEW_NODES_H
#define FIRM_BE_RISCV_GEN_RISCV_NEW_NODES_H

#include "be_types.h"
#include "irnode_t.h"
#include "riscv_nodes_attr.h"

typedef enum riscv_opcodes {
    iro_riscv_add,
    iro_riscv_addi,
    iro_riscv_and,
    iro_riscv_andi,
    iro_riscv_bcc,
    iro_riscv_div,
    iro_riscv_divu,
    iro_riscv_ijmp,
    iro_riscv_j,
    iro_riscv_jal,
    iro_riscv_jalr,
    iro_riscv_lb,
    iro_riscv_lbu,
    iro_riscv_lh,
    iro_riscv_lhu,
    iro_riscv_lui,
    iro_riscv_lw,
    iro_riscv_mul,
    iro_riscv_mulh,
    iro_riscv_mulhu,
    iro_riscv_or,
    iro_riscv_ori,
    iro_riscv_rem,
    iro_riscv_remu,
    iro_riscv_ret,
    iro_riscv_sb,
    iro_riscv_sh,
    iro_riscv_sll,
    iro_riscv_slli,
    iro_riscv_slt,
    iro_riscv_sltiu,
    iro_riscv_sltu,
    iro_riscv_sra,
    iro_riscv_srai,
    iro_riscv_srl,
    iro_riscv_srli,
    iro_riscv_sub,
    iro_riscv_sw,
    iro_riscv_switch,
    iro_riscv_xor,
    iro_riscv_xori,
    iro_riscv_last
} riscv_opcodes;


int is_riscv_irn(const ir_node *node);
int is_riscv_op(const ir_op *op);

int get_riscv_irn_opcode(const ir_node *node);
void riscv_create_opcodes(void);
void riscv_free_opcodes(void);

extern ir_op *op_riscv_add;

static inline bool is_riscv_add(ir_node const *const n)
{
    return get_irn_op(n) == op_riscv_add;
}

ir_node *new_bd_riscv_add(dbg_info *dbgi, ir_node *block, ir_node *left, ir_node *right);

extern ir_op *op_riscv_addi;

static inline bool is_riscv_addi(ir_node const *const n)
{
    return get_irn_op(n) == op_riscv_addi;
}

ir_node *new_bd_riscv_addi(dbg_info *dbgi, ir_node *block, ir_node *left, ir_entity *const ent, int32_t const val);

extern ir_op *op_riscv_and;

static inline bool is_riscv_and(ir_node const *const n)
{
    return get_irn_op(n) == op_riscv_and;
}

ir_node *new_bd_riscv_and(dbg_info *dbgi, ir_node *block, ir_node *left, ir_node *right);

extern ir_op *op_riscv_andi;

static inline bool is_riscv_andi(ir_node const *const n)
{
    return get_irn_op(n) == op_riscv_andi;
}

ir_node *new_bd_riscv_andi(dbg_info *dbgi, ir_node *block, ir_node *left, ir_entity *const ent, int32_t const val);

extern ir_op *op_riscv_bcc;

static inline bool is_riscv_bcc(ir_node const *const n)
{
    return get_irn_op(n) == op_riscv_bcc;
}

ir_node *new_bd_riscv_bcc(dbg_info *dbgi, ir_node *block, ir_node *left, ir_node *right, riscv_cond_t const cond);

extern ir_op *op_riscv_div;

static inline bool is_riscv_div(ir_node const *const n)
{
    return get_irn_op(n) == op_riscv_div;
}

ir_node *new_bd_riscv_div(dbg_info *dbgi, ir_node *block, ir_node *left, ir_node *right);

extern ir_op *op_riscv_divu;

static inline bool is_riscv_divu(ir_node const *const n)
{
    return get_irn_op(n) == op_riscv_divu;
}

ir_node *new_bd_riscv_divu(dbg_info *dbgi, ir_node *block, ir_node *left, ir_node *right);

extern ir_op *op_riscv_ijmp;

static inline bool is_riscv_ijmp(ir_node const *const n)
{
    return get_irn_op(n) == op_riscv_ijmp;
}

ir_node *new_bd_riscv_ijmp(dbg_info *dbgi, ir_node *block, ir_node *op0);

extern ir_op *op_riscv_j;

static inline bool is_riscv_j(ir_node const *const n)
{
    return get_irn_op(n) == op_riscv_j;
}

ir_node *new_bd_riscv_j(dbg_info *dbgi, ir_node *block);

extern ir_op *op_riscv_jal;

static inline bool is_riscv_jal(ir_node const *const n)
{
    return get_irn_op(n) == op_riscv_jal;
}

ir_node *new_bd_riscv_jal(dbg_info *dbgi, ir_node *block, int const arity, ir_node *const *const in, arch_register_req_t const **const in_reqs, int n_res, ir_entity *const ent, int32_t const val);

extern ir_op *op_riscv_jalr;

static inline bool is_riscv_jalr(ir_node const *const n)
{
    return get_irn_op(n) == op_riscv_jalr;
}

ir_node *new_bd_riscv_jalr(dbg_info *dbgi, ir_node *block, int const arity, ir_node *const *const in, arch_register_req_t const **const in_reqs, int n_res);

extern ir_op *op_riscv_lb;

static inline bool is_riscv_lb(ir_node const *const n)
{
    return get_irn_op(n) == op_riscv_lb;
}

ir_node *new_bd_riscv_lb(dbg_info *dbgi, ir_node *block, ir_node *mem, ir_node *base, ir_entity *const ent, int32_t const val);

extern ir_op *op_riscv_lbu;

static inline bool is_riscv_lbu(ir_node const *const n)
{
    return get_irn_op(n) == op_riscv_lbu;
}

ir_node *new_bd_riscv_lbu(dbg_info *dbgi, ir_node *block, ir_node *mem, ir_node *base, ir_entity *const ent, int32_t const val);

extern ir_op *op_riscv_lh;

static inline bool is_riscv_lh(ir_node const *const n)
{
    return get_irn_op(n) == op_riscv_lh;
}

ir_node *new_bd_riscv_lh(dbg_info *dbgi, ir_node *block, ir_node *mem, ir_node *base, ir_entity *const ent, int32_t const val);

extern ir_op *op_riscv_lhu;

static inline bool is_riscv_lhu(ir_node const *const n)
{
    return get_irn_op(n) == op_riscv_lhu;
}

ir_node *new_bd_riscv_lhu(dbg_info *dbgi, ir_node *block, ir_node *mem, ir_node *base, ir_entity *const ent, int32_t const val);

extern ir_op *op_riscv_lui;

static inline bool is_riscv_lui(ir_node const *const n)
{
    return get_irn_op(n) == op_riscv_lui;
}

ir_node *new_bd_riscv_lui(dbg_info *dbgi, ir_node *block, ir_entity *const ent, int32_t const val);

extern ir_op *op_riscv_lw;

static inline bool is_riscv_lw(ir_node const *const n)
{
    return get_irn_op(n) == op_riscv_lw;
}

ir_node *new_bd_riscv_lw(dbg_info *dbgi, ir_node *block, ir_node *mem, ir_node *base, ir_entity *const ent, int32_t const val);

extern ir_op *op_riscv_mul;

static inline bool is_riscv_mul(ir_node const *const n)
{
    return get_irn_op(n) == op_riscv_mul;
}

ir_node *new_bd_riscv_mul(dbg_info *dbgi, ir_node *block, ir_node *left, ir_node *right);

extern ir_op *op_riscv_mulh;

static inline bool is_riscv_mulh(ir_node const *const n)
{
    return get_irn_op(n) == op_riscv_mulh;
}

ir_node *new_bd_riscv_mulh(dbg_info *dbgi, ir_node *block, ir_node *left, ir_node *right);

extern ir_op *op_riscv_mulhu;

static inline bool is_riscv_mulhu(ir_node const *const n)
{
    return get_irn_op(n) == op_riscv_mulhu;
}

ir_node *new_bd_riscv_mulhu(dbg_info *dbgi, ir_node *block, ir_node *left, ir_node *right);

extern ir_op *op_riscv_or;

static inline bool is_riscv_or(ir_node const *const n)
{
    return get_irn_op(n) == op_riscv_or;
}

ir_node *new_bd_riscv_or(dbg_info *dbgi, ir_node *block, ir_node *left, ir_node *right);

extern ir_op *op_riscv_ori;

static inline bool is_riscv_ori(ir_node const *const n)
{
    return get_irn_op(n) == op_riscv_ori;
}

ir_node *new_bd_riscv_ori(dbg_info *dbgi, ir_node *block, ir_node *left, ir_entity *const ent, int32_t const val);

extern ir_op *op_riscv_rem;

static inline bool is_riscv_rem(ir_node const *const n)
{
    return get_irn_op(n) == op_riscv_rem;
}

ir_node *new_bd_riscv_rem(dbg_info *dbgi, ir_node *block, ir_node *left, ir_node *right);

extern ir_op *op_riscv_remu;

static inline bool is_riscv_remu(ir_node const *const n)
{
    return get_irn_op(n) == op_riscv_remu;
}

ir_node *new_bd_riscv_remu(dbg_info *dbgi, ir_node *block, ir_node *left, ir_node *right);

extern ir_op *op_riscv_ret;

static inline bool is_riscv_ret(ir_node const *const n)
{
    return get_irn_op(n) == op_riscv_ret;
}

ir_node *new_bd_riscv_ret(dbg_info *dbgi, ir_node *block, int const arity, ir_node *const *const in, arch_register_req_t const **const in_reqs);

extern ir_op *op_riscv_sb;

static inline bool is_riscv_sb(ir_node const *const n)
{
    return get_irn_op(n) == op_riscv_sb;
}

ir_node *new_bd_riscv_sb(dbg_info *dbgi, ir_node *block, ir_node *mem, ir_node *base, ir_node *value, ir_entity *const ent, int32_t const val);

extern ir_op *op_riscv_sh;

static inline bool is_riscv_sh(ir_node const *const n)
{
    return get_irn_op(n) == op_riscv_sh;
}

ir_node *new_bd_riscv_sh(dbg_info *dbgi, ir_node *block, ir_node *mem, ir_node *base, ir_node *value, ir_entity *const ent, int32_t const val);

extern ir_op *op_riscv_sll;

static inline bool is_riscv_sll(ir_node const *const n)
{
    return get_irn_op(n) == op_riscv_sll;
}

ir_node *new_bd_riscv_sll(dbg_info *dbgi, ir_node *block, ir_node *left, ir_node *right);

extern ir_op *op_riscv_slli;

static inline bool is_riscv_slli(ir_node const *const n)
{
    return get_irn_op(n) == op_riscv_slli;
}

ir_node *new_bd_riscv_slli(dbg_info *dbgi, ir_node *block, ir_node *left, ir_entity *const ent, int32_t const val);

extern ir_op *op_riscv_slt;

static inline bool is_riscv_slt(ir_node const *const n)
{
    return get_irn_op(n) == op_riscv_slt;
}

ir_node *new_bd_riscv_slt(dbg_info *dbgi, ir_node *block, ir_node *left, ir_node *right);

extern ir_op *op_riscv_sltiu;

static inline bool is_riscv_sltiu(ir_node const *const n)
{
    return get_irn_op(n) == op_riscv_sltiu;
}

ir_node *new_bd_riscv_sltiu(dbg_info *dbgi, ir_node *block, ir_node *left, ir_entity *const ent, int32_t const val);

extern ir_op *op_riscv_sltu;

static inline bool is_riscv_sltu(ir_node const *const n)
{
    return get_irn_op(n) == op_riscv_sltu;
}

ir_node *new_bd_riscv_sltu(dbg_info *dbgi, ir_node *block, ir_node *left, ir_node *right);

extern ir_op *op_riscv_sra;

static inline bool is_riscv_sra(ir_node const *const n)
{
    return get_irn_op(n) == op_riscv_sra;
}

ir_node *new_bd_riscv_sra(dbg_info *dbgi, ir_node *block, ir_node *left, ir_node *right);

extern ir_op *op_riscv_srai;

static inline bool is_riscv_srai(ir_node const *const n)
{
    return get_irn_op(n) == op_riscv_srai;
}

ir_node *new_bd_riscv_srai(dbg_info *dbgi, ir_node *block, ir_node *left, ir_entity *const ent, int32_t const val);

extern ir_op *op_riscv_srl;

static inline bool is_riscv_srl(ir_node const *const n)
{
    return get_irn_op(n) == op_riscv_srl;
}

ir_node *new_bd_riscv_srl(dbg_info *dbgi, ir_node *block, ir_node *left, ir_node *right);

extern ir_op *op_riscv_srli;

static inline bool is_riscv_srli(ir_node const *const n)
{
    return get_irn_op(n) == op_riscv_srli;
}

ir_node *new_bd_riscv_srli(dbg_info *dbgi, ir_node *block, ir_node *left, ir_entity *const ent, int32_t const val);

extern ir_op *op_riscv_sub;

static inline bool is_riscv_sub(ir_node const *const n)
{
    return get_irn_op(n) == op_riscv_sub;
}

ir_node *new_bd_riscv_sub(dbg_info *dbgi, ir_node *block, ir_node *left, ir_node *right);

extern ir_op *op_riscv_sw;

static inline bool is_riscv_sw(ir_node const *const n)
{
    return get_irn_op(n) == op_riscv_sw;
}

ir_node *new_bd_riscv_sw(dbg_info *dbgi, ir_node *block, ir_node *mem, ir_node *base, ir_node *value, ir_entity *const ent, int32_t const val);

extern ir_op *op_riscv_switch;

static inline bool is_riscv_switch(ir_node const *const n)
{
    return get_irn_op(n) == op_riscv_switch;
}

ir_node *new_bd_riscv_switch(dbg_info *dbgi, ir_node *block, ir_node *op0, int n_res, const ir_switch_table *table, ir_entity *table_entity);

extern ir_op *op_riscv_xor;

static inline bool is_riscv_xor(ir_node const *const n)
{
    return get_irn_op(n) == op_riscv_xor;
}

ir_node *new_bd_riscv_xor(dbg_info *dbgi, ir_node *block, ir_node *left, ir_node *right);

extern ir_op *op_riscv_xori;

static inline bool is_riscv_xori(ir_node const *const n)
{
    return get_irn_op(n) == op_riscv_xori;
}

ir_node *new_bd_riscv_xori(dbg_info *dbgi, ir_node *block, ir_node *left, ir_entity *const ent, int32_t const val);


typedef enum pn_riscv_add {
    pn_riscv_add_res = 0,
} pn_riscv_add;

typedef enum n_riscv_add {
    n_riscv_add_left = 0,
    n_riscv_add_right = 1,
} n_riscv_add;

typedef enum pn_riscv_addi {
    pn_riscv_addi_res = 0,
} pn_riscv_addi;

typedef enum n_riscv_addi {
    n_riscv_addi_left = 0,
} n_riscv_addi;

typedef enum pn_riscv_and {
    pn_riscv_and_res = 0,
} pn_riscv_and;

typedef enum n_riscv_and {
    n_riscv_and_left = 0,
    n_riscv_and_right = 1,
} n_riscv_and;

typedef enum pn_riscv_andi {
    pn_riscv_andi_res = 0,
} pn_riscv_andi;

typedef enum n_riscv_andi {
    n_riscv_andi_left = 0,
} n_riscv_andi;

typedef enum pn_riscv_bcc {
    pn_riscv_bcc_false = 0,
    pn_riscv_bcc_true = 1,
} pn_riscv_bcc;

typedef enum n_riscv_bcc {
    n_riscv_bcc_left = 0,
    n_riscv_bcc_right = 1,
} n_riscv_bcc;

typedef enum pn_riscv_div {
    pn_riscv_div_res = 0,
} pn_riscv_div;

typedef enum n_riscv_div {
    n_riscv_div_left = 0,
    n_riscv_div_right = 1,
} n_riscv_div;

typedef enum pn_riscv_divu {
    pn_riscv_divu_res = 0,
} pn_riscv_divu;

typedef enum n_riscv_divu {
    n_riscv_divu_left = 0,
    n_riscv_divu_right = 1,
} n_riscv_divu;

typedef enum pn_riscv_jal {
    pn_riscv_jal_M = 0,
    pn_riscv_jal_stack = 1,
    pn_riscv_jal_first_result = 2,
} pn_riscv_jal;

typedef enum n_riscv_jal {
    n_riscv_jal_mem = 0,
    n_riscv_jal_stack = 1,
    n_riscv_jal_first_argument = 2,
} n_riscv_jal;

typedef enum pn_riscv_jalr {
    pn_riscv_jalr_M = 0,
    pn_riscv_jalr_stack = 1,
    pn_riscv_jalr_first_result = 2,
} pn_riscv_jalr;

typedef enum n_riscv_jalr {
    n_riscv_jalr_mem = 0,
    n_riscv_jalr_stack = 1,
    n_riscv_jalr_first_argument = 2,
} n_riscv_jalr;

typedef enum pn_riscv_lb {
    pn_riscv_lb_M = 0,
    pn_riscv_lb_res = 1,
} pn_riscv_lb;

typedef enum n_riscv_lb {
    n_riscv_lb_mem = 0,
    n_riscv_lb_base = 1,
} n_riscv_lb;

typedef enum pn_riscv_lbu {
    pn_riscv_lbu_M = 0,
    pn_riscv_lbu_res = 1,
} pn_riscv_lbu;

typedef enum n_riscv_lbu {
    n_riscv_lbu_mem = 0,
    n_riscv_lbu_base = 1,
} n_riscv_lbu;

typedef enum pn_riscv_lh {
    pn_riscv_lh_M = 0,
    pn_riscv_lh_res = 1,
} pn_riscv_lh;

typedef enum n_riscv_lh {
    n_riscv_lh_mem = 0,
    n_riscv_lh_base = 1,
} n_riscv_lh;

typedef enum pn_riscv_lhu {
    pn_riscv_lhu_M = 0,
    pn_riscv_lhu_res = 1,
} pn_riscv_lhu;

typedef enum n_riscv_lhu {
    n_riscv_lhu_mem = 0,
    n_riscv_lhu_base = 1,
} n_riscv_lhu;

typedef enum pn_riscv_lui {
    pn_riscv_lui_res = 0,
} pn_riscv_lui;

typedef enum pn_riscv_lw {
    pn_riscv_lw_M = 0,
    pn_riscv_lw_res = 1,
} pn_riscv_lw;

typedef enum n_riscv_lw {
    n_riscv_lw_mem = 0,
    n_riscv_lw_base = 1,
} n_riscv_lw;

typedef enum pn_riscv_mul {
    pn_riscv_mul_res = 0,
} pn_riscv_mul;

typedef enum n_riscv_mul {
    n_riscv_mul_left = 0,
    n_riscv_mul_right = 1,
} n_riscv_mul;

typedef enum pn_riscv_mulh {
    pn_riscv_mulh_res = 0,
} pn_riscv_mulh;

typedef enum n_riscv_mulh {
    n_riscv_mulh_left = 0,
    n_riscv_mulh_right = 1,
} n_riscv_mulh;

typedef enum pn_riscv_mulhu {
    pn_riscv_mulhu_res = 0,
} pn_riscv_mulhu;

typedef enum n_riscv_mulhu {
    n_riscv_mulhu_left = 0,
    n_riscv_mulhu_right = 1,
} n_riscv_mulhu;

typedef enum pn_riscv_or {
    pn_riscv_or_res = 0,
} pn_riscv_or;

typedef enum n_riscv_or {
    n_riscv_or_left = 0,
    n_riscv_or_right = 1,
} n_riscv_or;

typedef enum pn_riscv_ori {
    pn_riscv_ori_res = 0,
} pn_riscv_ori;

typedef enum n_riscv_ori {
    n_riscv_ori_left = 0,
} n_riscv_ori;

typedef enum pn_riscv_rem {
    pn_riscv_rem_res = 0,
} pn_riscv_rem;

typedef enum n_riscv_rem {
    n_riscv_rem_left = 0,
    n_riscv_rem_right = 1,
} n_riscv_rem;

typedef enum pn_riscv_remu {
    pn_riscv_remu_res = 0,
} pn_riscv_remu;

typedef enum n_riscv_remu {
    n_riscv_remu_left = 0,
    n_riscv_remu_right = 1,
} n_riscv_remu;

typedef enum n_riscv_ret {
    n_riscv_ret_mem = 0,
    n_riscv_ret_stack = 1,
    n_riscv_ret_addr = 2,
    n_riscv_ret_first_result = 3,
} n_riscv_ret;

typedef enum pn_riscv_sb {
    pn_riscv_sb_M = 0,
} pn_riscv_sb;

typedef enum n_riscv_sb {
    n_riscv_sb_mem = 0,
    n_riscv_sb_base = 1,
    n_riscv_sb_value = 2,
} n_riscv_sb;

typedef enum pn_riscv_sh {
    pn_riscv_sh_M = 0,
} pn_riscv_sh;

typedef enum n_riscv_sh {
    n_riscv_sh_mem = 0,
    n_riscv_sh_base = 1,
    n_riscv_sh_value = 2,
} n_riscv_sh;

typedef enum pn_riscv_sll {
    pn_riscv_sll_res = 0,
} pn_riscv_sll;

typedef enum n_riscv_sll {
    n_riscv_sll_left = 0,
    n_riscv_sll_right = 1,
} n_riscv_sll;

typedef enum pn_riscv_slli {
    pn_riscv_slli_res = 0,
} pn_riscv_slli;

typedef enum n_riscv_slli {
    n_riscv_slli_left = 0,
} n_riscv_slli;

typedef enum pn_riscv_slt {
    pn_riscv_slt_res = 0,
} pn_riscv_slt;

typedef enum n_riscv_slt {
    n_riscv_slt_left = 0,
    n_riscv_slt_right = 1,
} n_riscv_slt;

typedef enum pn_riscv_sltiu {
    pn_riscv_sltiu_res = 0,
} pn_riscv_sltiu;

typedef enum n_riscv_sltiu {
    n_riscv_sltiu_left = 0,
} n_riscv_sltiu;

typedef enum pn_riscv_sltu {
    pn_riscv_sltu_res = 0,
} pn_riscv_sltu;

typedef enum n_riscv_sltu {
    n_riscv_sltu_left = 0,
    n_riscv_sltu_right = 1,
} n_riscv_sltu;

typedef enum pn_riscv_sra {
    pn_riscv_sra_res = 0,
} pn_riscv_sra;

typedef enum n_riscv_sra {
    n_riscv_sra_left = 0,
    n_riscv_sra_right = 1,
} n_riscv_sra;

typedef enum pn_riscv_srai {
    pn_riscv_srai_res = 0,
} pn_riscv_srai;

typedef enum n_riscv_srai {
    n_riscv_srai_left = 0,
} n_riscv_srai;

typedef enum pn_riscv_srl {
    pn_riscv_srl_res = 0,
} pn_riscv_srl;

typedef enum n_riscv_srl {
    n_riscv_srl_left = 0,
    n_riscv_srl_right = 1,
} n_riscv_srl;

typedef enum pn_riscv_srli {
    pn_riscv_srli_res = 0,
} pn_riscv_srli;

typedef enum n_riscv_srli {
    n_riscv_srli_left = 0,
} n_riscv_srli;

typedef enum pn_riscv_sub {
    pn_riscv_sub_res = 0,
} pn_riscv_sub;

typedef enum n_riscv_sub {
    n_riscv_sub_left = 0,
    n_riscv_sub_right = 1,
} n_riscv_sub;

typedef enum pn_riscv_sw {
    pn_riscv_sw_M = 0,
} pn_riscv_sw;

typedef enum n_riscv_sw {
    n_riscv_sw_mem = 0,
    n_riscv_sw_base = 1,
    n_riscv_sw_value = 2,
} n_riscv_sw;

typedef enum pn_riscv_xor {
    pn_riscv_xor_res = 0,
} pn_riscv_xor;

typedef enum n_riscv_xor {
    n_riscv_xor_left = 0,
    n_riscv_xor_right = 1,
} n_riscv_xor;

typedef enum pn_riscv_xori {
    pn_riscv_xori_res = 0,
} pn_riscv_xori;

typedef enum n_riscv_xori {
    n_riscv_xori_left = 0,
} n_riscv_xori;


#endif