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

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

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_constraints_t {
    IR_GRAPH_CONSTRAINT_ARCH_DEP                  = 1U << 0,
    IR_GRAPH_CONSTRAINT_MODEB_LOWERED             = 1U << 1,
    IR_GRAPH_CONSTRAINT_NORMALISATION2            = 1U << 2,
    IR_GRAPH_CONSTRAINT_OPTIMIZE_UNREACHABLE_CODE = 1U << 3,
    IR_GRAPH_CONSTRAINT_CONSTRUCTION              = 1U << 4,
    IR_GRAPH_CONSTRAINT_TARGET_LOWERED            = 1U << 5,
    IR_GRAPH_CONSTRAINT_BACKEND                   = 1U << 6,
} ir_graph_constraints_t;
ENUM_BITSET(ir_graph_constraints_t)


FIRM_API void add_irg_constraints(ir_graph *irg,
                                  ir_graph_constraints_t constraints);
FIRM_API void clear_irg_constraints(ir_graph *irg,
                                    ir_graph_constraints_t constraints);
FIRM_API int irg_is_constrained(const ir_graph *irg,
                                ir_graph_constraints_t constraints);

typedef enum ir_graph_properties_t {
    IR_GRAPH_PROPERTIES_NONE                         = 0,
    IR_GRAPH_PROPERTY_NO_CRITICAL_EDGES              = 1U << 0,
    IR_GRAPH_PROPERTY_NO_BADS                        = 1U << 1,
    IR_GRAPH_PROPERTY_NO_TUPLES                      = 1U << 2,
    IR_GRAPH_PROPERTY_NO_UNREACHABLE_CODE            = 1U << 3,
    IR_GRAPH_PROPERTY_ONE_RETURN                     = 1U << 4,
    IR_GRAPH_PROPERTY_CONSISTENT_DOMINANCE           = 1U << 5,
    IR_GRAPH_PROPERTY_CONSISTENT_POSTDOMINANCE       = 1U << 6,
    IR_GRAPH_PROPERTY_CONSISTENT_DOMINANCE_FRONTIERS = 1U << 7,
    IR_GRAPH_PROPERTY_CONSISTENT_OUT_EDGES           = 1U << 8,
    IR_GRAPH_PROPERTY_CONSISTENT_OUTS                = 1U << 9,
    IR_GRAPH_PROPERTY_CONSISTENT_LOOPINFO            = 1U << 10,
    IR_GRAPH_PROPERTY_CONSISTENT_ENTITY_USAGE        = 1U << 11,
    IR_GRAPH_PROPERTY_MANY_RETURNS                   = 1U << 12,

    IR_GRAPH_PROPERTIES_CONTROL_FLOW =
          IR_GRAPH_PROPERTY_NO_CRITICAL_EDGES
        | IR_GRAPH_PROPERTY_ONE_RETURN
        | IR_GRAPH_PROPERTY_NO_UNREACHABLE_CODE
        | IR_GRAPH_PROPERTY_CONSISTENT_LOOPINFO
        | IR_GRAPH_PROPERTY_CONSISTENT_DOMINANCE
        | IR_GRAPH_PROPERTY_CONSISTENT_POSTDOMINANCE
        | IR_GRAPH_PROPERTY_CONSISTENT_DOMINANCE_FRONTIERS,

    IR_GRAPH_PROPERTIES_ALL =
          IR_GRAPH_PROPERTIES_CONTROL_FLOW
        | IR_GRAPH_PROPERTY_NO_BADS
        | IR_GRAPH_PROPERTY_NO_TUPLES
        | IR_GRAPH_PROPERTY_CONSISTENT_OUT_EDGES
        | IR_GRAPH_PROPERTY_CONSISTENT_OUTS
        | IR_GRAPH_PROPERTY_CONSISTENT_ENTITY_USAGE
        | IR_GRAPH_PROPERTY_MANY_RETURNS,

} ir_graph_properties_t;
ENUM_BITSET(ir_graph_properties_t)


FIRM_API void add_irg_properties(ir_graph *irg, ir_graph_properties_t props);
FIRM_API void clear_irg_properties(ir_graph *irg, ir_graph_properties_t props);
FIRM_API int irg_has_properties(const ir_graph *irg,
                                ir_graph_properties_t props);

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

FIRM_API void assure_irg_properties(ir_graph *irg, ir_graph_properties_t props);

FIRM_API void confirm_irg_properties(ir_graph *irg, ir_graph_properties_t props);

#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