X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=include%2Flibfirm%2Ftv.h;h=82d75dd5f10f469f51e3485911a3cb6e8351af28;hb=94f6c873ed355ad4480e62d1b3aa47899148c436;hp=466488276dac86130f012a67ecbd980ee65cec0d;hpb=f549051eeb9789b68f2c40b45e02d3fab4a027e3;p=libfirm diff --git a/include/libfirm/tv.h b/include/libfirm/tv.h index 466488276..82d75dd5f 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. * @@ -24,7 +24,7 @@ * @date 2003 * @author Mathias Heil * @version $Id$ - * @summary + * @brief * Tarvals represent target machine values. They are typed by modes. * Tarvals only represent values of mode_sort: * - int_number, @@ -74,7 +74,7 @@ * - 0[0-7]* (octal representation) * - (+|-)?[1-9][0-9]* (decimal representation) * - * if mode if float_number: + * if mode is float_number: * - (+|-)?(decimal int) (. (decimal int))? ((e|E)(+|-)?(decimal int))? * * if mode is boolean: true, True, TRUE ... False... 0, 1, @@ -102,6 +102,26 @@ */ tarval *new_tarval_from_str(const char *str, size_t len, ir_mode *mode); +/** + * Construct a new tarval from a given string. + * + * @param str The string representing the target value + * @param len The length of the string + * @param sign is -1 or 1 depending on the numbers sign + * @param base number system base. + * binary(2), octal(8), decimal(10) and hexadecimal(16) numbers + * are supported. + * @param mode The mode requested for the result tarval + * + * @return + * A tarval with the given mode. If overflow settings are set to + * TV_OVERFLOW_BAD then a tarval_bad is returned if the number can't be + * represented in the given mode. + * Return bad if the number couldn't successfully be parsed. + */ +tarval *new_integer_tarval_from_str(const char *str, size_t len, char sign, + unsigned char base, ir_mode *mode); + /** * Constructor function for new tarvals * @@ -147,6 +167,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 +207,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 +216,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 +247,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,27 +262,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 *tv); + +/** + * Returns 1 if tv is the "minus one" + * + * @param tv the tarval */ -int tarval_is_one(tarval *a); +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. */ @@ -262,7 +310,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); @@ -271,6 +318,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 @@ -310,13 +377,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); @@ -332,8 +401,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. @@ -362,7 +431,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 @@ -395,58 +464,188 @@ 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 and not of two integer tarvals. + * + * @param a the first tarval + * @param b the second tarval + * + * @return a & ~b or tarval_bad + */ +tarval *tarval_andnot(tarval *a, tarval *b); + +/** + * 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 *********** */ @@ -460,13 +659,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; /** @@ -474,11 +673,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; /** @@ -537,10 +736,10 @@ char *get_tarval_bitpattern(tarval *tv); * * To query a 32bit value the following code can be used: * - * val0 = tarval_sub_bits(tv, 0); + * val0 = tarval_sub_bits(tv, 0); <- lowest bits * val1 = tarval_sub_bits(tv, 1); * val2 = tarval_sub_bits(tv, 2); - * val3 = tarval_sub_bits(tv, 3); + * val3 = tarval_sub_bits(tv, 3); <- highest bits * * Because this is the bit representation of the target machine, only the following * operations are legal on the result: @@ -549,7 +748,7 @@ char *get_tarval_bitpattern(tarval *tv); * - bitwise logical operations to select/mask bits * * @param tv the tarval - * @param byte_ofs the byte offset + * @param byte_ofs the byte offset from lower to higher * * @note * The result of this function is undefined if the mode is neither integer nor float. @@ -557,56 +756,72 @@ char *get_tarval_bitpattern(tarval *tv); unsigned char get_tarval_sub_bits(tarval *tv, unsigned byte_ofs); /** - * Return values of tarval classify + * Returns non-zero if a given (integer) tarval has only one single bit + * set. + * + * @param tv the tarval */ -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; +int tarval_is_single_bit(tarval *tv); /** - * Identifying tarvals values for algebraic simplifications. + * Return the number of set bits in a given (integer) tarval. * - * @param tv the tarval + * @param tv the tarval * - * @return - * - TV_CLASSIFY_NULL for additive neutral or the NULL tarval for reference modes, - * - TV_CLASSIFY_ONE for multiplicative neutral, - * - TV_CLASSIFY_ALL_ONE for bitwise-and neutral - * - TV_CLASSIFY_OTHER else + * @return number of set bits or -1 on error */ -tarval_classification_t classify_tarval(tarval *tv); +int get_tarval_popcount(tarval *tv); /** - * Returns non-zero if a given (integer) tarval has only one single bit - * set. + * Return the number of the lowest set bit in a given (integer) tarval. + * + * @param tv the tarval + * + * @return number of lowest set bit or -1 on error */ -int tarval_is_single_bit(tarval *tv); +int get_tarval_lowest_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. @@ -621,9 +836,56 @@ 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); +void tarval_enable_fp_ops(int enable); + +/** returns 0/1 if floating point folding is enable/disabled */ +int tarval_fp_ops_enabled(void); + +/** + * 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 */