libfirm/typerep.h

Go to the documentation of this file.

/*
 * Copyright (C) 1995-2011 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_TYPEREP_H
#define FIRM_TYPEREP_H

#include <stdlib.h>
#include "firm_types.h"

#include "begin.h"

typedef enum {
    ir_visibility_default,
    ir_visibility_local,
    ir_visibility_external,
    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;
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_d_entity(ir_type *owner, ident *name, ir_type *tp,
                                 dbg_info *db);

FIRM_API ir_entity *new_parameter_entity(ir_type *owner, size_t pos,
                                         ir_type *type);

FIRM_API ir_entity *new_d_parameter_entity(ir_type *owner, size_t pos,
                                           ir_type *type, dbg_info *dbgi);

FIRM_API int check_entity(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 *ent);

FIRM_API void set_entity_offset(ir_entity *ent, int offset);

FIRM_API unsigned char get_entity_offset_bits_remainder(const ir_entity *ent);

FIRM_API void set_entity_offset_bits_remainder(ir_entity *ent,
                                               unsigned char offset);

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

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

FIRM_API int is_entity_compiler_generated(const ir_entity *ent);

FIRM_API void set_entity_compiler_generated(ir_entity *ent, int flag);

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 int is_irn_const_expression(ir_node *n);

FIRM_API ir_node *copy_const_value(dbg_info *dbg, ir_node *n, ir_node *to_block);

FIRM_API ir_node *get_atomic_ent_value(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 int has_entity_initializer(const ir_entity *entity);

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_entity(const void *thing);

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 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 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_type *get_entity_repr_class(const ir_entity *ent);

FIRM_API ir_entity *get_unknown_entity(void);

FIRM_API int is_unknown_entity(const ir_entity *entity);

typedef enum {
    allocation_automatic,
    allocation_parameter,
    allocation_dynamic,
    allocation_static
} ir_allocation;
FIRM_API ir_allocation get_entity_allocation(const ir_entity *ent);
FIRM_API void set_entity_allocation(ir_entity *ent, ir_allocation al);

typedef enum {
    peculiarity_existent,
    peculiarity_description,
    peculiarity_inherited
} ir_peculiarity;
FIRM_API ir_peculiarity get_entity_peculiarity(const ir_entity *ent);
FIRM_API void set_entity_peculiarity(ir_entity *ent, ir_peculiarity pec);

FIRM_API int is_entity_final(const ir_entity *ent);
FIRM_API void set_entity_final(ir_entity *ent, int final);

FIRM_API ir_peculiarity get_class_peculiarity(const ir_type *clss);
FIRM_API void set_class_peculiarity(ir_type *clss, ir_peculiarity pec);

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 {
    tpo_uninitialized = 0,   /* not a type opcode */
    tpo_class,               
    tpo_struct,              
    tpo_method,              
    tpo_union,               
    tpo_array,               
    tpo_enumeration,         
    tpo_pointer,             
    tpo_primitive,           
    tpo_code,                
    tpo_none,                
    tpo_unknown,             
    tpo_last = tpo_unknown   /* not a type opcode */
} tp_opcode;

typedef struct tp_op tp_op;


FIRM_API const char *get_tpop_name(const tp_op *op);

FIRM_API tp_opcode get_tpop_code(const tp_op *op);

FIRM_API int is_SubClass_of(ir_type *low, 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);

FIRM_API ident *default_mangle_inherited_name(const ir_entity *ent,
                                              const ir_type *clss);

typedef ident *mangle_inherited_name_func(const ir_entity *ent,
                                          const ir_type *clss);

FIRM_API void resolve_inheritance(mangle_inherited_name_func *mfunc);


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


typedef enum {
    ir_class_casts_any        = 0, 
    ir_class_casts_transitive = 1, 
    ir_class_casts_normalized = 2, 
    ir_class_casts_state_max
} ir_class_cast_state;

FIRM_API void set_irg_class_cast_state(ir_graph *irg,
                                       ir_class_cast_state state);
FIRM_API ir_class_cast_state get_irg_class_cast_state(const ir_graph *irg);
FIRM_API void set_irp_class_cast_state(ir_class_cast_state state);
FIRM_API ir_class_cast_state get_irp_class_cast_state(void);

enum trverify_error_codes {
    no_error = 0,                      
    error_ent_not_cont,                
    error_null_mem,                    
    error_const_on_wrong_irg,          
    error_existent_entity_without_irg, 
    error_wrong_ent_overwrites,        
    error_inherited_ent_without_const, 
    error_glob_ent_allocation,         
    error_ent_const_mode,              
    error_ent_wrong_owner              
};

FIRM_API int check_type(ir_type *tp);

FIRM_API int tr_verify(void);

FIRM_API void free_type(ir_type *tp);

FIRM_API const tp_op *get_type_tpop(const ir_type *tp);
FIRM_API ident *get_type_tpop_nameid(const ir_type *tp);
FIRM_API const char *get_type_tpop_name(const ir_type *tp);
FIRM_API tp_opcode get_type_tpop_code(const ir_type *tp);

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 void set_type_mode(ir_type *tp, ir_mode* m);

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(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 int type_not_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 int is_type(const void *thing);

FIRM_API long get_type_nr(const ir_type *tp);

FIRM_API int equal_type(ir_type *typ1, ir_type *typ2);

FIRM_API int smaller_type(ir_type *st, ir_type *lt);

FIRM_API ir_type *new_type_class(ident *name);

FIRM_API ir_type *new_d_type_class(ident *name, type_dbg_info *db);

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(const ir_type *clss, ir_entity *mem);

FIRM_API ir_entity *get_class_member_by_name(ir_type *clss, ident *name);

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(ir_type *clss, size_t pos);

FIRM_API size_t get_class_subtype_index(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(ir_type *clss, ir_type *super_clss);

FIRM_API ir_type *get_class_supertype(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 ir_entity *get_class_type_info(const ir_type *clss);

FIRM_API void set_class_type_info(ir_type *clss, ir_entity *ent);

FIRM_API unsigned get_class_vtable_size(const ir_type *clss);

FIRM_API void set_class_vtable_size(ir_type *clss, unsigned size);

FIRM_API int is_class_final(const ir_type *clss);

FIRM_API void set_class_final(ir_type *clss, int flag);

FIRM_API int is_class_interface(const ir_type *clss);

FIRM_API void set_class_interface(ir_type *clss, int flag);

FIRM_API int is_class_abstract(const ir_type *clss);

FIRM_API void set_class_abstract(ir_type *clss, int flag);

FIRM_API int is_Class_type(const ir_type *clss);

FIRM_API const tp_op *type_class;
FIRM_API const tp_op *get_tpop_class(void);

FIRM_API ir_type *new_type_struct(ident *name);
FIRM_API ir_type *new_d_type_struct(ident *name, type_dbg_info* db);

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(const ir_type *strct, ir_entity *member);

FIRM_API int is_Struct_type(const ir_type *strct);

FIRM_API const tp_op *type_struct;
FIRM_API const tp_op *get_tpop_struct(void);

FIRM_API ir_type *new_type_union(ident *name);

FIRM_API ir_type *new_d_type_union(ident *name, type_dbg_info* db);


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(const ir_type *uni, ir_entity *member);

FIRM_API int is_Union_type(const ir_type *uni);

FIRM_API const tp_op *type_union;
FIRM_API const tp_op *get_tpop_union(void);

FIRM_API ir_type *new_type_method(size_t n_param, size_t n_res);

FIRM_API ir_type *new_d_type_method(size_t n_param, size_t n_res,
                                    type_dbg_info *db);

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

typedef enum ir_variadicity {
    variadicity_non_variadic, 
    variadicity_variadic      
} ir_variadicity;

FIRM_API const char *get_variadicity_name(ir_variadicity vari);

FIRM_API ir_variadicity get_method_variadicity(const ir_type *method);

FIRM_API void set_method_variadicity(ir_type *method, ir_variadicity vari);

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 const tp_op *type_method;
FIRM_API const tp_op *get_tpop_method(void);

FIRM_API ir_type *new_type_array(size_t n_dims, ir_type *element_type);

FIRM_API ir_type *new_d_type_array(size_t n_dims, ir_type *element_type,
                                   type_dbg_info* db);


FIRM_API size_t get_array_n_dimensions(const ir_type *array);

FIRM_API void set_array_bounds_int(ir_type *array, size_t dimension,
                                   int lower_bound, int upper_bound);
FIRM_API void set_array_bounds(ir_type *array, size_t dimension,
                               ir_node *lower_bound, ir_node *upper_bound);
FIRM_API void set_array_lower_bound(ir_type *array, size_t dimension,
                                    ir_node *lower_bound);

FIRM_API void set_array_lower_bound_int(ir_type *array, size_t dimension,
                                        int lower_bound);

FIRM_API void set_array_upper_bound(ir_type *array, size_t dimension,
                                    ir_node *upper_bound);

FIRM_API void set_array_upper_bound_int(ir_type *array, size_t dimension,
                                        int upper_bound);

FIRM_API int has_array_lower_bound(const ir_type *array, size_t dimension);
FIRM_API ir_node *get_array_lower_bound(const ir_type *array, size_t dimension);
FIRM_API long get_array_lower_bound_int(const ir_type *array, size_t dimension);
FIRM_API int has_array_upper_bound(const ir_type *array, size_t dimension);
FIRM_API ir_node *get_array_upper_bound(const ir_type *array, size_t dimension);
FIRM_API long get_array_upper_bound_int(const ir_type *array, size_t dimension);

FIRM_API void set_array_order(ir_type *array, size_t dimension, size_t order);

FIRM_API size_t get_array_order(const ir_type *array, size_t dimension);

FIRM_API size_t find_array_dimension(const ir_type *array, size_t order);

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_element_entity(ir_type *array, ir_entity *ent);

FIRM_API ir_entity *get_array_element_entity(const ir_type *array);

FIRM_API int is_Array_type(const ir_type *array);

FIRM_API const tp_op *type_array;
FIRM_API const tp_op *get_tpop_array(void);

FIRM_API ir_type *new_type_enumeration(ident *name, size_t n_enums);

FIRM_API ir_type *new_d_type_enumeration(ident *name, size_t n_enums,
                                         type_dbg_info *db);


FIRM_API ident *get_enumeration_ident(const ir_type *enumeration);

FIRM_API const char *get_enumeration_name(const ir_type *enumeration);

FIRM_API void set_enumeration_const(ir_type *enumeration, size_t pos,
                                    ident *nameid, ir_tarval *con);

FIRM_API size_t get_enumeration_n_enums(const ir_type *enumeration);

FIRM_API ir_enum_const *get_enumeration_const(const ir_type *enumeration,
                                              size_t pos);

FIRM_API ir_type *get_enumeration_owner(const ir_enum_const *enum_cnst);

FIRM_API void set_enumeration_value(ir_enum_const *enum_cnst, ir_tarval *con);

FIRM_API ir_tarval *get_enumeration_value(const ir_enum_const *enum_cnst);

FIRM_API void set_enumeration_nameid(ir_enum_const *enum_cnst, ident *id);

FIRM_API ident *get_enumeration_const_nameid(const ir_enum_const *enum_cnst);

FIRM_API const char *get_enumeration_const_name(const ir_enum_const *enum_cnst);

FIRM_API int is_Enumeration_type(const ir_type *enumeration);

FIRM_API const tp_op *type_enumeration;
FIRM_API const tp_op *get_tpop_enumeration(void);

FIRM_API ir_type *new_type_pointer(ir_type *points_to);

FIRM_API ir_type *new_d_type_pointer(ir_type *points_to, type_dbg_info* db);


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 const tp_op *type_pointer;
FIRM_API const tp_op *get_tpop_pointer(void);

FIRM_API ir_type *new_type_primitive(ir_mode *mode);

FIRM_API ir_type *new_d_type_primitive(ir_mode *mode, type_dbg_info* db);

FIRM_API int is_Primitive_type(const ir_type *primitive);

FIRM_API ir_type *get_primitive_base_type(const ir_type *tp);

FIRM_API void set_primitive_base_type(ir_type *tp, ir_type *base_tp);

FIRM_API const tp_op *type_primitive;
FIRM_API const tp_op *get_tpop_primitive(void);

FIRM_API ir_type *get_none_type(void);
FIRM_API int is_none_type(const ir_type *type);
FIRM_API const tp_op *tpop_none;
FIRM_API const tp_op *get_tpop_none(void);
FIRM_API ir_type *get_code_type(void);
FIRM_API int is_code_type(const ir_type *tp);
FIRM_API const tp_op *tpop_code;
FIRM_API const tp_op *get_tpop_code_type(void);
FIRM_API ir_type *get_unknown_type(void);
FIRM_API int is_unknown_type(const ir_type *type);
FIRM_API const tp_op *tpop_unknown;
FIRM_API const tp_op *get_tpop_unknown(void);
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(const ir_type *tp, ir_entity *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 ir_entity *frame_alloc_area(ir_type *frame_type, int size,
                                     unsigned alignment, int at_start);

typedef int (compare_types_func_t)(const void *tp1, const void *tp2);

typedef union {
    ir_type   *typ;   
    ir_entity *ent;   
} type_or_ent;

typedef void type_walk_func(type_or_ent tore, 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 void types_calc_finalization(void);

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