gen_mips_new_nodes.h

#ifndef FIRM_BE_MIPS_GEN_MIPS_NEW_NODES_H
#define FIRM_BE_MIPS_GEN_MIPS_NEW_NODES_H

#include "be_types.h"
#include "irnode_t.h"
#include "mips_nodes_attr.h"

typedef enum mips_opcodes {
    iro_mips_addiu,
    iro_mips_addu,
    iro_mips_and,
    iro_mips_andi,
    iro_mips_b,
    iro_mips_bcc,
    iro_mips_div_hi,
    iro_mips_div_lo,
    iro_mips_divu_hi,
    iro_mips_divu_lo,
    iro_mips_ijmp,
    iro_mips_jal,
    iro_mips_jalr,
    iro_mips_lb,
    iro_mips_lbu,
    iro_mips_lh,
    iro_mips_lhu,
    iro_mips_lui,
    iro_mips_lw,
    iro_mips_mult_hi,
    iro_mips_mult_lo,
    iro_mips_multu_hi,
    iro_mips_nor,
    iro_mips_or,
    iro_mips_ori,
    iro_mips_ret,
    iro_mips_sb,
    iro_mips_sh,
    iro_mips_sll,
    iro_mips_sllv,
    iro_mips_slt,
    iro_mips_sltiu,
    iro_mips_sltu,
    iro_mips_sra,
    iro_mips_srav,
    iro_mips_srl,
    iro_mips_srlv,
    iro_mips_subu,
    iro_mips_sw,
    iro_mips_switch,
    iro_mips_xor,
    iro_mips_xori,
    iro_mips_last
} mips_opcodes;


int is_mips_irn(const ir_node *node);
int is_mips_op(const ir_op *op);

int get_mips_irn_opcode(const ir_node *node);
void mips_create_opcodes(void);
void mips_free_opcodes(void);

extern ir_op *op_mips_addiu;

static inline bool is_mips_addiu(ir_node const *const n)
{
    return get_irn_op(n) == op_mips_addiu;
}

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

extern ir_op *op_mips_addu;

static inline bool is_mips_addu(ir_node const *const n)
{
    return get_irn_op(n) == op_mips_addu;
}

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

extern ir_op *op_mips_and;

static inline bool is_mips_and(ir_node const *const n)
{
    return get_irn_op(n) == op_mips_and;
}

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

extern ir_op *op_mips_andi;

static inline bool is_mips_andi(ir_node const *const n)
{
    return get_irn_op(n) == op_mips_andi;
}

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

extern ir_op *op_mips_b;

static inline bool is_mips_b(ir_node const *const n)
{
    return get_irn_op(n) == op_mips_b;
}

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

extern ir_op *op_mips_bcc;

static inline bool is_mips_bcc(ir_node const *const n)
{
    return get_irn_op(n) == op_mips_bcc;
}

ir_node *new_bd_mips_bcc(dbg_info *dbgi, ir_node *block, ir_node *left, ir_node *right, mips_cond_t const cond);
ir_node *new_bd_mips_bcc_z(dbg_info *dbgi, ir_node *block, ir_node *left, mips_cond_t const cond);

extern ir_op *op_mips_div_hi;

static inline bool is_mips_div_hi(ir_node const *const n)
{
    return get_irn_op(n) == op_mips_div_hi;
}

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

extern ir_op *op_mips_div_lo;

static inline bool is_mips_div_lo(ir_node const *const n)
{
    return get_irn_op(n) == op_mips_div_lo;
}

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

extern ir_op *op_mips_divu_hi;

static inline bool is_mips_divu_hi(ir_node const *const n)
{
    return get_irn_op(n) == op_mips_divu_hi;
}

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

extern ir_op *op_mips_divu_lo;

static inline bool is_mips_divu_lo(ir_node const *const n)
{
    return get_irn_op(n) == op_mips_divu_lo;
}

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

extern ir_op *op_mips_ijmp;

static inline bool is_mips_ijmp(ir_node const *const n)
{
    return get_irn_op(n) == op_mips_ijmp;
}

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

extern ir_op *op_mips_jal;

static inline bool is_mips_jal(ir_node const *const n)
{
    return get_irn_op(n) == op_mips_jal;
}

ir_node *new_bd_mips_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_mips_jalr;

static inline bool is_mips_jalr(ir_node const *const n)
{
    return get_irn_op(n) == op_mips_jalr;
}

ir_node *new_bd_mips_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_mips_lb;

static inline bool is_mips_lb(ir_node const *const n)
{
    return get_irn_op(n) == op_mips_lb;
}

ir_node *new_bd_mips_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_mips_lbu;

static inline bool is_mips_lbu(ir_node const *const n)
{
    return get_irn_op(n) == op_mips_lbu;
}

ir_node *new_bd_mips_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_mips_lh;

static inline bool is_mips_lh(ir_node const *const n)
{
    return get_irn_op(n) == op_mips_lh;
}

ir_node *new_bd_mips_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_mips_lhu;

static inline bool is_mips_lhu(ir_node const *const n)
{
    return get_irn_op(n) == op_mips_lhu;
}

ir_node *new_bd_mips_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_mips_lui;

static inline bool is_mips_lui(ir_node const *const n)
{
    return get_irn_op(n) == op_mips_lui;
}

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

extern ir_op *op_mips_lw;

static inline bool is_mips_lw(ir_node const *const n)
{
    return get_irn_op(n) == op_mips_lw;
}

ir_node *new_bd_mips_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_mips_mult_hi;

static inline bool is_mips_mult_hi(ir_node const *const n)
{
    return get_irn_op(n) == op_mips_mult_hi;
}

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

extern ir_op *op_mips_mult_lo;

static inline bool is_mips_mult_lo(ir_node const *const n)
{
    return get_irn_op(n) == op_mips_mult_lo;
}

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

extern ir_op *op_mips_multu_hi;

static inline bool is_mips_multu_hi(ir_node const *const n)
{
    return get_irn_op(n) == op_mips_multu_hi;
}

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

extern ir_op *op_mips_nor;

static inline bool is_mips_nor(ir_node const *const n)
{
    return get_irn_op(n) == op_mips_nor;
}

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

extern ir_op *op_mips_or;

static inline bool is_mips_or(ir_node const *const n)
{
    return get_irn_op(n) == op_mips_or;
}

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

extern ir_op *op_mips_ori;

static inline bool is_mips_ori(ir_node const *const n)
{
    return get_irn_op(n) == op_mips_ori;
}

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

extern ir_op *op_mips_ret;

static inline bool is_mips_ret(ir_node const *const n)
{
    return get_irn_op(n) == op_mips_ret;
}

ir_node *new_bd_mips_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_mips_sb;

static inline bool is_mips_sb(ir_node const *const n)
{
    return get_irn_op(n) == op_mips_sb;
}

ir_node *new_bd_mips_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_mips_sh;

static inline bool is_mips_sh(ir_node const *const n)
{
    return get_irn_op(n) == op_mips_sh;
}

ir_node *new_bd_mips_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_mips_sll;

static inline bool is_mips_sll(ir_node const *const n)
{
    return get_irn_op(n) == op_mips_sll;
}

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

extern ir_op *op_mips_sllv;

static inline bool is_mips_sllv(ir_node const *const n)
{
    return get_irn_op(n) == op_mips_sllv;
}

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

extern ir_op *op_mips_slt;

static inline bool is_mips_slt(ir_node const *const n)
{
    return get_irn_op(n) == op_mips_slt;
}

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

extern ir_op *op_mips_sltiu;

static inline bool is_mips_sltiu(ir_node const *const n)
{
    return get_irn_op(n) == op_mips_sltiu;
}

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

extern ir_op *op_mips_sltu;

static inline bool is_mips_sltu(ir_node const *const n)
{
    return get_irn_op(n) == op_mips_sltu;
}

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

extern ir_op *op_mips_sra;

static inline bool is_mips_sra(ir_node const *const n)
{
    return get_irn_op(n) == op_mips_sra;
}

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

extern ir_op *op_mips_srav;

static inline bool is_mips_srav(ir_node const *const n)
{
    return get_irn_op(n) == op_mips_srav;
}

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

extern ir_op *op_mips_srl;

static inline bool is_mips_srl(ir_node const *const n)
{
    return get_irn_op(n) == op_mips_srl;
}

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

extern ir_op *op_mips_srlv;

static inline bool is_mips_srlv(ir_node const *const n)
{
    return get_irn_op(n) == op_mips_srlv;
}

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

extern ir_op *op_mips_subu;

static inline bool is_mips_subu(ir_node const *const n)
{
    return get_irn_op(n) == op_mips_subu;
}

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

extern ir_op *op_mips_sw;

static inline bool is_mips_sw(ir_node const *const n)
{
    return get_irn_op(n) == op_mips_sw;
}

ir_node *new_bd_mips_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_mips_switch;

static inline bool is_mips_switch(ir_node const *const n)
{
    return get_irn_op(n) == op_mips_switch;
}

ir_node *new_bd_mips_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_mips_xor;

static inline bool is_mips_xor(ir_node const *const n)
{
    return get_irn_op(n) == op_mips_xor;
}

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

extern ir_op *op_mips_xori;

static inline bool is_mips_xori(ir_node const *const n)
{
    return get_irn_op(n) == op_mips_xori;
}

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


typedef enum pn_mips_addiu {
    pn_mips_addiu_res = 0,
} pn_mips_addiu;

typedef enum n_mips_addiu {
    n_mips_addiu_left = 0,
} n_mips_addiu;

typedef enum pn_mips_addu {
    pn_mips_addu_res = 0,
} pn_mips_addu;

typedef enum n_mips_addu {
    n_mips_addu_left = 0,
    n_mips_addu_right = 1,
} n_mips_addu;

typedef enum pn_mips_and {
    pn_mips_and_res = 0,
} pn_mips_and;

typedef enum n_mips_and {
    n_mips_and_left = 0,
    n_mips_and_right = 1,
} n_mips_and;

typedef enum pn_mips_andi {
    pn_mips_andi_res = 0,
} pn_mips_andi;

typedef enum n_mips_andi {
    n_mips_andi_left = 0,
} n_mips_andi;

typedef enum pn_mips_bcc {
    pn_mips_bcc_false = 0,
    pn_mips_bcc_true = 1,
} pn_mips_bcc;

typedef enum pn_mips_div_hi {
    pn_mips_div_hi_res = 0,
} pn_mips_div_hi;

typedef enum n_mips_div_hi {
    n_mips_div_hi_left = 0,
    n_mips_div_hi_right = 1,
} n_mips_div_hi;

typedef enum pn_mips_div_lo {
    pn_mips_div_lo_res = 0,
} pn_mips_div_lo;

typedef enum n_mips_div_lo {
    n_mips_div_lo_left = 0,
    n_mips_div_lo_right = 1,
} n_mips_div_lo;

typedef enum pn_mips_divu_hi {
    pn_mips_divu_hi_res = 0,
} pn_mips_divu_hi;

typedef enum n_mips_divu_hi {
    n_mips_divu_hi_left = 0,
    n_mips_divu_hi_right = 1,
} n_mips_divu_hi;

typedef enum pn_mips_divu_lo {
    pn_mips_divu_lo_res = 0,
} pn_mips_divu_lo;

typedef enum n_mips_divu_lo {
    n_mips_divu_lo_left = 0,
    n_mips_divu_lo_right = 1,
} n_mips_divu_lo;

typedef enum pn_mips_jal {
    pn_mips_jal_M = 0,
    pn_mips_jal_stack = 1,
    pn_mips_jal_first_result = 2,
} pn_mips_jal;

typedef enum n_mips_jal {
    n_mips_jal_mem = 0,
    n_mips_jal_stack = 1,
    n_mips_jal_first_argument = 2,
} n_mips_jal;

typedef enum pn_mips_jalr {
    pn_mips_jalr_M = 0,
    pn_mips_jalr_stack = 1,
    pn_mips_jalr_first_result = 2,
} pn_mips_jalr;

typedef enum n_mips_jalr {
    n_mips_jalr_mem = 0,
    n_mips_jalr_stack = 1,
    n_mips_jalr_first_argument = 2,
} n_mips_jalr;

typedef enum pn_mips_lb {
    pn_mips_lb_M = 0,
    pn_mips_lb_res = 1,
} pn_mips_lb;

typedef enum n_mips_lb {
    n_mips_lb_mem = 0,
    n_mips_lb_base = 1,
} n_mips_lb;

typedef enum pn_mips_lbu {
    pn_mips_lbu_M = 0,
    pn_mips_lbu_res = 1,
} pn_mips_lbu;

typedef enum n_mips_lbu {
    n_mips_lbu_mem = 0,
    n_mips_lbu_base = 1,
} n_mips_lbu;

typedef enum pn_mips_lh {
    pn_mips_lh_M = 0,
    pn_mips_lh_res = 1,
} pn_mips_lh;

typedef enum n_mips_lh {
    n_mips_lh_mem = 0,
    n_mips_lh_base = 1,
} n_mips_lh;

typedef enum pn_mips_lhu {
    pn_mips_lhu_M = 0,
    pn_mips_lhu_res = 1,
} pn_mips_lhu;

typedef enum n_mips_lhu {
    n_mips_lhu_mem = 0,
    n_mips_lhu_base = 1,
} n_mips_lhu;

typedef enum pn_mips_lui {
    pn_mips_lui_res = 0,
} pn_mips_lui;

typedef enum pn_mips_lw {
    pn_mips_lw_M = 0,
    pn_mips_lw_res = 1,
} pn_mips_lw;

typedef enum n_mips_lw {
    n_mips_lw_mem = 0,
    n_mips_lw_base = 1,
} n_mips_lw;

typedef enum pn_mips_mult_hi {
    pn_mips_mult_hi_res = 0,
} pn_mips_mult_hi;

typedef enum n_mips_mult_hi {
    n_mips_mult_hi_left = 0,
    n_mips_mult_hi_right = 1,
} n_mips_mult_hi;

typedef enum pn_mips_mult_lo {
    pn_mips_mult_lo_res = 0,
} pn_mips_mult_lo;

typedef enum n_mips_mult_lo {
    n_mips_mult_lo_left = 0,
    n_mips_mult_lo_right = 1,
} n_mips_mult_lo;

typedef enum pn_mips_multu_hi {
    pn_mips_multu_hi_res = 0,
} pn_mips_multu_hi;

typedef enum n_mips_multu_hi {
    n_mips_multu_hi_left = 0,
    n_mips_multu_hi_right = 1,
} n_mips_multu_hi;

typedef enum pn_mips_nor {
    pn_mips_nor_res = 0,
} pn_mips_nor;

typedef enum n_mips_nor {
    n_mips_nor_left = 0,
    n_mips_nor_right = 1,
} n_mips_nor;

typedef enum pn_mips_or {
    pn_mips_or_res = 0,
} pn_mips_or;

typedef enum n_mips_or {
    n_mips_or_left = 0,
    n_mips_or_right = 1,
} n_mips_or;

typedef enum pn_mips_ori {
    pn_mips_ori_res = 0,
} pn_mips_ori;

typedef enum n_mips_ori {
    n_mips_ori_left = 0,
} n_mips_ori;

typedef enum n_mips_ret {
    n_mips_ret_mem = 0,
    n_mips_ret_stack = 1,
    n_mips_ret_addr = 2,
    n_mips_ret_first_result = 3,
} n_mips_ret;

typedef enum pn_mips_sb {
    pn_mips_sb_M = 0,
} pn_mips_sb;

typedef enum n_mips_sb {
    n_mips_sb_mem = 0,
    n_mips_sb_base = 1,
    n_mips_sb_value = 2,
} n_mips_sb;

typedef enum pn_mips_sh {
    pn_mips_sh_M = 0,
} pn_mips_sh;

typedef enum n_mips_sh {
    n_mips_sh_mem = 0,
    n_mips_sh_base = 1,
    n_mips_sh_value = 2,
} n_mips_sh;

typedef enum pn_mips_sll {
    pn_mips_sll_res = 0,
} pn_mips_sll;

typedef enum n_mips_sll {
    n_mips_sll_left = 0,
} n_mips_sll;

typedef enum pn_mips_sllv {
    pn_mips_sllv_res = 0,
} pn_mips_sllv;

typedef enum n_mips_sllv {
    n_mips_sllv_left = 0,
    n_mips_sllv_right = 1,
} n_mips_sllv;

typedef enum pn_mips_slt {
    pn_mips_slt_res = 0,
} pn_mips_slt;

typedef enum n_mips_slt {
    n_mips_slt_left = 0,
    n_mips_slt_right = 1,
} n_mips_slt;

typedef enum pn_mips_sltiu {
    pn_mips_sltiu_res = 0,
} pn_mips_sltiu;

typedef enum n_mips_sltiu {
    n_mips_sltiu_left = 0,
} n_mips_sltiu;

typedef enum pn_mips_sltu {
    pn_mips_sltu_res = 0,
} pn_mips_sltu;

typedef enum n_mips_sltu {
    n_mips_sltu_left = 0,
    n_mips_sltu_right = 1,
} n_mips_sltu;

typedef enum pn_mips_sra {
    pn_mips_sra_res = 0,
} pn_mips_sra;

typedef enum n_mips_sra {
    n_mips_sra_left = 0,
} n_mips_sra;

typedef enum pn_mips_srav {
    pn_mips_srav_res = 0,
} pn_mips_srav;

typedef enum n_mips_srav {
    n_mips_srav_left = 0,
    n_mips_srav_right = 1,
} n_mips_srav;

typedef enum pn_mips_srl {
    pn_mips_srl_res = 0,
} pn_mips_srl;

typedef enum n_mips_srl {
    n_mips_srl_left = 0,
} n_mips_srl;

typedef enum pn_mips_srlv {
    pn_mips_srlv_res = 0,
} pn_mips_srlv;

typedef enum n_mips_srlv {
    n_mips_srlv_left = 0,
    n_mips_srlv_right = 1,
} n_mips_srlv;

typedef enum pn_mips_subu {
    pn_mips_subu_res = 0,
} pn_mips_subu;

typedef enum n_mips_subu {
    n_mips_subu_left = 0,
    n_mips_subu_right = 1,
} n_mips_subu;

typedef enum pn_mips_sw {
    pn_mips_sw_M = 0,
} pn_mips_sw;

typedef enum n_mips_sw {
    n_mips_sw_mem = 0,
    n_mips_sw_base = 1,
    n_mips_sw_value = 2,
} n_mips_sw;

typedef enum pn_mips_xor {
    pn_mips_xor_res = 0,
} pn_mips_xor;

typedef enum n_mips_xor {
    n_mips_xor_left = 0,
    n_mips_xor_right = 1,
} n_mips_xor;

typedef enum pn_mips_xori {
    pn_mips_xori_res = 0,
} pn_mips_xori;

typedef enum n_mips_xori {
    n_mips_xori_left = 0,
} n_mips_xori;


#endif