libfirm/irgraph.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_IRGRAPH_H
#define FIRM_IR_IRGRAPH_H

#include <stddef.h>

#include "firm_types.h"
#include "begin.h"

FIRM_API ir_graph *new_ir_graph(ir_entity *ent, int n_loc);

FIRM_API void free_ir_graph(ir_graph *irg);

FIRM_API int is_ir_graph(const void *thing);

FIRM_API ir_entity *get_irg_entity(const ir_graph *irg);
FIRM_API void set_irg_entity(ir_graph *irg, ir_entity *ent);

FIRM_API ir_type *get_irg_frame_type(ir_graph *irg);
FIRM_API void set_irg_frame_type(ir_graph *irg, ir_type *ftp);

FIRM_API ir_node *get_irg_start_block(const ir_graph *irg);
FIRM_API void set_irg_start_block(ir_graph *irg, ir_node *node);

FIRM_API ir_node *get_irg_start(const ir_graph *irg);
FIRM_API void set_irg_start(ir_graph *irg, ir_node *node);

FIRM_API ir_node *get_irg_end_block(const ir_graph *irg);
FIRM_API void set_irg_end_block(ir_graph *irg, ir_node *node);

FIRM_API ir_node *get_irg_end(const ir_graph *irg);
FIRM_API void set_irg_end(ir_graph *irg, ir_node *node);

FIRM_API ir_node *get_irg_initial_exec(const ir_graph *irg);
FIRM_API void set_irg_initial_exec(ir_graph *irg, ir_node *node);

FIRM_API ir_node *get_irg_frame(const ir_graph *irg);
FIRM_API void set_irg_frame(ir_graph *irg, ir_node *node);

FIRM_API ir_node *get_irg_initial_mem(const ir_graph *irg);
FIRM_API void set_irg_initial_mem(ir_graph *irg, ir_node *node);

FIRM_API ir_node *get_irg_args(const ir_graph *irg);
FIRM_API void set_irg_args(ir_graph *irg, ir_node *node);

FIRM_API ir_node *get_irg_no_mem(const ir_graph *irg);
FIRM_API void set_irg_no_mem(ir_graph *irg, ir_node *node);

FIRM_API int get_irg_n_locs(ir_graph *irg);

FIRM_API long get_irg_graph_nr(const ir_graph *irg);

FIRM_API size_t get_irg_idx(const ir_graph *irg);

FIRM_API ir_node *get_idx_irn(const ir_graph *irg, unsigned idx);


typedef enum {
    phase_building,  
    phase_high,      
    phase_low,       
    phase_backend    
} irg_phase_state;

FIRM_API irg_phase_state get_irg_phase_state(const ir_graph *irg);

FIRM_API void set_irg_phase_state(ir_graph *irg, irg_phase_state state);

FIRM_API op_pin_state get_irg_pinned(const ir_graph *irg);

typedef enum {
    irg_callee_info_none,
    irg_callee_info_consistent,
    irg_callee_info_inconsistent
} irg_callee_info_state;

FIRM_API irg_callee_info_state get_irg_callee_info_state(const ir_graph *irg);

FIRM_API void set_irg_callee_info_state(ir_graph *irg, irg_callee_info_state s);

typedef enum {
    irg_inline_any,            
    irg_inline_forbidden,      
    irg_inline_recomended,     
    irg_inline_forced,         
    irg_inline_forced_no_body  
} irg_inline_property;

FIRM_API irg_inline_property get_irg_inline_property(const ir_graph *irg);
FIRM_API void set_irg_inline_property(ir_graph *irg, irg_inline_property s);

FIRM_API mtp_additional_properties get_irg_additional_properties(const ir_graph *irg);

FIRM_API void set_irg_additional_properties(ir_graph *irg,
                                            mtp_additional_properties property_mask);

FIRM_API void add_irg_additional_properties(ir_graph *irg,
                                            mtp_additional_properties flag);

FIRM_API void set_irg_link(ir_graph *irg, void *thing);
FIRM_API void *get_irg_link(const ir_graph *irg);

FIRM_API void inc_irg_visited(ir_graph *irg);
FIRM_API ir_visited_t get_irg_visited(const ir_graph *irg);
FIRM_API void set_irg_visited(ir_graph *irg, ir_visited_t i);
FIRM_API ir_visited_t get_max_irg_visited(void);
FIRM_API void set_max_irg_visited(int val);
FIRM_API ir_visited_t inc_max_irg_visited(void);

FIRM_API void inc_irg_block_visited(ir_graph *irg);
FIRM_API ir_visited_t get_irg_block_visited(const ir_graph *irg);
FIRM_API void set_irg_block_visited(ir_graph *irg, ir_visited_t i);

typedef enum ir_resources_t {
    IR_RESOURCE_NONE          = 0,       
    IR_RESOURCE_BLOCK_VISITED = 1 << 0,  
    IR_RESOURCE_BLOCK_MARK    = 1 << 1,  
    IR_RESOURCE_IRN_VISITED   = 1 << 2,  
    IR_RESOURCE_IRN_LINK      = 1 << 3,  
    IR_RESOURCE_LOOP_LINK     = 1 << 4,  
    IR_RESOURCE_PHI_LIST      = 1 << 5   
} ir_resources_t;
ENUM_BITSET(ir_resources_t)

#ifndef NDEBUG

FIRM_API void ir_reserve_resources(ir_graph *irg, ir_resources_t resources);
FIRM_API void ir_free_resources(ir_graph *irg, ir_resources_t resources);
FIRM_API ir_resources_t ir_resources_reserved(const ir_graph *irg);
#else
#define ir_reserve_resources(irg,resources)  (void)0
#define ir_free_resources(irg,resources)     (void)0
#define ir_resources_reserved(irg)           0
#endif

typedef enum {
    IR_GRAPH_STATE_ARCH_DEP                  = 1U << 0,
    IR_GRAPH_STATE_MODEB_LOWERED             = 1U << 1,
    IR_GRAPH_STATE_NORMALISATION2            = 1U << 2,
    IR_GRAPH_STATE_IMPLICIT_BITFIELD_MASKING = 1U << 3,
    IR_GRAPH_STATE_OPTIMIZE_UNREACHABLE_CODE = 1U << 4,
    IR_GRAPH_STATE_NO_CRITICAL_EDGES         = 1U << 5,
    IR_GRAPH_STATE_NO_BADS                   = 1U << 6,
    IR_GRAPH_STATE_NO_UNREACHABLE_CODE       = 1U << 7,
    IR_GRAPH_STATE_ONE_RETURN                = 1U << 8,
    IR_GRAPH_STATE_CONSISTENT_DOMINANCE      = 1U << 9,
    IR_GRAPH_STATE_CONSISTENT_POSTDOMINANCE  = 1U << 10,
    IR_GRAPH_STATE_CONSISTENT_OUT_EDGES      = 1U << 11,
    IR_GRAPH_STATE_CONSISTENT_OUTS           = 1U << 12,
    IR_GRAPH_STATE_CONSISTENT_LOOPINFO       = 1U << 13,
    IR_GRAPH_STATE_CONSISTENT_ENTITY_USAGE   = 1U << 14,
    IR_GRAPH_STATE_VALID_EXTENDED_BLOCKS     = 1U << 15,
    IR_GRAPH_STATE_MANY_RETURNS              = 1U << 16,
} ir_graph_state_t;
ENUM_BITSET(ir_graph_state_t)


FIRM_API void set_irg_state(ir_graph *irg, ir_graph_state_t state);
FIRM_API void clear_irg_state(ir_graph *irg, ir_graph_state_t state);
FIRM_API int is_irg_state(const ir_graph *irg, ir_graph_state_t state);

FIRM_API void set_irg_loc_description(ir_graph *irg, int n, void *description);

FIRM_API void *get_irg_loc_description(ir_graph *irg, int n);

FIRM_API unsigned get_irg_estimated_node_cnt(const ir_graph *irg);

FIRM_API unsigned get_irg_last_idx(const ir_graph *irg);

FIRM_API unsigned get_irg_fp_model(const ir_graph *irg);

FIRM_API void set_irg_fp_model(ir_graph *irg, unsigned model);

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

#define get_irg_data_base(data,off) \
    (assert(off > 0 && "Invalid graph data offset"), (ir_graph *) ((char *) (data) + (off)))

FIRM_API size_t register_additional_graph_data(size_t size);

#include "end.h"

#endif