irmode.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_IRMODE_H
#define FIRM_IR_IRMODE_H

#include "firm_types.h"
#include "begin.h"

#include <stddef.h>

typedef enum ir_mode_arithmetic {
    irma_none = 1,            
    irma_twos_complement = 2, 
    irma_ieee754 = 256,       
    irma_x86_extended_float,  
    irma_last = irma_x86_extended_float,
} ir_mode_arithmetic;

FIRM_API ir_mode *new_int_mode(const char *name,
                               ir_mode_arithmetic arithmetic,
                               unsigned bit_size, int sign,
                               unsigned modulo_shift);

FIRM_API ir_mode *new_reference_mode(const char *name,
                                     ir_mode_arithmetic arithmetic,
                                     unsigned bit_size,
                                     unsigned modulo_shift);

FIRM_API ir_mode *new_float_mode(const char *name,
                                 ir_mode_arithmetic arithmetic,
                                 unsigned exponent_size,
                                 unsigned mantissa_size);

FIRM_API int is_mode(const void *thing);

FIRM_API ident *get_mode_ident(const ir_mode *mode);

FIRM_API const char *get_mode_name(const ir_mode *mode);

FIRM_API unsigned get_mode_size_bits(const ir_mode *mode);

FIRM_API unsigned get_mode_size_bytes(const ir_mode *mode);

FIRM_API int get_mode_sign(const ir_mode *mode);

FIRM_API ir_mode_arithmetic get_mode_arithmetic(const ir_mode *mode);

FIRM_API unsigned int get_mode_modulo_shift(const ir_mode *mode);

FIRM_API void *get_mode_link(const ir_mode *mode);

FIRM_API void set_mode_link(ir_mode *mode, void *l);

FIRM_API ir_tarval *get_mode_min(ir_mode *mode);

FIRM_API ir_tarval *get_mode_max(ir_mode *mode);

FIRM_API ir_tarval *get_mode_null(ir_mode *mode);

FIRM_API ir_tarval *get_mode_one(ir_mode *mode);

FIRM_API ir_tarval *get_mode_minus_one(ir_mode *mode);

FIRM_API ir_tarval *get_mode_all_one(ir_mode *mode);

FIRM_API ir_tarval *get_mode_infinite(ir_mode *mode);

FIRM_API ir_tarval *get_mode_NAN(ir_mode *mode);

FIRM_API ir_mode *mode_M; 
FIRM_API ir_mode *mode_F;   
FIRM_API ir_mode *mode_D;   
FIRM_API ir_mode *mode_Q;   
FIRM_API ir_mode *mode_Bs;  
FIRM_API ir_mode *mode_Bu;  
FIRM_API ir_mode *mode_Hs;  
FIRM_API ir_mode *mode_Hu;  
FIRM_API ir_mode *mode_Is;  
FIRM_API ir_mode *mode_Iu;  
FIRM_API ir_mode *mode_Ls;  
FIRM_API ir_mode *mode_Lu;  
FIRM_API ir_mode *mode_LLs; 
FIRM_API ir_mode *mode_LLu; 
FIRM_API ir_mode *mode_P;   
FIRM_API ir_mode *mode_P_code; 
FIRM_API ir_mode *mode_P_data; 
FIRM_API ir_mode *mode_b;  
FIRM_API ir_mode *mode_X;  
FIRM_API ir_mode *mode_BB; 
FIRM_API ir_mode *mode_T;  
FIRM_API ir_mode *mode_ANY;
FIRM_API ir_mode *mode_BAD;
FIRM_API ir_mode *get_modeF(void);
FIRM_API ir_mode *get_modeD(void);
FIRM_API ir_mode *get_modeQ(void);
FIRM_API ir_mode *get_modeBs(void);
FIRM_API ir_mode *get_modeBu(void);
FIRM_API ir_mode *get_modeHs(void);
FIRM_API ir_mode *get_modeHu(void);
FIRM_API ir_mode *get_modeIs(void);
FIRM_API ir_mode *get_modeIu(void);
FIRM_API ir_mode *get_modeLs(void);
FIRM_API ir_mode *get_modeLu(void);
FIRM_API ir_mode *get_modeLLs(void);
FIRM_API ir_mode *get_modeLLu(void);
FIRM_API ir_mode *get_modeP(void);
FIRM_API ir_mode *get_modeb(void);
FIRM_API ir_mode *get_modeX(void);
FIRM_API ir_mode *get_modeBB(void);
FIRM_API ir_mode *get_modeM(void);
FIRM_API ir_mode *get_modeT(void);
FIRM_API ir_mode *get_modeANY(void);
FIRM_API ir_mode *get_modeBAD(void);

FIRM_API ir_mode *get_modeP_code(void);

FIRM_API ir_mode *get_modeP_data(void);

FIRM_API void set_modeP_code(ir_mode *p);

FIRM_API void set_modeP_data(ir_mode *p);

FIRM_API int mode_is_signed (const ir_mode *mode);
FIRM_API int mode_is_float (const ir_mode *mode);
FIRM_API int mode_is_int (const ir_mode *mode);
FIRM_API int mode_is_reference (const ir_mode *mode);
FIRM_API int mode_is_num (const ir_mode *mode);
FIRM_API int mode_is_data (const ir_mode *mode);
FIRM_API int mode_is_datab (const ir_mode *mode);
FIRM_API int mode_is_dataM (const ir_mode *mode);

FIRM_API int smaller_mode(const ir_mode *sm, const ir_mode *lm);

FIRM_API int values_in_mode(const ir_mode *sm, const ir_mode *lm);

FIRM_API ir_mode *find_unsigned_mode(const ir_mode *mode);

FIRM_API ir_mode *find_signed_mode(const ir_mode *mode);

FIRM_API ir_mode *find_double_bits_int_mode(const ir_mode *mode);

FIRM_API int mode_honor_signed_zeros(const ir_mode *mode);

FIRM_API int mode_overflow_on_unary_Minus(const ir_mode *mode);

FIRM_API int mode_wrap_around(const ir_mode *mode);

FIRM_API ir_mode *get_reference_mode_signed_eq(ir_mode *mode);

FIRM_API void set_reference_mode_signed_eq(ir_mode *ref_mode, ir_mode *int_mode);

FIRM_API ir_mode *get_reference_mode_unsigned_eq(ir_mode *mode);

FIRM_API void set_reference_mode_unsigned_eq(ir_mode *ref_mode, ir_mode *int_mode);

FIRM_API unsigned get_mode_mantissa_size(const ir_mode *mode);

FIRM_API unsigned get_mode_exponent_size(const ir_mode *mode);

FIRM_API int is_reinterpret_cast(const ir_mode *src, const ir_mode *dst);

FIRM_API ir_type *get_type_for_mode(const ir_mode *mode);

FIRM_API size_t ir_get_n_modes(void);

FIRM_API ir_mode *ir_get_mode(size_t num);

#include "end.h"

#endif