libfirm/irnode.h

Go to the documentation of this file.

/*
 * Copyright (C) 1995-2008 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_IRNODE_H
#define FIRM_IR_IRNODE_H

#include <stddef.h>

#include "firm_common.h"
#include "typerep.h"
#include "irop.h"
#include "irmode.h"
#include "begin.h"
#include "nodeops.h"

FIRM_API int is_ir_node(const void *thing);

FIRM_API int get_irn_arity(const ir_node *node);

FIRM_API ir_node *get_irn_n(const ir_node *node, int n);

FIRM_API void set_irn_in(ir_node *node, int arity, ir_node *in[]);

FIRM_API int add_irn_dep(ir_node *node, ir_node *dep);

FIRM_API void add_irn_deps(ir_node *tgt, ir_node *src);

FIRM_API int get_irn_deps(const ir_node *node);

FIRM_API ir_node *get_irn_dep(const ir_node *node, int pos);

FIRM_API void set_irn_dep(ir_node *node, int pos, ir_node *dep);

FIRM_API void set_irn_n(ir_node *node, int n, ir_node *in);
FIRM_API int add_irn_n(ir_node *node, ir_node *in);
FIRM_API void set_irn_mode(ir_node *node, ir_mode *mode);
FIRM_API ir_mode *get_irn_mode(const ir_node *node);
FIRM_API ir_op *get_irn_op(const ir_node *node);
FIRM_API void set_irn_op(ir_node *node, ir_op *op);
FIRM_API unsigned get_irn_opcode(const ir_node *node);
FIRM_API const char *get_irn_opname(const ir_node *node);
FIRM_API ident *get_irn_opident(const ir_node *node);
FIRM_API int get_irn_pred_pos(ir_node *node, ir_node *arg);
FIRM_API ir_visited_t get_irn_visited(const ir_node *node);
FIRM_API void set_irn_visited(ir_node *node, ir_visited_t visited);
FIRM_API void mark_irn_visited(ir_node *node);
FIRM_API int irn_visited(const ir_node *node);
FIRM_API int irn_visited_else_mark(ir_node *node);

FIRM_API void set_irn_link(ir_node *node, void *link);

FIRM_API void *get_irn_link(const ir_node *node);

FIRM_API ir_graph *get_irn_irg(const ir_node *node);

FIRM_API long get_irn_node_nr(const ir_node *node);

FIRM_API op_pin_state get_irn_pinned(const ir_node *node);

FIRM_API void set_irn_pinned(ir_node *node, op_pin_state state);

FIRM_API op_pin_state is_irn_pinned_in_irg(const ir_node *node);

FIRM_API ir_node *new_ir_node(dbg_info *db, ir_graph *irg, ir_node *block,
                              ir_op *op, ir_mode *mode,
                              int arity, ir_node *const *in);

FIRM_API ir_node *get_nodes_block(const ir_node *node);

FIRM_API void set_nodes_block(ir_node *node, ir_node *block);

FIRM_API int get_Block_n_cfgpreds(const ir_node *block);
FIRM_API ir_node *get_Block_cfgpred(const ir_node *block, int pos);
FIRM_API void set_Block_cfgpred(ir_node *block, int pos, ir_node *pred);

FIRM_API int get_Block_cfgpred_pos(const ir_node *block, const ir_node *pred);

FIRM_API ir_node *get_Block_cfgpred_block(const ir_node *node, int pos);

FIRM_API int get_Block_matured(const ir_node *block);
FIRM_API void set_Block_matured(ir_node *block, int matured);

FIRM_API ir_visited_t get_Block_block_visited(const ir_node *block);
FIRM_API void set_Block_block_visited(ir_node *block, ir_visited_t visit);

FIRM_API void mark_Block_block_visited(ir_node *node);
FIRM_API int Block_block_visited(const ir_node *node);

FIRM_API ir_extblk *get_Block_extbb(const ir_node *block);
FIRM_API void set_Block_extbb(ir_node *block, ir_extblk *extblk);
FIRM_API ir_graph *get_Block_irg(const ir_node *block);
FIRM_API ir_entity *create_Block_entity(ir_node *block);
FIRM_API ir_node *get_Block_phis(const ir_node *block);
FIRM_API void set_Block_phis(ir_node *block, ir_node *phi);
FIRM_API void add_Block_phi(ir_node *block, ir_node *phi);
FIRM_API unsigned get_Block_mark(const ir_node *block);
FIRM_API void set_Block_mark(ir_node *block, unsigned mark);

FIRM_API ir_type *is_frame_pointer(const ir_node *n);

FIRM_API int get_End_n_keepalives(const ir_node *end);
FIRM_API ir_node *get_End_keepalive(const ir_node *end, int pos);
FIRM_API void add_End_keepalive(ir_node *end, ir_node *ka);
FIRM_API void set_End_keepalive(ir_node *end, int pos, ir_node *ka);

FIRM_API void set_End_keepalives(ir_node *end, int n, ir_node *in[]);

FIRM_API void remove_End_keepalive(ir_node *end, ir_node *irn);

FIRM_API void remove_End_Bads_and_doublets(ir_node *end);

FIRM_API void free_End(ir_node *end);

FIRM_API ir_node **get_Return_res_arr(ir_node *node);
FIRM_API size_t get_Return_n_ress(const ir_node *node);
FIRM_API ir_node *get_Return_res(const ir_node *node, int pos);
FIRM_API void set_Return_res(ir_node *node, int pos, ir_node *res);

FIRM_API int is_Const_null(const ir_node *node);

FIRM_API int is_Const_one(const ir_node *node);

FIRM_API int is_Const_all_one(const ir_node *node);

FIRM_API int is_strictConv(const ir_node *node);

FIRM_API int is_SymConst_addr_ent(const ir_node *node);

#define SYMCONST_HAS_TYPE(kind) ((kind) <= symconst_type_align)

#define SYMCONST_HAS_ENT(kind) ((kind) == symconst_addr_ent || (kind) == symconst_ofs_ent)

#define SYMCONST_HAS_ENUM(kind) ((kind) == symconst_enum_const)

FIRM_API symconst_kind get_SymConst_kind(const ir_node *node);
FIRM_API void set_SymConst_kind(ir_node *node, symconst_kind num);

FIRM_API ir_type *get_SymConst_type(const ir_node *node);
FIRM_API void set_SymConst_type(ir_node *node, ir_type *tp);

FIRM_API ir_entity *get_SymConst_entity(const ir_node *node);
FIRM_API void set_SymConst_entity(ir_node *node, ir_entity *ent);

FIRM_API ir_enum_const *get_SymConst_enum(const ir_node *node);
FIRM_API void set_SymConst_enum(ir_node *node, ir_enum_const *ec);

FIRM_API union symconst_symbol get_SymConst_symbol(const ir_node *node);
FIRM_API void set_SymConst_symbol(ir_node *node, union symconst_symbol sym);

FIRM_API ir_node **get_Sel_index_arr(ir_node *node);
FIRM_API int get_Sel_n_indexs(const ir_node *node);
FIRM_API ir_node *get_Sel_index(const ir_node *node, int pos);
FIRM_API void set_Sel_index(ir_node *node, int pos, ir_node *index);

FIRM_API ir_node **get_Call_param_arr(ir_node *node);
FIRM_API size_t get_Call_n_params(const ir_node *node);
FIRM_API ir_node *get_Call_param(const ir_node *node, int pos);
FIRM_API void set_Call_param(ir_node *node, int pos, ir_node *param);

FIRM_API int Call_has_callees(const ir_node *node);
FIRM_API size_t get_Call_n_callees(const ir_node *node);
FIRM_API ir_entity *get_Call_callee(const ir_node *node, size_t pos);

FIRM_API void set_Call_callee_arr(ir_node *node, size_t n, ir_entity **arr);
FIRM_API void remove_Call_callee_arr(ir_node *node);

FIRM_API ir_node **get_Builtin_param_arr(ir_node *node);
FIRM_API int get_Builtin_n_params(const ir_node *node);
FIRM_API ir_node *get_Builtin_param(const ir_node *node, int pos);
FIRM_API void set_Builtin_param(ir_node *node, int pos, ir_node *param);

FIRM_API const char *get_builtin_kind_name(ir_builtin_kind kind);

FIRM_API int is_unop(const ir_node *node);
FIRM_API ir_node *get_unop_op(const ir_node *node);
FIRM_API void set_unop_op(ir_node *node, ir_node *op);

FIRM_API int is_binop(const ir_node *node);
FIRM_API ir_node *get_binop_left(const ir_node *node);
FIRM_API void set_binop_left(ir_node *node, ir_node *left);
FIRM_API ir_node *get_binop_right(const ir_node *node);
FIRM_API void set_binop_right(ir_node *node, ir_node *right);

FIRM_API int is_x_except_Proj(const ir_node *node);

FIRM_API int is_x_regular_Proj(const ir_node *node);

FIRM_API void ir_set_throws_exception(ir_node *node, int throws_exception);

FIRM_API int ir_throws_exception(const ir_node *node);

FIRM_API const char *get_relation_string(ir_relation relation);

FIRM_API ir_relation get_negated_relation(ir_relation relation);

FIRM_API ir_relation get_inversed_relation(ir_relation relation);

FIRM_API int is_Cast_upcast(ir_node *node);

FIRM_API int is_Cast_downcast(ir_node *node);

FIRM_API int is_Phi0(const ir_node *n);
FIRM_API ir_node **get_Phi_preds_arr(ir_node *node);
FIRM_API int get_Phi_n_preds(const ir_node *node);
FIRM_API ir_node *get_Phi_pred(const ir_node *node, int pos);
FIRM_API void set_Phi_pred(ir_node *node, int pos, ir_node *pred);
FIRM_API ir_node *get_Phi_next(const ir_node *phi);
FIRM_API void set_Phi_next(ir_node *phi, ir_node *next);

FIRM_API int is_memop(const ir_node *node);
FIRM_API ir_node *get_memop_mem(const ir_node *node);
FIRM_API void set_memop_mem(ir_node *node, ir_node *mem);

FIRM_API ir_node **get_Sync_preds_arr(ir_node *node);
FIRM_API int get_Sync_n_preds(const ir_node *node);
FIRM_API ir_node *get_Sync_pred(const ir_node *node, int pos);
FIRM_API void set_Sync_pred(ir_node *node, int pos, ir_node *pred);
FIRM_API void add_Sync_pred(ir_node *node, ir_node *pred);
FIRM_API void del_Sync_n(ir_node *n, int i);

FIRM_API int is_arg_Proj(const ir_node *node);

FIRM_API ir_node **get_Tuple_preds_arr(ir_node *node);
FIRM_API int get_Tuple_n_preds(const ir_node *node);
FIRM_API ir_node  *get_Tuple_pred(const ir_node *node, int pos);
FIRM_API void set_Tuple_pred(ir_node *node, int pos, ir_node *pred);

FIRM_API size_t get_ASM_n_input_constraints(const ir_node *node);
FIRM_API size_t get_ASM_n_output_constraints(const ir_node *node);
FIRM_API size_t get_ASM_n_clobbers(const ir_node *node);

FIRM_API ir_node *skip_Proj(ir_node *node);
FIRM_API const ir_node *skip_Proj_const(const ir_node *node);
FIRM_API ir_node *skip_Id(ir_node *node);
FIRM_API ir_node *skip_Tuple(ir_node *node);
FIRM_API ir_node *skip_Cast(ir_node *node);
FIRM_API const ir_node *skip_Cast_const(const ir_node *node);
FIRM_API ir_node *skip_Pin(ir_node *node);
FIRM_API ir_node *skip_Confirm(ir_node *node);
FIRM_API ir_node *skip_HighLevel_ops(ir_node *node);
FIRM_API int is_cfop(const ir_node *node);
FIRM_API int is_unknown_jump(const ir_node *node);

FIRM_API int is_fragile_op(const ir_node *node);

FIRM_API int is_irn_forking(const ir_node *node);

FIRM_API void copy_node_attr(ir_graph *irg, const ir_node *old_node, ir_node *new_node);

FIRM_API ir_type *get_irn_type_attr(ir_node *n);

FIRM_API ir_entity *get_irn_entity_attr(ir_node *n);

FIRM_API int is_irn_constlike(const ir_node *node);

FIRM_API int is_irn_keep(const ir_node *node);

FIRM_API int is_irn_start_block_placed(const ir_node *node);

FIRM_API int is_irn_cse_neutral(const ir_node *node);

FIRM_API const char *get_cond_jmp_predicate_name(cond_jmp_predicate pred);

#define get_irn_data(node,type,off) \
  (assert(off > 0 && "Invalid node data offset"), (type *) ((char *) (node) - (off)))

#define get_irn_data_base(data,off) \
  (assert(off > 0 && "Invalid node data offset"), (ir_node *) ((char *) (data) + (off)))

FIRM_API unsigned firm_register_additional_node_data(unsigned size);

FIRM_API void *get_irn_generic_attr(ir_node *node);
FIRM_API const void *get_irn_generic_attr_const(const ir_node *node);

FIRM_API unsigned get_irn_idx(const ir_node *node);

FIRM_API void set_irn_dbg_info(ir_node *n, dbg_info *db);

FIRM_API dbg_info *get_irn_dbg_info(const ir_node *n);

FIRM_API unsigned firm_default_hash(const ir_node *node);

FIRM_API const char *gdb_node_helper(void *firm_object);

FIRM_API ir_switch_table *ir_new_switch_table(ir_graph *irg, size_t n_entries);

FIRM_API size_t ir_switch_table_get_n_entries(const ir_switch_table *table);

FIRM_API void ir_switch_table_set(ir_switch_table *table, size_t entry,
                                  ir_tarval *min, ir_tarval *max, long pn);

FIRM_API ir_tarval *ir_switch_table_get_max(const ir_switch_table *table,
                                            size_t entry);

FIRM_API ir_tarval *ir_switch_table_get_min(const ir_switch_table *table,
                                            size_t entry);

FIRM_API long ir_switch_table_get_pn(const ir_switch_table *table, size_t entry);

FIRM_API ir_switch_table *ir_switch_table_duplicate(ir_graph *irg, const ir_switch_table *table);
#include "end.h"

#endif