libfirm/tv.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_TV_TV_H
#define FIRM_TV_TV_H

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

#include "begin.h"

FIRM_API ir_tarval *new_tarval_from_str(const char *str, size_t len,
                                        ir_mode *mode);

FIRM_API ir_tarval *new_integer_tarval_from_str(const char *str, size_t len,
                                                char sign, unsigned char base,
                                                ir_mode *mode);

FIRM_API ir_tarval *new_tarval_from_long(long l, ir_mode *mode);

FIRM_API long get_tarval_long(ir_tarval *tv);

FIRM_API int tarval_is_long(ir_tarval *tv);

FIRM_API ir_tarval *new_tarval_from_double(double d, ir_mode *mode);

FIRM_API ir_tarval *new_tarval_from_long_double(long double d, ir_mode *mode);

FIRM_API double get_tarval_double(ir_tarval *tv);

FIRM_API long double get_tarval_long_double(ir_tarval *tv);

FIRM_API int tarval_is_double(ir_tarval *tv);

FIRM_API ir_mode *get_tarval_mode(const ir_tarval *tv);

FIRM_API int tarval_is_negative(ir_tarval *tv);

FIRM_API int tarval_is_null(ir_tarval *tv);

FIRM_API int tarval_is_one(ir_tarval *tv);

FIRM_API int tarval_is_minus_one(ir_tarval *tv);

FIRM_API int tarval_is_all_one(ir_tarval *tv);

FIRM_API int tarval_is_constant(ir_tarval *tv);

FIRM_API ir_tarval *tarval_bad;
FIRM_API ir_tarval *get_tarval_bad(void);

FIRM_API ir_tarval *tarval_undefined;
FIRM_API ir_tarval *get_tarval_undefined(void);

FIRM_API ir_tarval *tarval_b_false;
FIRM_API ir_tarval *get_tarval_b_false(void);

FIRM_API ir_tarval *tarval_b_true;
FIRM_API ir_tarval *get_tarval_b_true(void);

FIRM_API ir_tarval *tarval_unreachable;
FIRM_API ir_tarval *get_tarval_unreachable(void);

FIRM_API ir_tarval *tarval_reachable;
FIRM_API ir_tarval *get_tarval_reachable(void);

#define tarval_top          tarval_undefined

#define get_tarval_top()    get_tarval_undefined()

#define tarval_bottom       tarval_bad

#define get_tarval_bottom() get_tarval_bad()

FIRM_API ir_tarval *get_tarval_max(ir_mode *mode);

FIRM_API ir_tarval *get_tarval_min(ir_mode *mode);

FIRM_API ir_tarval *get_tarval_null(ir_mode *mode);

FIRM_API ir_tarval *get_tarval_one(ir_mode *mode);

FIRM_API ir_tarval *get_tarval_minus_one(ir_mode *mode);

FIRM_API ir_tarval *get_tarval_all_one(ir_mode *mode);

FIRM_API ir_tarval *get_tarval_nan(ir_mode *mode);

FIRM_API ir_tarval *get_tarval_plus_inf(ir_mode *mode);

FIRM_API ir_tarval *get_tarval_minus_inf(ir_mode *mode);

typedef enum tarval_int_overflow_mode_t {
    TV_OVERFLOW_BAD,      
    TV_OVERFLOW_WRAP,     
    TV_OVERFLOW_SATURATE  
} tarval_int_overflow_mode_t;

FIRM_API void tarval_set_integer_overflow_mode(tarval_int_overflow_mode_t ov_mode);

FIRM_API tarval_int_overflow_mode_t tarval_get_integer_overflow_mode(void);

FIRM_API ir_relation tarval_cmp(ir_tarval *a, ir_tarval *b);

FIRM_API ir_tarval *tarval_convert_to(ir_tarval *src, ir_mode *mode);

/*
 * These function implement basic computations representable as opcodes
 * in FIRM nodes.
 *
 * PARAMETERS
 *    tarval_neg:
 *    traval_abs:
 *      a - the tarval to operate on
 *
 *    all others:
 *      a - the first operand tarval
 *      b - the second operand tarval
 *
 * RESULT
 *    If necessary a new tarval is constructed for the resulting value,
 *   or the one already carrying the computation result is retrieved and
 *   returned as result.
 *
 * NOTES
 *   The order the arguments are given in is important, imagine postfix
 *   notation.
 *   Illegal operations will trigger an assertion.
 *   The sort member of the struct mode defines which operations are valid
 */

FIRM_API ir_tarval *tarval_not(ir_tarval *a);

FIRM_API ir_tarval *tarval_neg(ir_tarval *a);

FIRM_API ir_tarval *tarval_add(ir_tarval *a, ir_tarval *b);

FIRM_API ir_tarval *tarval_sub(ir_tarval *a, ir_tarval *b, ir_mode *dst_mode);

FIRM_API ir_tarval *tarval_mul(ir_tarval *a, ir_tarval *b);

FIRM_API ir_tarval *tarval_div(ir_tarval *a, ir_tarval *b);

FIRM_API ir_tarval *tarval_mod(ir_tarval *a, ir_tarval *b);

FIRM_API ir_tarval *tarval_divmod(ir_tarval *a, ir_tarval *b, ir_tarval **mod_res);

FIRM_API ir_tarval *tarval_abs(ir_tarval *a);

FIRM_API ir_tarval *tarval_and(ir_tarval *a, ir_tarval *b);

FIRM_API ir_tarval *tarval_andnot(ir_tarval *a, ir_tarval *b);

FIRM_API ir_tarval *tarval_or(ir_tarval *a, ir_tarval *b);

FIRM_API ir_tarval *tarval_eor(ir_tarval *a, ir_tarval *b);

FIRM_API ir_tarval *tarval_shl(ir_tarval *a, ir_tarval *b);

FIRM_API ir_tarval *tarval_shr(ir_tarval *a, ir_tarval *b);

FIRM_API ir_tarval *tarval_shrs(ir_tarval *a, ir_tarval *b);

FIRM_API ir_tarval *tarval_rotl(ir_tarval *a, ir_tarval *b);

FIRM_API int tarval_carry(void);

typedef enum {
    TVO_NATIVE,  
    TVO_HEX,     
    TVO_DECIMAL, 
    TVO_OCTAL,   
    TVO_BINARY,  
    TVO_FLOAT,   
    TVO_HEXFLOAT 
} tv_output_mode;

typedef struct tarval_mode_info {
    tv_output_mode mode_output;  
    const char *mode_prefix;     
    const char *mode_suffix;     
} tarval_mode_info;

FIRM_API int set_tarval_mode_output_option(ir_mode *mode,
                                           const tarval_mode_info *modeinfo);

FIRM_API const tarval_mode_info *get_tarval_mode_output_option(ir_mode *mode);

FIRM_API char *get_tarval_bitpattern(ir_tarval *tv);

FIRM_API unsigned char get_tarval_sub_bits(ir_tarval *tv, unsigned byte_ofs);

FIRM_API int tarval_is_single_bit(ir_tarval *tv);

FIRM_API int get_tarval_popcount(ir_tarval *tv);

FIRM_API int get_tarval_lowest_bit(ir_tarval *tv);

FIRM_API int tarval_snprintf(char *buf, size_t buflen, ir_tarval *tv);

FIRM_API int tarval_printf(ir_tarval *tv);

FIRM_API int tarval_zero_mantissa(ir_tarval *tv);

FIRM_API int tarval_get_exponent(ir_tarval *tv);

FIRM_API int tarval_ieee754_can_conv_lossless(ir_tarval *tv, ir_mode *mode);

FIRM_API unsigned tarval_ieee754_get_exact(void);

FIRM_API void tarval_enable_fp_ops(int enable);

FIRM_API int tarval_fp_ops_enabled(void);

FIRM_API int tarval_is_NaN(ir_tarval *tv);

FIRM_API int tarval_is_plus_inf(ir_tarval *tv);

FIRM_API int tarval_is_minus_inf(ir_tarval *tv);

FIRM_API int tarval_is_finite(ir_tarval *tv);

FIRM_API int is_tarval(const void *thing);

#include "end.h"

#endif