firm_types.h

/*
 * This file is part of libFirm.
 * Copyright (C) 2012 University of Karlsruhe.
 */

#ifndef FIRM_COMMON_FIRM_TYPES_H
#define FIRM_COMMON_FIRM_TYPES_H

#include "begin.h"

typedef unsigned long ir_visited_t;
typedef unsigned long ir_label_t;

typedef struct dbg_info             dbg_info;
typedef struct type_dbg_info        type_dbg_info;
typedef const char                  ident;
typedef struct ir_node              ir_node;
typedef struct ir_op                ir_op;
typedef struct ir_mode              ir_mode;
typedef struct ir_edge_t            ir_edge_t;
typedef struct ir_heights_t         ir_heights_t;
typedef struct ir_tarval            ir_tarval;
typedef struct ir_type              ir_type;
typedef struct ir_graph             ir_graph;
typedef struct ir_prog              ir_prog;
typedef struct ir_loop              ir_loop;
typedef struct ir_entity            ir_entity;
typedef struct ir_cdep              ir_cdep;
typedef union  ir_initializer_t     ir_initializer_t;

typedef void irg_walk_func(ir_node *, void *);

typedef struct ir_switch_table  ir_switch_table;

typedef ir_node *uninitialized_local_variable_func_t(ir_graph *irg, ir_mode *mode, int pos);

#ifdef __cplusplus
# define ENUM_BITSET(type) \
    extern "C++" { \
        static inline type operator ~  (type  a)         { return     (type)~(int)a;           } \
        static inline type operator &  (type  a, type b) { return     (type)((int)a & (int)b); } \
        static inline type operator &= (type& a, type b) { return a = (type)((int)a & (int)b); } \
        static inline type operator ^  (type  a, type b) { return     (type)((int)a ^ (int)b); } \
        static inline type operator ^= (type& a, type b) { return a = (type)((int)a ^ (int)b); } \
        static inline type operator |  (type  a, type b) { return     (type)((int)a | (int)b); } \
        static inline type operator |= (type& a, type b) { return a = (type)((int)a | (int)b); } \
    }
#else

# define ENUM_BITSET(type)
#endif

#ifdef __cplusplus
# define ENUM_COUNTABLE(type) \
    extern "C++" { \
        static inline type operator ++(type& a) { return a = (type)((int)a + 1); } \
        static inline type operator --(type& a) { return a = (type)((int)a - 1); } \
    }
#else

# define ENUM_COUNTABLE(type)
#endif

typedef enum ir_relation {
    ir_relation_false              = 0,       
    ir_relation_equal              = 1u << 0, 
    ir_relation_less               = 1u << 1, 
    ir_relation_greater            = 1u << 2, 
    ir_relation_unordered          = 1u << 3, 
    ir_relation_less_equal         = ir_relation_equal|ir_relation_less,    
    ir_relation_greater_equal      = ir_relation_equal|ir_relation_greater, 
    ir_relation_less_greater       = ir_relation_less|ir_relation_greater,  
    ir_relation_less_equal_greater = ir_relation_equal|ir_relation_less|ir_relation_greater, 
    ir_relation_unordered_equal    = ir_relation_unordered|ir_relation_equal, 
    ir_relation_unordered_less     = ir_relation_unordered|ir_relation_less,  
    ir_relation_unordered_less_equal = ir_relation_unordered|ir_relation_less|ir_relation_equal, 
    ir_relation_unordered_greater    = ir_relation_unordered|ir_relation_greater, 
    ir_relation_unordered_greater_equal = ir_relation_unordered|ir_relation_greater|ir_relation_equal, 
    ir_relation_unordered_less_greater  = ir_relation_unordered|ir_relation_less|ir_relation_greater, 
    ir_relation_true                    = ir_relation_equal|ir_relation_less|ir_relation_greater|ir_relation_unordered, 
} ir_relation;
ENUM_BITSET(ir_relation)


typedef enum ir_cons_flags {
    cons_none             = 0,        
    cons_volatile         = 1U << 0,  
    cons_unaligned        = 1U << 1,  
    cons_floats           = 1U << 2,  
    cons_throws_exception = 1U << 3,  
} ir_cons_flags;
ENUM_BITSET(ir_cons_flags)


typedef enum op_pin_state {
    op_pin_state_floats = 0,    
    op_pin_state_pinned = 1,    
    op_pin_state_exc_pinned,    
} op_pin_state;

typedef enum cond_jmp_predicate {
    COND_JMP_PRED_NONE,        
    COND_JMP_PRED_TRUE,        
    COND_JMP_PRED_FALSE        
} cond_jmp_predicate;

typedef enum mtp_additional_properties {
    mtp_no_property                 = 0,
    mtp_property_no_write           = 1u << 0,
    mtp_property_pure               = 1u << 1,
    mtp_property_noreturn           = 1u << 2,
    mtp_property_terminates         = 1u << 3,
    mtp_property_nothrow            = 1u << 4,
    mtp_property_naked              = 1u << 5,
    mtp_property_malloc             = 1u << 6,
    mtp_property_returns_twice      = 1u << 7,
    mtp_property_private            = 1u << 8,
    mtp_property_always_inline      = 1u << 9,
    mtp_property_noinline           = 1u << 10,
    mtp_property_inline_recommended = 1u << 11,
    mtp_temporary                   = 1u << 12,
} mtp_additional_properties;
ENUM_BITSET(mtp_additional_properties)


typedef struct ir_asm_constraint {
    unsigned pos;         
    ident    *constraint; 
    ir_mode  *mode;       
} ir_asm_constraint;

typedef enum ir_builtin_kind {
    ir_bk_trap,                 
    ir_bk_debugbreak,           
    ir_bk_return_address,       
    ir_bk_frame_address,        
    ir_bk_prefetch,             
    ir_bk_ffs,                  
    ir_bk_clz,                  
    ir_bk_ctz,                  
    ir_bk_popcount,             
    ir_bk_parity,               
    ir_bk_bswap,                
    ir_bk_inport,               
    ir_bk_outport,              
    ir_bk_saturating_increment, 
    ir_bk_compare_swap,         
    ir_bk_may_alias,            
    ir_bk_va_start,             
    ir_bk_va_arg,               
    ir_bk_last = ir_bk_va_arg,
} ir_builtin_kind;

typedef enum {
    volatility_non_volatile,    
    volatility_is_volatile      
} ir_volatility;

typedef enum {
    align_is_aligned = 0, 
    align_non_aligned,    
} ir_align;

typedef struct hook_entry hook_entry_t;

#include "end.h"

#endif