X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Ftv%2Ftv.h;h=8ed8a5490db577e0b03207b57c7b289fbf715dce;hb=2d09549421b49587d4680a94dab277646e9fef44;hp=69f7c276a5551ebc66fdaf5518edbe9682766c6a;hpb=6a12c4be6be2050e965ff7a543d2c3119afbf971;p=libfirm diff --git a/ir/tv/tv.h b/ir/tv/tv.h index 69f7c276a..8ed8a5490 100644 --- a/ir/tv/tv.h +++ b/ir/tv/tv.h @@ -1,53 +1,30 @@ +/* + * Project: libFIRM + * File name: ir/tv/tv.h + * Purpose: Representation of and static computations on target machine + * values. + * Author: Mathias Heil + * Modified by: + * Created: + * CVS-ID: $Id$ + * Copyright: (c) 2003 Universität Karlsruhe + * Licence: This file protected by GPL - GNU GENERAL PUBLIC LICENSE. + */ + /** * @file tv.h * * Declarations for Target Values. */ -/* $Id$ */ - -/* -Discussion of new interface, proposals by Prof. Waite: -(email of 13.6.2001) -> 1. You say that you plan to replace the tv module. That replacement is -> absolutely essential for an ANSI C translator: Section 6.1.3.2 of the -> standard says that the representation of an integer_constant depends -> upon its value as well as any suffixes that are attached to it. The -> possible Firm modes for such a constant are i, I, l, and L. The -> current tv module provides only one integer conversion routine, and -> that requires conversion by the client. Since the type of the value -> argument is long, this may preclude the representation of an unsigned -> long constant. -> -> There is a similar problem with floating constants. Floating -> constants can be suffixed in C, and the mode depends upon the suffix. -> It can indicate that the constant is of type long double, which your -> current tv module is incapable of representing. -> -> Your tv module interface accepts two kinds of information: modes and -> values. Values obtained from the program text might be uninterpreted -> strings, strings interpreted as integers, and strings interpreted as -> reals. Values provided by the compiler are usually integers. Modes are -> always Firm modes. It seems to me that the tv module should provide -> tarval* constructors for three of the four kinds of values. Each of these -> constructors should have an ir_mode parameter and one or more parameters -> appropriate for the kind of value. As is currently the case, one -> constructor should be provided for both compiler-generated integers and -> source strings interpreted as integers. (This avoids problems of -> different conversion radices -- the client does the conversion.) For -> symmetry, the constructor for source strings interpreted as reals should -> accept a long double parameter and require the client to do the -> conversion. - -*/ - #ifndef _TV_H_ #define _TV_H_ # include "irmode.h" -# include "entity.h" +/* # include "entity.h" */ # include "irnode.h" /* for pnc_number enum */ + /****h* libfirm/tv * * NAME @@ -55,7 +32,6 @@ Discussion of new interface, proposals by Prof. Waite: * Internal representation for machine values. * * AUTHORS - * Christian von Roques * Matthias Heil * * DESCRIPTION @@ -175,15 +151,17 @@ tarval *new_tarval_from_str(const char *str, size_t len, ir_mode *mode); */ tarval *new_tarval_from_long(long l, ir_mode *mode); -/** +/** Return value as long if possible. + * * This returns a long int with the value represented value, or * gibberish, depending on the size of long int and the size of the * stored value. It works for e.g. 1 as mode_Ls, but might not work for * get_mode_max(mode_Ls). * This will overflow silently, so use only if you know what * you are doing! (better check with tarval_is_long()...) + * Works only for int modes, even not for character modes! */ -long tarval_to_long(tarval *tv); +long get_tarval_long(tarval *tv); /** * This validates if tarval_to_long() will return a satisfying @@ -195,11 +173,11 @@ int tarval_is_long(tarval *tv); /** * Constructor function for new tarvals. * - * @param d The long double representing the value + * @param d The (long) double representing the value * @param mode The mode requested for the result tarval * * This function creates a new tarval representing the value represented - * by a long double. If a tarval representing this value already exists, + * by a (long) double. If a tarval representing this value already exists, * this tarval is returned instead of a new one. So tarvals are directly * comparable since their representation is unique. * Only modes of sort float_number can be constructed this way. @@ -211,7 +189,7 @@ int tarval_is_long(tarval *tv); * value/mode pair. * * @note - * If the long double is not representable in the given mode an assertion + * If the (long) double is not representable in the given mode an assertion * is thrown. This will happen for any mode not of sort float_number. * * @sa @@ -228,7 +206,7 @@ tarval *new_tarval_from_double(long double d, ir_mode *mode); * This will overflow silently, so use only if you know what * you are doing! (better check with tarval_is_long...) */ -long double tarval_to_double(tarval *tv); +long double get_tarval_double(tarval *tv); /** * This validates if tarval_to_double() will return a satisfying @@ -237,22 +215,6 @@ long double tarval_to_double(tarval *tv); */ int tarval_is_double(tarval *tv); -/** - * Construct a tarval that represents the address of the entity. - * - * The address must be constant, the entity must have as owner the global type. - */ -tarval *new_tarval_from_entity (entity *ent, ir_mode *mode); - -/** - * Returns the associated entity of a tarval. - */ -entity *tarval_to_entity(tarval *tv); - -/** - * Returns non-zero if a the given tarval represents an entity. - */ -int tarval_is_entity(tarval *tv); /** ********** Access routines for tarval fields ********** **/ @@ -298,6 +260,13 @@ int tarval_is_negative(tarval *a); */ int tarval_is_null(tarval *a); +/** + * Returns 1 if tv is the "one" + * + * @param a the tarval + */ +int tarval_is_one(tarval *a); + /** The 'bad' tarval. */ extern tarval *tarval_bad; /** Returns the 'bad tarval. */ @@ -349,6 +318,22 @@ tarval *get_tarval_inf(ir_mode *mode); /* ******************** Arithmethic 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 */ +} tarval_int_overflow_mode_t; + +/** + * Sets the overflow mode for integer operations. + */ +void tarval_set_integer_overflow_mode(tarval_int_overflow_mode_t ov_mode); + +/** + * Get the overflow mode for integer operations. + */ +tarval_int_overflow_mode_t tarval_get_integer_overflow_mode(void); + /** * Compares two tarvals * @@ -419,7 +404,10 @@ tarval *tarval_convert_to(tarval *src, ir_mode *m); * The sort member of the struct mode defines which operations are valid */ -/** Negation of a tarval. */ +/** bitwise Negation of a tarval. */ +tarval *tarval_not(tarval *a); + +/** arithmetic Negation of a tarval. */ tarval *tarval_neg(tarval *a); /** Addition of two tarvals. */ @@ -464,6 +452,9 @@ tarval *tarval_shrs(tarval *a, tarval *b); /** Rotation. */ tarval *tarval_rot(tarval *a, tarval *b); +/** Carry flag of the last operation */ +int tarval_carry(void); + /* *********** Output of tarvals *********** */ /** @@ -480,12 +471,13 @@ typedef enum { TVO_DECIMAL, /**< use decimal representation */ TVO_OCTAL, /**< use octal representation */ TVO_BINARY, /**< use binary representation */ - TVO_FLOAT /**< use floating point 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; /** * This structure contains helper information to format the output - * of a tarval of an mode. + * of a tarval of a mode. */ typedef struct tarval_mode_info { tv_output_mode mode_output; /**< if != TVO_NATIVE select a special mode */ @@ -503,9 +495,20 @@ typedef struct tarval_mode_info { * @param mode a ir_mode that should be associated * @param modeinfo the output format info * - * Returns zero on success. + * @return zero on success. + */ +int set_tarval_mode_output_option(ir_mode *mode, const tarval_mode_info *modeinfo); + +/** + * Returns the output options of one mode. + * + * This functions returns the modinfo of a given mode. + * + * @param mode a ir_mode that should be associated + * + * @return the output option */ -int tarval_set_mode_output_option(ir_mode *mode, const tarval_mode_info *modeinfo); +const tarval_mode_info *get_tarval_mode_output_option(ir_mode *mode); /** * Returns Bit representation of a tarval value, as string of '0' and '1' @@ -530,7 +533,7 @@ int tarval_set_mode_output_option(ir_mode *mode, const tarval_mode_info *modeinf * irmode.h for the definition of the ir_mode struct * the size member of aforementioned struct */ -char *tarval_bitpattern(tarval *tv); +char *get_tarval_bitpattern(tarval *tv); /** * Returns the bitpattern of the bytes_ofs byte. @@ -557,40 +560,39 @@ char *tarval_bitpattern(tarval *tv); * @note * The result of this funcion is undefined if the mode is neither integer nor float. */ -unsigned char tarval_sub_bits(tarval *tv, unsigned byte_ofs); +unsigned char get_tarval_sub_bits(tarval *tv, unsigned byte_ofs); /** - * Identifying some tarvals ??? - * - * @return - * - 0 for additive neutral, - * - +1 for multiplicative neutral, - * - -1 for bitwise-and neutral - * - 2 else - * - * @deprecated - * This function is deprecated and its use strongly discouraged. - * Implemented for completeness. + * Return values of tarval classify */ -long tarval_classify(tarval *tv); +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; /** - * Initialization of the tarval module. - * - * Call before init_mode(). + * Identifying tarvals values for algebraic simplifications. + * @param tv + * @return + * - TV_CLASSIFY_NULL for additive neutral, + * - TV_CLASSIFY_ONE for multiplicative neutral, + * - TV_CLASSIFY_ALL_ONE for bitwise-and neutral + * - TV_CLASSIFY_OTHER else */ -void init_tarval_1(void); +tarval_classification_t classify_tarval(tarval *tv); + + /** - * Initialization of the tarval module. - * - * Call after init_mode(). + * Output of tarvals to a buffer. */ -void init_tarval_2(void); +int tarval_snprintf(char *buf, size_t buflen, tarval *tv); /** - * Output of tarvals. + * Output of tarvals to stdio. */ -int tarval_snprintf(char *buf, size_t buflen, tarval *tv); +int tarval_printf(tarval *tv); #endif /* _TV_H_ */