irop.h

/*
 * This file is part of libFirm.
 * Copyright (C) 2012 University of Karlsruhe.
 */

#ifndef FIRM_IR_IROP_H
#define FIRM_IR_IROP_H

#include <stdio.h>
#include "firm_types.h"
#include "begin.h"

typedef enum {
    oparity_invalid = 0,
    oparity_binary,             
    oparity_dynamic,            
    oparity_any
} op_arity;


typedef enum {
    irop_flag_none         = 0, 
    irop_flag_commutative  = 1U <<  0, 
    irop_flag_cfopcode     = 1U <<  1, 
    irop_flag_fragile      = 1U <<  2, 
    irop_flag_forking      = 1U <<  3, 
    irop_flag_constlike    = 1U <<  5, 
    irop_flag_keep         = 1U <<  6, 
    irop_flag_start_block  = 1U <<  7, 
    irop_flag_uses_memory  = 1U <<  8, 
    irop_flag_dump_noblock = 1U <<  9, 
    irop_flag_unknown_jump = 1U << 11,
    irop_flag_const_memory = 1U << 12,
} irop_flags;
ENUM_BITSET(irop_flags)


FIRM_API const char *get_op_name(const ir_op *op);

FIRM_API unsigned get_op_code(const ir_op *op);

FIRM_API const char *get_op_pin_state_name(op_pin_state s);

FIRM_API op_pin_state get_op_pinned(const ir_op *op);

FIRM_API unsigned get_next_ir_opcode(void);

FIRM_API unsigned get_next_ir_opcodes(unsigned num);

typedef void (*op_func)(void);

FIRM_API op_func get_generic_function_ptr(const ir_op *op);

FIRM_API void set_generic_function_ptr(ir_op *op, op_func func);

FIRM_API irop_flags get_op_flags(const ir_op *op);

typedef unsigned (*hash_func)(const ir_node *self);

typedef ir_tarval *(*computed_value_func)(const ir_node *self);

typedef ir_node *(*equivalent_node_func)(ir_node *self);

typedef ir_node *(*transform_node_func)(ir_node *self);

typedef int (*node_attrs_equal_func)(const ir_node *a, const ir_node *b);

typedef int (*reassociate_func)(ir_node **n);

typedef void (*copy_attr_func)(ir_graph *irg, const ir_node *old_node, ir_node *new_node);

typedef ir_type *(*get_type_attr_func)(const ir_node *self);

typedef ir_entity *(*get_entity_attr_func)(const ir_node *self);

typedef int (*verify_node_func)(const ir_node *node);

typedef int (*verify_proj_node_func)(const ir_node *proj);

typedef enum {
    dump_node_opcode_txt,   
    dump_node_mode_txt,     
    dump_node_nodeattr_txt, 
    dump_node_info_txt      
} dump_reason_t;

typedef void (*dump_node_func)(FILE *out, const ir_node *self, dump_reason_t reason);

FIRM_API void set_op_hash(ir_op *op, hash_func func);
FIRM_API void set_op_computed_value(ir_op *op, computed_value_func func);
FIRM_API void set_op_computed_value_proj(ir_op *op, computed_value_func func);
FIRM_API void set_op_equivalent_node(ir_op *op, equivalent_node_func func);
FIRM_API void set_op_equivalent_node_proj(ir_op *op, equivalent_node_func func);
FIRM_API void set_op_transform_node(ir_op *op, transform_node_func func);
FIRM_API void set_op_transform_node_proj(ir_op *op, transform_node_func func);
FIRM_API void set_op_attrs_equal(ir_op *op, node_attrs_equal_func func);
FIRM_API void set_op_reassociate(ir_op *op, reassociate_func func);
FIRM_API void set_op_copy_attr(ir_op *op, copy_attr_func func);
FIRM_API void set_op_get_type_attr(ir_op *op, get_type_attr_func func);
FIRM_API void set_op_get_entity_attr(ir_op *op, get_entity_attr_func func);
FIRM_API void set_op_verify(ir_op *op, verify_node_func func);
FIRM_API void set_op_verify_proj(ir_op *op, verify_proj_node_func func);
FIRM_API void set_op_dump(ir_op *op, dump_node_func func);

FIRM_API ir_op *new_ir_op(unsigned code, const char *name, op_pin_state p,
                          irop_flags flags, op_arity opar, int op_index,
                          size_t attr_size);

FIRM_API void free_ir_op(ir_op *code);

FIRM_API unsigned ir_get_n_opcodes(void);

FIRM_API ir_op *ir_get_opcode(unsigned code);

FIRM_API void ir_clear_opcodes_generic_func(void);

FIRM_API void ir_op_set_memory_index(ir_op *op, int memory_index);

FIRM_API void ir_op_set_fragile_indices(ir_op *op, unsigned pn_x_regular,
                                        unsigned pn_x_except);

#include "end.h"

#endif