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 *copy_entity_own(ir_entity *old, ir_type *new_owner);

FIRM_API ir_entity *copy_entity_name(ir_entity *old, ident *new_name);

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

FIRM_API ir_node *get_atomic_ent_value(const ir_entity *ent);
FIRM_API void set_atomic_ent_value(ir_entity *ent, ir_node *val);

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_atomic_entity(const ir_entity *ent);
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_bytes(const ir_type *tp);

FIRM_API void set_type_size_bytes(ir_type *tp, unsigned size);

FIRM_API unsigned get_type_alignment_bytes(const ir_type *tp);

FIRM_API void set_type_alignment_bytes(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 ident *get_class_ident(const ir_type *clss);

FIRM_API const char *get_class_name(const ir_type *clss);

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 ident *get_struct_ident(const ir_type *strct);

FIRM_API const char *get_struct_name(const ir_type *strct);

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 ident *get_union_ident(const ir_type *uni);

FIRM_API const char *get_union_name(const ir_type *uni);

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

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 void set_method_variadic(ir_type *method, int is_variadic);

FIRM_API mtp_additional_properties get_method_additional_properties(const ir_type *method);

FIRM_API void set_method_additional_properties(ir_type *method,
                                               mtp_additional_properties property_mask);

FIRM_API void add_method_additional_properties(ir_type *method,
                                               mtp_additional_properties flag);

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, 
    cc_bits                = (0xFF << 24)
} calling_convention;

#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 void set_method_calling_convention(ir_type *method, unsigned cc_mask);

FIRM_API unsigned get_method_n_regparams(ir_type *method);

FIRM_API void set_method_n_regparams(ir_type *method, unsigned n_regs);

FIRM_API int is_Method_type(const ir_type *method);

FIRM_API ir_type *new_type_array(ir_type *element_type);

FIRM_API void set_array_size(ir_type *array, ir_node *size);

FIRM_API void set_array_size_int(ir_type *array, unsigned size);

FIRM_API int has_array_size(const ir_type *array);
FIRM_API ir_node *get_array_size(const ir_type *array);
FIRM_API unsigned get_array_size_int(const ir_type *array);

FIRM_API void set_array_element_type(ir_type *array, ir_type *tp);

FIRM_API ir_type *get_array_element_type(const ir_type *array);

FIRM_API void set_array_variable_size(ir_type *array, int variable_size_flag);

FIRM_API int is_array_variable_size(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 *find_pointer_type_to_type(ir_type *tp);

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 set_compound_variable_size(ir_type *compound, int variable_size);

FIRM_API int is_compound_variable_size(const ir_type *compound);

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 ir_entity *frame_alloc_area(ir_type *frame_type, int size,
                                     unsigned alignment, int at_start);

FIRM_API int is_segment_type(const ir_type *tp);

FIRM_API ident *get_segment_ident(ir_type const *type);

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

FIRM_API ir_visibility get_type_visibility(const ir_type *tp);
FIRM_API void set_type_visibility(ir_type *tp, ir_visibility v);

#include "end.h"

#endif