+/*
+ * 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 "entity.h"
# include "irnode.h" /* for pnc_number enum */
+
/****h* libfirm/tv
*
* NAME
* Internal representation for machine values.
*
* AUTHORS
- * Christian von Roques
* Matthias Heil
*
* DESCRIPTION
/**
* 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.
* 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
* Construct a tarval that represents the address of the entity.
*
* The address must be constant, the entity must have as owner the global type.
+ * We no more support this function: Use the new SymConst instead.
*/
tarval *new_tarval_from_entity (entity *ent, ir_mode *mode);
/**
- * Returns the associated entity of a tarval.
+ * Returns the associated entity of a tarval. Asserts if tarval does not
+ * contain an entity.
*/
+#define get_tarval_entity tarval_to_entity
entity *tarval_to_entity(tarval *tv);
/**
*/
/** Returns the mode of the tarval. */
-#ifdef TARVAL_ACCESS_DEFINES
-# include "tv_t.h"
-# define get_tarval_mode(tv) (tv)->mode
-#else
ir_mode *get_tarval_mode (tarval *tv);
-#endif
/* Testing properties of the represented values */
-/** Returns 0 if tv is positive, else > 0.
+/**
+ * Returns 1 if tv is negative
*
- * @todo
- * not tested!
+ * @param a the tarval
*/
int tarval_is_negative(tarval *a);
+/**
+ * Returns 1 if tv is null
+ *
+ * @param a the tarval
+ */
+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. */
* 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. */
tarval *tarval_and(tarval *a, tarval *b);
/** Bitwise or. */
-tarval *tarval_or (tarval *a, tarval *b);
+tarval *tarval_or(tarval *a, tarval *b);
/** Bitwise exclusive or. */
tarval *tarval_eor(tarval *a, tarval *b);
/* *********** Output of tarvals *********** */
+/**
+ * The output mode for tarval values.
+ *
+ * Some modes allow more that one representation, for instance integers
+ * can be represented hex or decimal. Of course it would be enough to have
+ * one and let every backend convert it into the 'right' one.
+ * However, we can do this in the tarval much simplier...
+ */
+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)*/
+} tv_output_mode;
+
+/**
+ * This structure contains helper information to format the output
+ * 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 */
+} tarval_mode_info;
+
+/**
+ * Specify the output options of one mode.
+ *
+ * This functions stores the modinfo, so DO NOT DESTROY it.
+ *
+ * @param mode a ir_mode that should be associated
+ * @param modeinfo the output format info
+ *
+ * @return zero on success.
+ */
+int tarval_set_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
+ */
+const tarval_mode_info *tarval_get_mode_output_option(ir_mode *mode);
+
/**
* Returns Bit representation of a tarval value, as string of '0' and '1'
*
*/
char *tarval_bitpattern(tarval *tv);
-/**
- * Returns bitpattern [from, to[.
- */
-char *tarval_sub_bitpattern(tarval *tv, int from, int to);
-
/**
* Returns the bitpattern of the bytes_ofs byte.
*
* Because this is the bit representation of the target machine, only the following
* operations are legal on the result:
*
- * - concatenation (be aware of the endieness)
- * - bitwise logical operations to selct/mask bits
+ * - concatenation (endian dependance MUST be handled by the CALLER)
+ * - bitwise logical operations to select/mask bits
*
* @param tv the tarval
* @param byte_ofs the byte offset
unsigned char tarval_sub_bits(tarval *tv, unsigned byte_ofs);
/**
- * Identifying some tarvals ???
- *
+ * 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;
+
+/**
+ * Identifying tarvals values for algebraic simplifications.
+ * @param tv
* @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.
+ * - TV_CLASSIFY_NULL for additive neutral,
+ * - TV_CLASSIFY_ONE for multiplicative neutral,
+ * - TV_CLASSIFY_ALL_ONE for bitwise-and neutral
+ * - TV_CLASSIFY_OTHER else
*/
-long tarval_classify(tarval *tv);
+tarval_classification_t tarval_classify(tarval *tv);
/**
* Initialization of the tarval module.
*/
void init_tarval_2(void);
+void finish_tarval(void);
+
+/**
+ * Output of tarvals to a buffer.
+ */
+int tarval_snprintf(char *buf, size_t buflen, tarval *tv);
+
+/**
+ * Output of tarvals to stdio.
+ */
+int tarval_printf(tarval *tv);
+
#endif /* _TV_H_ */
projects / libfirm / blobdiff