typerep.h

/*
 * This file is part of libFirm.
 * Copyright (C) 2012 University of Karlsruhe.
 */
 
#ifndef FIRM_TYPEREP_H
#define FIRM_TYPEREP_H
 
#include <stddef.h>
#include "firm_types.h"
 
#include "begin.h"
 
typedef enum {
    ir_visibility_external,
    ir_visibility_external_private,
    ir_visibility_external_protected,
    ir_visibility_local,
    ir_visibility_private,
} ir_visibility;
 
typedef enum ir_linkage {
    IR_LINKAGE_DEFAULT         = 0,
    IR_LINKAGE_CONSTANT        = 1 << 0,
    IR_LINKAGE_WEAK            = 1 << 1,
    IR_LINKAGE_GARBAGE_COLLECT = 1 << 2,
    IR_LINKAGE_MERGE           = 1 << 3,
    IR_LINKAGE_HIDDEN_USER     = 1 << 4,
    IR_LINKAGE_NO_CODEGEN      = 1 << 5,
    IR_LINKAGE_NO_IDENTITY     = 1 << 6,
} ir_linkage;
ENUM_BITSET(ir_linkage)
 
 
FIRM_API ir_visibility get_entity_visibility(const ir_entity *entity);
 
FIRM_API void set_entity_visibility(ir_entity *entity, ir_visibility visibility);
 
FIRM_API int entity_is_externally_visible(const ir_entity *entity);
 
FIRM_API int entity_has_definition(const ir_entity *entity);
 
FIRM_API ir_entity *new_entity(ir_type *owner, ident *name, ir_type *tp);
 
FIRM_API ir_entity *new_global_entity(ir_type *segment, ident *ld_name,
                                      ir_type *type, ir_visibility visibility,
                                      ir_linkage linkage);
 
FIRM_API ir_entity *new_parameter_entity(ir_type *owner, size_t pos,
                                         ir_type *type);
 
FIRM_API ir_entity *new_alias_entity(ir_type *owner, ident *name,
                                     ir_entity *alias, ir_type *type,
                                     ir_visibility visibility);
 
FIRM_API void set_entity_alias(ir_entity *alias, ir_entity *aliased);
 
FIRM_API ir_entity *get_entity_alias(const ir_entity *alias);
 
FIRM_API int check_entity(const ir_entity *ent);
 
FIRM_API ir_entity *clone_entity(ir_entity const *old, ident *name,
                                 ir_type *owner);
 
FIRM_API void free_entity(ir_entity *ent);
 
FIRM_API const char *get_entity_name(const ir_entity *ent);
 
FIRM_API ident *get_entity_ident(const ir_entity *ent);
 
FIRM_API void set_entity_ident(ir_entity *ent, ident *id);
 
FIRM_API ident *get_entity_ld_ident(const ir_entity *ent);
 
FIRM_API void set_entity_ld_ident(ir_entity *ent, ident *ld_ident);
 
FIRM_API const char *get_entity_ld_name(const ir_entity *ent);
 
FIRM_API int entity_has_ld_ident(const ir_entity *entity);
 
FIRM_API ir_type *get_entity_owner(const ir_entity *ent);
 
FIRM_API void set_entity_owner(ir_entity *ent, ir_type *owner);
 
FIRM_API ir_type *get_entity_type(const ir_entity *ent);
 
FIRM_API void set_entity_type(ir_entity *ent, ir_type *tp);
 
FIRM_API ir_linkage get_entity_linkage(const ir_entity *entity);
 
FIRM_API void set_entity_linkage(ir_entity *entity, ir_linkage linkage);
FIRM_API void add_entity_linkage(ir_entity *entity, ir_linkage linkage);
FIRM_API void remove_entity_linkage(ir_entity *entity, ir_linkage linkage);
 
FIRM_API ir_volatility get_entity_volatility(const ir_entity *ent);
 
FIRM_API void set_entity_volatility(ir_entity *ent, ir_volatility vol);
 
FIRM_API const char *get_volatility_name(ir_volatility var);
 
FIRM_API unsigned get_entity_alignment(const ir_entity *entity);
 
FIRM_API void set_entity_alignment(ir_entity *entity, unsigned alignment);
 
FIRM_API ir_align get_entity_aligned(const ir_entity *ent);
 
FIRM_API void set_entity_aligned(ir_entity *ent, ir_align a);
 
FIRM_API const char *get_align_name(ir_align a);
 
FIRM_API int get_entity_offset(const ir_entity *entity);
 
FIRM_API void set_entity_offset(ir_entity *entity, int offset);
 
FIRM_API unsigned get_entity_bitfield_offset(const ir_entity *entity);
 
FIRM_API void set_entity_bitfield_offset(ir_entity *entity, unsigned offset);
 
FIRM_API void set_entity_bitfield_size(ir_entity *entity, unsigned size);
 
FIRM_API unsigned get_entity_bitfield_size(const ir_entity *entity);
 
FIRM_API void *get_entity_link(const ir_entity *ent);
 
FIRM_API void set_entity_link(ir_entity *ent, void *l);
 
FIRM_API ir_graph *get_entity_irg(const ir_entity *ent);
 
FIRM_API ir_graph *get_entity_linktime_irg(const ir_entity *ent);
 
#define IR_VTABLE_NUM_NOT_SET ((unsigned)(-1))
 
FIRM_API unsigned get_entity_vtable_number(const ir_entity *ent);
 
FIRM_API void set_entity_vtable_number(ir_entity *ent, unsigned vtable_number);
 
FIRM_API void set_entity_label(ir_entity *ent, ir_label_t label);
FIRM_API ir_label_t get_entity_label(const ir_entity *ent);
 
typedef enum {
    ir_usage_none             = 0,      
    ir_usage_address_taken    = 1 << 0, 
    ir_usage_write            = 1 << 1, 
    ir_usage_read             = 1 << 2, 
    ir_usage_reinterpret_cast = 1 << 3, 
    ir_usage_unknown
        = ir_usage_address_taken | ir_usage_write | ir_usage_read
        | ir_usage_reinterpret_cast
} ir_entity_usage;
 
FIRM_API ir_entity_usage get_entity_usage(const ir_entity *ent);
 
FIRM_API void set_entity_usage(ir_entity *ent, ir_entity_usage flag);
 
FIRM_API dbg_info *get_entity_dbg_info(const ir_entity *ent);
 
FIRM_API void set_entity_dbg_info(ir_entity *ent, dbg_info *db);
 
#define IR_VA_START_PARAMETER_NUMBER  ((size_t)-1)
 
FIRM_API int is_parameter_entity(const ir_entity *entity);
 
FIRM_API size_t get_entity_parameter_number(const ir_entity *entity);
 
FIRM_API void set_entity_parameter_number(ir_entity *entity, size_t n);
 
typedef enum ir_initializer_kind_t {
    IR_INITIALIZER_CONST,
    IR_INITIALIZER_TARVAL,
    IR_INITIALIZER_NULL,
    IR_INITIALIZER_COMPOUND
} ir_initializer_kind_t;
 
FIRM_API ir_initializer_kind_t get_initializer_kind(const ir_initializer_t *initializer);
 
FIRM_API const char *get_initializer_kind_name(ir_initializer_kind_t ini);
 
FIRM_API ir_initializer_t *get_initializer_null(void);
 
FIRM_API ir_initializer_t *create_initializer_const(ir_node *value);
 
FIRM_API ir_initializer_t *create_initializer_tarval(ir_tarval *tv);
 
FIRM_API ir_node *get_initializer_const_value(const ir_initializer_t *initializer);
 
FIRM_API ir_tarval *get_initializer_tarval_value(const ir_initializer_t *initialzier);
 
FIRM_API ir_initializer_t *create_initializer_compound(size_t n_entries);
 
FIRM_API size_t get_initializer_compound_n_entries(const ir_initializer_t *initializer);
 
FIRM_API void set_initializer_compound_value(ir_initializer_t *initializer,
                                             size_t index,
                                             ir_initializer_t *value);
 
FIRM_API ir_initializer_t *get_initializer_compound_value(
        const ir_initializer_t *initializer, size_t index);
 
FIRM_API void set_entity_initializer(ir_entity *entity, ir_initializer_t *initializer);
 
FIRM_API ir_initializer_t *get_entity_initializer(const ir_entity *entity);
 
FIRM_API void add_entity_overwrites(ir_entity *ent, ir_entity *overwritten);
FIRM_API size_t get_entity_n_overwrites(const ir_entity *ent);
FIRM_API size_t get_entity_overwrites_index(const ir_entity *ent,
                                            ir_entity *overwritten);
FIRM_API ir_entity *get_entity_overwrites(const ir_entity *ent, size_t pos);
FIRM_API void set_entity_overwrites(ir_entity *ent, size_t pos,
                                    ir_entity *overwritten);
FIRM_API void remove_entity_overwrites(ir_entity *ent, ir_entity *overwritten);
 
FIRM_API size_t get_entity_n_overwrittenby(const ir_entity *ent);
FIRM_API size_t get_entity_overwrittenby_index(const ir_entity *ent,
                                               ir_entity *overwrites);
FIRM_API ir_entity *get_entity_overwrittenby(const ir_entity *ent, size_t pos);
FIRM_API void set_entity_overwrittenby(ir_entity *ent, size_t pos,
                                       ir_entity *overwrites);
FIRM_API void remove_entity_overwrittenby(ir_entity *ent,
                                          ir_entity *overwrites);
 
FIRM_API int is_compound_entity(const ir_entity *ent);
FIRM_API int is_method_entity(const ir_entity *ent);
FIRM_API int is_alias_entity(const ir_entity *ent);
 
FIRM_API long get_entity_nr(const ir_entity *ent);
 
FIRM_API ir_visited_t get_entity_visited(const ir_entity *ent);
 
FIRM_API void set_entity_visited(ir_entity *ent, ir_visited_t num);
 
FIRM_API void mark_entity_visited(ir_entity *ent);
 
FIRM_API int entity_visited(const ir_entity *ent);
 
FIRM_API int entity_not_visited(const ir_entity *ent);
 
FIRM_API int entity_has_additional_properties(const ir_entity *entity);
 
FIRM_API mtp_additional_properties get_entity_additional_properties(const ir_entity *ent);
 
FIRM_API void set_entity_additional_properties(ir_entity *ent,
                                               mtp_additional_properties prop);
 
FIRM_API void add_entity_additional_properties(ir_entity *ent,
                                               mtp_additional_properties flag);
 
FIRM_API ir_entity *get_unknown_entity(void);
 
FIRM_API int is_unknown_entity(const ir_entity *entity);
 
typedef enum ptr_access_kind {
    ptr_access_none  = 0,                                 
    ptr_access_read  = 1,                                 
    ptr_access_write = 2,                                 
    ptr_access_rw    = ptr_access_read|ptr_access_write,  
    ptr_access_store = 4,                                 
    ptr_access_all   = ptr_access_rw|ptr_access_store     
} ptr_access_kind;
ENUM_BITSET(ptr_access_kind)
 
 
typedef enum tp_opcode {
    tpo_uninitialized = 0,   /* not a type opcode */
    tpo_struct,              
    tpo_union,               
    tpo_class,               
    tpo_segment,             
    tpo_method,              
    tpo_array,               
    tpo_pointer,             
    tpo_primitive,           
    tpo_code,                
    tpo_unknown,             
    tpo_last = tpo_unknown   /* not a type opcode */
} tp_opcode;
 
FIRM_API const char *get_type_opcode_name(tp_opcode opcode);
 
FIRM_API int is_SubClass_of(const ir_type *low, const ir_type *high);
 
FIRM_API int is_SubClass_ptr_of(ir_type *low, ir_type *high);
 
#define is_SuperClass_of(high, low) is_SubClass_of(low, high)
 
#define is_SuperClass_ptr_of(low, high) is_SubClass_ptr_of(high, low)
 
FIRM_API int is_overwritten_by(ir_entity *high, ir_entity *low);
 
FIRM_API ir_entity *resolve_ent_polymorphy(ir_type *dynamic_class,
                                           ir_entity* static_ent);
 
/* ----------------------------------------------------------------------- */
/* The transitive closure of the subclass/superclass and                   */
/* overwrites/overwrittenby relation.                                      */
/*                                                                         */
/* A walk over the ir (O(#types+#entities)) computes the transitive        */
/* closure.  Adding a new type/entity or changing the basic relations in   */
/* some other way invalidates the transitive closure, i.e., it is not      */
/* updated by the basic functions.                                         */
/*                                                                         */
/* The transitive edges are held in a set, not in an array as the          */
/* underlying relation.                                                    */
/*                                                                         */
/* Do the sets contain the node itself?  I assume NOT!                     */
/* ----------------------------------------------------------------------- */
 
typedef enum {
    inh_transitive_closure_none,       
    inh_transitive_closure_valid,      
    inh_transitive_closure_invalid,    
    inh_transitive_closure_max         
} inh_transitive_closure_state;
 
FIRM_API void set_irp_inh_transitive_closure_state(inh_transitive_closure_state s);
FIRM_API void invalidate_irp_inh_transitive_closure_state(void);
FIRM_API inh_transitive_closure_state get_irp_inh_transitive_closure_state(void);
 
FIRM_API void compute_inh_transitive_closure(void);
 
FIRM_API void free_inh_transitive_closure(void);
 
FIRM_API ir_type *get_class_trans_subtype_first(const ir_type *tp);
FIRM_API ir_type *get_class_trans_subtype_next(const ir_type *tp);
FIRM_API int is_class_trans_subtype(const ir_type *tp, const ir_type *subtp);
 
FIRM_API ir_type *get_class_trans_supertype_first(const ir_type *tp);
FIRM_API ir_type *get_class_trans_supertype_next(const ir_type *tp);
 
FIRM_API ir_entity *get_entity_trans_overwrittenby_first(const ir_entity *ent);
FIRM_API ir_entity *get_entity_trans_overwrittenby_next(const ir_entity *ent);
 
FIRM_API ir_entity *get_entity_trans_overwrites_first(const ir_entity *ent);
FIRM_API ir_entity *get_entity_trans_overwrites_next(const ir_entity *ent);
 
 
FIRM_API int check_type(const ir_type *tp);
 
FIRM_API int tr_verify(void);
 
FIRM_API void free_type(ir_type *tp);
 
FIRM_API tp_opcode get_type_opcode(const ir_type *type);
 
FIRM_API void ir_print_type(char *buffer, size_t buffer_size,
                            const ir_type *tp);
 
typedef enum {
    layout_undefined,    
    layout_fixed         
} ir_type_state;
 
FIRM_API const char *get_type_state_name(ir_type_state s);
 
FIRM_API ir_type_state get_type_state(const ir_type *tp);
 
FIRM_API void set_type_state(ir_type *tp, ir_type_state state);
 
FIRM_API ir_mode *get_type_mode(const ir_type *tp);
 
FIRM_API unsigned get_type_size(const ir_type *tp);
 
FIRM_API void set_type_size(ir_type *tp, unsigned size);
 
FIRM_API unsigned get_type_alignment(const ir_type *tp);
 
FIRM_API void set_type_alignment(ir_type *tp, unsigned align);
 
FIRM_API ir_visited_t get_type_visited(const ir_type *tp);
FIRM_API void set_type_visited(ir_type *tp, ir_visited_t num);
FIRM_API void mark_type_visited(ir_type *tp);
FIRM_API int type_visited(const ir_type *tp);
 
FIRM_API void *get_type_link(const ir_type *tp);
FIRM_API void set_type_link(ir_type *tp, void *l);
 
FIRM_API void         inc_master_type_visited(void);
FIRM_API void         set_master_type_visited(ir_visited_t val);
FIRM_API ir_visited_t get_master_type_visited(void);
 
FIRM_API void set_type_dbg_info(ir_type *tp, type_dbg_info *db);
 
FIRM_API type_dbg_info *get_type_dbg_info(const ir_type *tp);
 
FIRM_API long get_type_nr(const ir_type *tp);
 
FIRM_API ir_type *new_type_class(ident *name);
 
FIRM_API size_t get_class_n_members(const ir_type *clss);
 
FIRM_API ir_entity *get_class_member(const ir_type *clss, size_t pos);
 
#define INVALID_MEMBER_INDEX ((size_t)-1)
 
FIRM_API size_t get_class_member_index(ir_type const *clss,
                                       ir_entity const *mem);
 
FIRM_API void add_class_subtype(ir_type *clss, ir_type *subtype);
 
FIRM_API size_t get_class_n_subtypes(const ir_type *clss);
 
FIRM_API ir_type *get_class_subtype(const ir_type *clss, size_t pos);
 
FIRM_API size_t get_class_subtype_index(const ir_type *clss,
                                        const ir_type *subclass);
 
FIRM_API void set_class_subtype(ir_type *clss, ir_type *subtype, size_t pos);
 
FIRM_API void remove_class_subtype(ir_type *clss, ir_type *subtype);
 
FIRM_API void add_class_supertype(ir_type *clss, ir_type *supertype);
 
FIRM_API size_t get_class_n_supertypes(const ir_type *clss);
 
FIRM_API size_t get_class_supertype_index(const ir_type *clss,
                                          const ir_type *super_clss);
 
FIRM_API ir_type *get_class_supertype(const ir_type *clss, size_t pos);
 
FIRM_API void set_class_supertype(ir_type *clss, ir_type *supertype, size_t pos);
 
FIRM_API void remove_class_supertype(ir_type *clss, ir_type *supertype);
 
FIRM_API int is_Class_type(const ir_type *clss);
 
FIRM_API ir_type *new_type_struct(ident *name);
 
FIRM_API size_t get_struct_n_members(const ir_type *strct);
 
FIRM_API ir_entity *get_struct_member(const ir_type *strct, size_t pos);
 
FIRM_API size_t get_struct_member_index(ir_type const *strct,
                                        ir_entity const *member);
 
FIRM_API int is_Struct_type(const ir_type *strct);
 
FIRM_API ir_type *new_type_union(ident *name);
 
FIRM_API size_t get_union_n_members(const ir_type *uni);
 
FIRM_API ir_entity *get_union_member(const ir_type *uni, size_t pos);
 
FIRM_API size_t get_union_member_index(ir_type const *uni,
                                       ir_entity const *member);
 
FIRM_API int is_Union_type(const ir_type *uni);
 
FIRM_API ir_type *new_type_method(size_t n_param, size_t n_res, int is_variadic, unsigned cc_mask, mtp_additional_properties property_mask);
 
FIRM_API size_t get_method_n_params(const ir_type *method);
 
FIRM_API ir_type *get_method_param_type(const ir_type *method, size_t pos);
FIRM_API void set_method_param_type(ir_type *method, size_t pos, ir_type *tp);
FIRM_API size_t get_method_n_ress(const ir_type *method);
FIRM_API ir_type *get_method_res_type(const ir_type *method, size_t pos);
FIRM_API void set_method_res_type(ir_type *method, size_t pos, ir_type *tp);
 
FIRM_API int is_method_variadic(ir_type const *method);
 
FIRM_API mtp_additional_properties get_method_additional_properties(const ir_type *method);
 
typedef enum {
    cc_reg_param           = 0x01000000, 
    cc_last_on_top         = 0x02000000, 
    cc_callee_clear_stk    = 0x04000000, 
    cc_this_call           = 0x08000000, 
    cc_compound_ret        = 0x10000000, 
    cc_frame_on_caller_stk = 0x20000000, 
    cc_fpreg_param         = 0x40000000, 
} calling_convention;
 
#define cc_bits (0xFF000000)
 
#define cc_cdecl_set    (0)
#define cc_stdcall_set  cc_callee_clear_stk
#define cc_fastcall_set (cc_reg_param|cc_callee_clear_stk)
 
#define IS_CDECL(cc_mask)     (((cc_mask) & cc_bits) == cc_cdecl_set)
 
#define IS_STDCALL(cc_mask)   (((cc_mask) & cc_bits) == cc_stdcall_set)
 
#define IS_FASTCALL(cc_mask)  (((cc_mask) & cc_bits) == cc_fastcall_set)
 
#define SET_CDECL(cc_mask)    (((cc_mask) & ~cc_bits) | cc_cdecl_set)
 
#define SET_STDCALL(cc_mask)  (((cc_mask) & ~cc_bits) | cc_stdcall_set)
 
#define SET_FASTCALL(cc_mask) (((cc_mask) & ~cc_bits) | cc_fastcall_set)
 
FIRM_API unsigned get_method_calling_convention(const ir_type *method);
 
FIRM_API unsigned get_method_n_regparams(ir_type *method);
 
FIRM_API int is_Method_type(const ir_type *method);
 
FIRM_API ir_type *new_type_array(ir_type *element_type, unsigned n_elements);
 
FIRM_API unsigned get_array_size(const ir_type *array);
 
FIRM_API ir_type *get_array_element_type(const ir_type *array);
 
FIRM_API int is_Array_type(const ir_type *array);
 
FIRM_API ir_type *new_type_pointer(ir_type *points_to);
 
FIRM_API void set_pointer_points_to_type(ir_type *pointer, ir_type *tp);
 
FIRM_API ir_type *get_pointer_points_to_type(const ir_type *pointer);
 
FIRM_API int is_Pointer_type(const ir_type *pointer);
 
FIRM_API ir_type *new_type_primitive(ir_mode *mode);
 
FIRM_API int is_Primitive_type(const ir_type *primitive);
 
FIRM_API ir_type *get_code_type(void);
FIRM_API int is_code_type(const ir_type *tp);
FIRM_API ir_type *get_unknown_type(void);
FIRM_API int is_unknown_type(const ir_type *type);
FIRM_API int is_atomic_type(const ir_type *tp);
 
FIRM_API ident *get_compound_ident(const ir_type *tp);
 
FIRM_API const char *get_compound_name(const ir_type *tp);
 
FIRM_API size_t get_compound_n_members(const ir_type *tp);
 
FIRM_API ir_entity *get_compound_member(const ir_type *tp, size_t pos);
 
FIRM_API size_t get_compound_member_index(ir_type const *tp,
                                          ir_entity const *member);
 
FIRM_API void remove_compound_member(ir_type *compound, ir_entity *entity);
 
FIRM_API void default_layout_compound_type(ir_type *tp);
 
FIRM_API int is_compound_type(const ir_type *tp);
 
FIRM_API ir_type *new_type_frame(void);
 
FIRM_API int is_frame_type(const ir_type *tp);
 
FIRM_API ir_type *clone_frame_type(ir_type *type);
 
FIRM_API int is_segment_type(const ir_type *tp);
 
typedef int (compare_types_func_t)(const void *tp1, const void *tp2);
 
typedef void type_walk_func(ir_type *type, ir_entity *entity, void *env);
 
typedef void class_walk_func(ir_type *clss, void *env);
 
FIRM_API void type_walk(type_walk_func *pre, type_walk_func *post, void *env);
 
FIRM_API void type_walk_irg(ir_graph *irg, type_walk_func *pre,
                            type_walk_func *post, void *env);
 
FIRM_API void type_walk_super2sub(type_walk_func *pre, type_walk_func *post,
                                  void *env);
 
FIRM_API void type_walk_super(type_walk_func *pre, type_walk_func *post,
                              void *env);
 
FIRM_API void class_walk_super2sub(class_walk_func *pre, class_walk_func *post,
                                   void *env);
 
typedef void entity_walk_func(ir_entity *ent, void *env);
 
FIRM_API void walk_types_entities(ir_type *tp, entity_walk_func *doit,
                                  void *env);
 
#include "end.h"
 
#endif