X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=include%2Flibfirm%2Ftv.h;h=e7186490fa798b7f1b7b311e0cdb895e36b2e188;hb=f7a0dee11313faad6f2ff54edc8eaadabd03e433;hp=9fc65133ccf53b329d850304500494bea225fd49;hpb=bdacbd77db4138f76e06dde1f0098edfa25e1aa9;p=libfirm diff --git a/include/libfirm/tv.h b/include/libfirm/tv.h index 9fc65133c..e7186490f 100644 --- a/include/libfirm/tv.h +++ b/include/libfirm/tv.h @@ -1,5 +1,5 @@ /* - * Copyright (C) 1995-2007 University of Karlsruhe. All right reserved. + * Copyright (C) 1995-2008 University of Karlsruhe. All right reserved. * * This file is part of libFirm. * @@ -147,6 +147,8 @@ long get_tarval_long(tarval *tv); * This validates if get_tarval_long() will return a satisfying * result. I.e. if tv is an int_number and between min, max * of long int (signed!) + * + * @param tv the tarval */ int tarval_is_long(tarval *tv); @@ -185,6 +187,8 @@ tarval *new_tarval_from_double(long double d, ir_mode *mode); * stored value. * This will overflow silently, so use only if you know what * you are doing! (better check with tarval_is_long...) + * + * @param tv the tarval */ long double get_tarval_double(tarval *tv); @@ -192,6 +196,8 @@ long double get_tarval_double(tarval *tv); * This validates if tarval_to_double() will return a satisfying * result. I.e. if tv is an float_number and between min, max * of double + * + * @param tv the tarval */ int tarval_is_double(tarval *tv); @@ -221,8 +227,12 @@ int tarval_is_double(tarval *tv); * the struct tarval */ -/** Returns the mode of the tarval. */ -ir_mode *get_tarval_mode (const tarval *tv); +/** + * Returns the mode of the tarval. + * + * @param tv the tarval + */ +ir_mode *get_tarval_mode(const tarval *tv); /** Returns the contents of the 'link' field of the tarval */ /* void *get_tarval_link (tarval*); */ @@ -232,32 +242,45 @@ ir_mode *get_tarval_mode (const tarval *tv); /** * Returns 1 if tv is negative * - * @param a the tarval + * @param tv the tarval */ -int tarval_is_negative(tarval *a); +int tarval_is_negative(tarval *tv); /** * Returns 1 if tv is null * - * @param a the tarval + * @param tv the tarval */ -int tarval_is_null(tarval *a); +int tarval_is_null(tarval *tv); /** * Returns 1 if tv is the "one" * - * @param a the tarval + * @param tv the tarval */ -int tarval_is_one(tarval *a); +int tarval_is_one(tarval *tv); -/* +/** + * Returns 1 if tv is the "minus one" + * + * @param tv the tarval + */ +int tarval_is_minus_one(tarval *tv); + +/** * returns non-zero if all bits in the tarval are set */ int tarval_is_all_one(tarval *tv); +/** + * Return non-zero if the tarval is a constant (ie. NOT + * a reserved tarval like bad, undef, reachable etc.) + */ +int tarval_is_constant(tarval *tv); + /** The 'bad' tarval. */ extern tarval *tarval_bad; -/** Returns the 'bad tarval. */ +/** Returns the 'bad' tarval. */ tarval *get_tarval_bad(void); /** The 'undefined' tarval. */ @@ -267,7 +290,6 @@ tarval *get_tarval_undefined(void); /** The mode_b tarval 'false'. */ extern tarval *tarval_b_false; - /** Returns the mode_b tarval 'false'. */ tarval *get_tarval_b_false(void); @@ -276,6 +298,26 @@ extern tarval *tarval_b_true; /** Returns the mode_b tarval 'true'. */ tarval *get_tarval_b_true(void); +/** The mode_X tarval 'unreachable'. */ +extern tarval *tarval_unreachable; +/** Returns the mode_X tarval 'unreachable'. */ +tarval *get_tarval_unreachable(void); + +/** The mode_X tarval 'reachable'. */ +extern tarval *tarval_reachable; +/** Returns the mode_X tarval 'reachable'. */ +tarval *get_tarval_reachable(void); + +/** The 'top' tarval. This is just another name for the 'undefined' tarval. */ +#define tarval_top tarval_undefined +/** Returns the 'top' tarval. */ +#define get_tarval_top() get_tarval_undefined() + +/** The 'bottom' tarval. This is just another name for the 'bad' tarval. */ +#define tarval_bottom tarval_bad +/** Returns the 'bottom' tarval. */ +#define get_tarval_bottom() get_tarval_bad() + /* These functions calculate and return a tarval representing the requested * value. * The functions get_mode_{Max,Min,...} return tarvals retrieved from these @@ -315,13 +357,15 @@ tarval *get_tarval_minus_inf(ir_mode *mode); /* ******************** Arithmetic operations on tarvals ******************** */ typedef enum _tarval_int_overflow_mode_t { - TV_OVERFLOW_BAD, /**< tarval module will return tarval_bad if a overflow occurs */ - TV_OVERFLOW_WRAP, /**< tarval module will overflow will be ignored, wrap around occurs */ - TV_OVERFLOW_SATURATE /**< tarval module will saturate the overflow */ + TV_OVERFLOW_BAD, /**< tarval module will return tarval_bad if a overflow occurs */ + TV_OVERFLOW_WRAP, /**< tarval module will overflow will be ignored, wrap around occurs */ + TV_OVERFLOW_SATURATE /**< tarval module will saturate the overflow */ } tarval_int_overflow_mode_t; /** * Sets the overflow mode for integer operations. + * + * @param ov_mode one of teh overflow modes */ void tarval_set_integer_overflow_mode(tarval_int_overflow_mode_t ov_mode); @@ -337,8 +381,8 @@ tarval_int_overflow_mode_t tarval_get_integer_overflow_mode(void); * between a and b. This is either pn_Cmp_Uo, pn_Cmp_Lt, pn_Cmp_Eq, pn_Cmp_Gt, * or pn_Cmp_False if a or b are symbolic pointers which can not be compared at all. * - * @param a A tarval to be compared - * @param b A tarval to be compared + * @param a the first tarval to be compared + * @param b the second tarval to be compared * * @return * The pn_Cmp best describing the relation between a and b is returned. @@ -367,7 +411,7 @@ pn_Cmp tarval_cmp(tarval *a, tarval *b); * constructed and returned * * @note - * Illegal conversations will trigger an assertion + * Illegal convertions will trigger a panic * * @sa * FIRM documentation for conversion rules @@ -400,58 +444,178 @@ tarval *tarval_convert_to(tarval *src, ir_mode *mode); * The sort member of the struct mode defines which operations are valid */ -/** bitwise Negation of a tarval. */ +/** + * Bitwise Negation of a tarval. + * + * @param a the first tarval + * + * @return ~a or tarval_bad + */ tarval *tarval_not(tarval *a); -/** arithmetic Negation of a tarval. */ +/** + * Arithmetic Negation of a tarval. + * + * @param a the first tarval + * + * @return -a or tarval_bad + */ tarval *tarval_neg(tarval *a); -/** Addition of two tarvals. */ +/** + * Addition of two tarvals. + * + * @param a the first tarval + * @param b the second tarval + * + * @return a + b or tarval_bad + */ tarval *tarval_add(tarval *a, tarval *b); -/** Subtraction from a tarval. */ -tarval *tarval_sub(tarval *a, tarval *b); +/** + * Subtraction from a tarval. + * + * @param a the first tarval + * @param b the second tarval + * @param dst_mode the mode of the result, needed for mode_P - mode_P, else NULL + * + * @return a - b or tarval_bad + */ +tarval *tarval_sub(tarval *a, tarval *b, ir_mode *dst_mode); -/** Multiplication of tarvals. */ +/** + * Multiplication of tarvals. + * + * @param a the first tarval + * @param b the second tarval + * + * @return a * b or tarval_bad + */ tarval *tarval_mul(tarval *a, tarval *b); -/** 'Exact' division. */ +/** + * Division of two floating point tarvals. + * + * @param a the first tarval + * @param b the second tarval + * + * @return a / b or tarval_bad + */ tarval *tarval_quo(tarval *a, tarval *b); -/** Integer division. */ +/** + * Integer division of two tarvals. + * + * @param a the first tarval + * @param b the second tarval + * + * @return a / b or tarval_bad + */ tarval *tarval_div(tarval *a, tarval *b); -/** Remainder of integer division. */ +/** + * Remainder of integer division. + * + * @param a the first tarval + * @param b the second tarval + * + * @return a % b or tarval_bad + */ tarval *tarval_mod(tarval *a, tarval *b); -/** Integer division AND remainder. */ +/** + * Integer division AND remainder. + * + * @param a the first tarval + * @param b the second tarval + * @param mod_res after return, contains the remainder result, a % b or tarval_bad + * + * @return a / b or tarval_bad + */ tarval *tarval_divmod(tarval *a, tarval *b, tarval **mod_res); -/** Absolute value. */ +/** + * Absolute value of a tarval. + * + * @param a the first tarval + * + * @return |a| or tarval_bad + */ tarval *tarval_abs(tarval *a); -/** Bitwise and. */ +/** + * Bitwise and of two integer tarvals. + * + * @param a the first tarval + * @param b the second tarval + * + * @return a & b or tarval_bad + */ tarval *tarval_and(tarval *a, tarval *b); -/** Bitwise or. */ +/** + * Bitwise or of two integer tarvals. + * + * @param a the first tarval + * @param b the second tarval + * + * @return a | b or tarval_bad + */ tarval *tarval_or(tarval *a, tarval *b); -/** Bitwise exclusive or. */ +/** + * Bitwise exclusive or of two integer tarvals. + * + * @param a the first tarval + * @param b the second tarval + * + * @return a ^ b or tarval_bad + */ tarval *tarval_eor(tarval *a, tarval *b); -/** Left shift. */ +/** + * Logical Left shift. + * + * @param a the first tarval + * @param b the second tarval + * + * @return a << b or tarval_bad + */ tarval *tarval_shl(tarval *a, tarval *b); -/** Unsigned (logical) right shift. */ +/** + * Unsigned (logical) right shift. + * + * @param a the first tarval + * @param b the second tarval + * + * @return a >>u b or tarval_bad + */ tarval *tarval_shr(tarval *a, tarval *b); -/** Signed (arithmetic) right shift. */ +/** + * Signed (arithmetic) right shift. + * + * @param a the first tarval + * @param b the second tarval + * + * @return a >>s b or tarval_bad + */ tarval *tarval_shrs(tarval *a, tarval *b); -/** Rotation. */ -tarval *tarval_rot(tarval *a, tarval *b); +/** + * Rotation to left. + * + * @param a the first tarval + * @param b the second tarval + * + * @return a <> b or tarval_bad + */ +tarval *tarval_rotl(tarval *a, tarval *b); -/** Carry flag of the last operation */ +/** + * Returns the carry flag of the last operation. + */ int tarval_carry(void); /* *********** Output of tarvals *********** */ @@ -465,13 +629,13 @@ int tarval_carry(void); * However, we can do this in the tarval much simpler... */ typedef enum { - TVO_NATIVE, /**< the default output mode, depends on the mode */ - TVO_HEX, /**< use hex representation, always possible */ - TVO_DECIMAL, /**< use decimal representation */ - TVO_OCTAL, /**< use octal representation */ - TVO_BINARY, /**< use binary representation */ - TVO_FLOAT, /**< use floating point representation (i.e 1.342e-2)*/ - TVO_HEXFLOAT /**< use hexadecimal floating point representation (i.e 0x1.ea32p-12)*/ + TVO_NATIVE, /**< the default output mode, depends on the mode */ + TVO_HEX, /**< use hex representation, always possible */ + TVO_DECIMAL, /**< use decimal representation */ + TVO_OCTAL, /**< use octal representation */ + TVO_BINARY, /**< use binary representation */ + TVO_FLOAT, /**< use floating point representation (i.e 1.342e-2)*/ + TVO_HEXFLOAT /**< use hexadecimal floating point representation (i.e 0x1.ea32p-12)*/ } tv_output_mode; /** @@ -479,11 +643,11 @@ typedef enum { * of a tarval of a mode. */ typedef struct tarval_mode_info { - tv_output_mode mode_output; /**< if != TVO_NATIVE select a special mode */ - const char *mode_prefix; /**< if set, this prefix will be printed - before a value of this mode */ - const char *mode_suffix; /**< if set, this suffix will be printed - after a value of this mode */ + tv_output_mode mode_output; /**< if != TVO_NATIVE select a special mode */ + const char *mode_prefix; /**< if set, this prefix will be printed + before a value of this mode */ + const char *mode_suffix; /**< if set, this suffix will be printed + after a value of this mode */ } tarval_mode_info; /** @@ -561,44 +725,55 @@ char *get_tarval_bitpattern(tarval *tv); */ unsigned char get_tarval_sub_bits(tarval *tv, unsigned byte_ofs); -/** - * Return values of tarval classify - */ -typedef enum _tarval_classification_t { - TV_CLASSIFY_NULL = 0, /**< the tarval represents the additive neutral element */ - TV_CLASSIFY_ONE = +1, /**< the tarval represents the multiplicative neutral element */ - TV_CLASSIFY_ALL_ONE = -1, /**< the tarval represents the bitwise-and neutral element */ - TV_CLASSIFY_OTHER = 2 /**< all other tarvals */ -} tarval_classification_t; - /** * Returns non-zero if a given (integer) tarval has only one single bit * set. + * + * @param tv the tarval */ int tarval_is_single_bit(tarval *tv); /** - * Output of tarvals to a buffer. + * Output a tarval to a string buffer. + * + * @param buf the output buffer + * @param buflen the length of the buffer + * @param tv the tarval */ int tarval_snprintf(char *buf, size_t buflen, tarval *tv); /** - * Output of tarvals to stdio. + * Output a tarval to stdio. + * + * @param tv the tarval */ int tarval_printf(tarval *tv); /** * Returns non-zero if the mantissa of a floating point IEEE-754 * tarval is zero (i.e. 1.0Exxx) + * + * @param tv the tarval */ int tarval_ieee754_zero_mantissa(tarval *tv); /** * Returns the exponent of a floating point IEEE-754 * tarval. + * + * @param tv the tarval */ int tarval_ieee754_get_exponent(tarval *tv); +/** + * Check if the tarval can be converted to the given mode without + * precision loss. + * + * @param tv the tarval + * param mode the mode to convert to + */ +int tarval_ieee754_can_conv_lossless(tarval *tv, ir_mode *mode); + /** * Set the immediate precision for IEEE-754 results. Set this to * 0 to get the same precision as the operands. @@ -613,9 +788,53 @@ unsigned tarval_ieee754_set_immediate_precision(unsigned bits); */ unsigned tarval_ieee754_get_exact(void); +/** + * Return the size of the mantissa in bits (including possible + * implicit bits) for the given mode. + */ +unsigned tarval_ieee754_get_mantissa_size(const ir_mode *mode); + /** * Enable/Disable floating point constant folding. */ int tarval_enable_fp_ops(int enable); +/** + * Check if its the a floating point NaN. + * + * @param tv the tarval + */ +int tarval_is_NaN(tarval *tv); + +/** + * Check if its the a floating point +inf. + * + * @param tv the tarval + */ +int tarval_is_plus_inf(tarval *tv); + +/** + * Check if its the a floating point -inf. + * + * @param tv the tarval + */ +int tarval_is_minus_inf(tarval *tv); + +/** + * Check if the tarval represents a finite value, ie neither NaN nor inf. + * + * @param tv the tarval + */ +int tarval_is_finite(tarval *tv); + +/** + * Checks whether a pointer points to a tarval. + * + * @param thing an arbitrary pointer + * + * @return + * true if the thing is a tarval, else false + */ +int is_tarval(const void *thing); + #endif /* FIRM_TV_TV_H */