irop.h

Go to the documentation of this file.

/*
 * Copyright (C) 1995-2011 University of Karlsruhe.  All right reserved.
 *
 * This file is part of libFirm.
 *
 * This file may be distributed and/or modified under the terms of the
 * GNU General Public License version 2 as published by the Free Software
 * Foundation and appearing in the file LICENSE.GPL included in the
 * packaging of this file.
 *
 * Licensees holding valid libFirm Professional Edition licenses may use
 * this file in accordance with the libFirm Commercial License.
 * Agreement provided with the Software.
 *
 * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE.
 */

#ifndef FIRM_IR_IROP_H
#define FIRM_IR_IROP_H

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

typedef enum {
    oparity_invalid = 0,
    oparity_unary,              
    oparity_binary,             
    oparity_trinary,            
    oparity_zero,               
    oparity_variable,           
    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_highlevel    = 1U <<  4, 
    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_cse_neutral  = 1U << 10, 
    irop_flag_unknown_jump = 1U << 11,
} irop_flags;
ENUM_BITSET(irop_flags)


FIRM_API ident *get_op_ident(const ir_op *op);

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 void set_op_pinned(ir_op *op, op_pin_state pinned);

FIRM_API unsigned get_next_ir_opcode(void);

FIRM_API unsigned get_next_ir_opcodes(unsigned num);

typedef void (*op_func)(void);

#define NULL_FUNC       ((generic_func)(NULL))

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_cmp_attr_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);

typedef struct {
    hash_func             hash;                 
    computed_value_func   computed_value;       
    computed_value_func   computed_value_Proj;  
    equivalent_node_func  equivalent_node;      
    equivalent_node_func  equivalent_node_Proj; 
    transform_node_func   transform_node;       
    transform_node_func   transform_node_Proj;  
    node_cmp_attr_func    node_cmp_attr;        
    reassociate_func      reassociate;          
    copy_attr_func        copy_attr;            
    get_type_attr_func    get_type_attr;        
    get_entity_attr_func  get_entity_attr;      
    verify_node_func      verify_node;          
    verify_proj_node_func verify_proj_node;     
    dump_node_func        dump_node;            
    op_func               generic;              
    op_func               generic1;             
    op_func               generic2;             
    const arch_irn_ops_t *be_ops;               
} ir_op_ops;

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 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, int pn_x_regular,
                                        int pn_x_except);

FIRM_API ir_op_ops *get_op_ops(ir_op *op);

#include "end.h"

#endif