-extern tarval *tarval_d_NaN;
-extern tarval *tarval_d_Inf;
-extern tarval *tarval_p_void;
-extern tarval *tarval_mode_null[];
-extern tarval *tarval_mode_min[];
-extern tarval *tarval_mode_max[];
-
-void tarval_init_1 (void);
-void tarval_init_2 (void);
-
-/* Hash function on tarvals */
-unsigned tarval_hash (tarval *);
-
-/************************* Constructors for tarvals *************************/
-tarval *tarval_Z_from_str (const char *, size_t, int base);
-tarval *tarval_B_from_str (const char *, size_t);
-tarval *tarval_d_from_str (const char *, size_t);
-tarval *tarval_s_from_str (const char *, size_t);
-tarval *tarval_S_from_str (const char *, size_t);
-tarval *tarval_from_long (ir_mode *, long);
-tarval *tarval_p_from_str (const char *);
-tarval *tarval_p_from_entity (entity *);
-
-tarval *tarval_convert_to (tarval *, ir_mode *);
-
-/* Building an irm_C, irm_s, irm_S or irm_B target value step by step. */
-void tarval_start (void);
-void tarval_append (const char *, size_t);
-void tarval_append1 (char);
-tarval *tarval_finish_as (ir_mode *);
-tarval *tarval_cancel (void); /* returns tarval_bad */
-
-\f
-/* The flags for projecting a comparison result */
+/** Returns the mode_b tarval 'true'. */
+tarval *get_tarval_b_true(void);
+
+/** The 'void' pointer tarval. */
+extern tarval *tarval_P_void;
+/** Returns the 'void' pointer tarval. */
+tarval *get_tarval_P_void(void);
+
+/* These functions calculate and return a tarval representing the requested
+ * value.
+ * The functions get_mode_{Max,Min,...} return tarvals retrieved from these
+ * functions, but these are stored on initialization of the irmode module and
+ * therefore the irmode functions should be prefered to the functions below. */
+
+/** Returns the maximum value of a given mode. */
+tarval *get_tarval_max(ir_mode *mode);
+
+/** Returns the minimum value of a given mode. */
+tarval *get_tarval_min(ir_mode *mode);
+
+/** Returns the 0 value (additive neutral) of a given mode. */
+tarval *get_tarval_null(ir_mode *mode);
+
+/** Returns the 1 value (multiplicative neutral) of a given mode. */
+tarval *get_tarval_one(ir_mode *mode);
+
+/** Returns the -1 value (multiplicative neutral) of a given mode.
+ * Returns tarval bad for unsigned modes */
+tarval *get_tarval_minus_one(ir_mode *mode);
+
+/** Return quite nan for float_number modes. */
+tarval *get_tarval_nan(ir_mode *mode);
+
+/** Return +inf for float_number modes. */
+tarval *get_tarval_plus_inf(ir_mode *mode);
+
+/** Return -inf for float_number modes. */
+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 */
+} 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
+ *
+ * Compare a with b and return a pn_Cmp describing the relation
+ * 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
+ *
+ * @return
+ * The pn_Cmp best describing the relation between a and b is returned.
+ * This means the mode with the least bits set is returned, e.g. if the
+ * tarvals are equal the pn_Cmp 'pn_Cmp_Eq' is returned, not 'pn_Cmp_Ge' which
+ * indicates 'greater or equal'
+ *
+ * @sa
+ * irnode.h for the definition of pn_Cmp
+ */
+pn_Cmp tarval_cmp(tarval *a, tarval *b);
+
+/**
+ * Converts a tarval to another mode.
+ *
+ * Convert tarval 'src' to mode 'mode', this will succeed if and only if mode
+ * 'mode' is wider than the mode of src, as defined in the firm documentation
+ * and as returned by the function mode_is_smaller defined in irmode.h.
+ *
+ * @param src The tarval to convert
+ * @param mode Tho mode to convert to
+ *
+ * @return
+ * If a tarval of mode 'mode' with the result of the conversion of the 'src'
+ * tarvals value already exists, it will be returned, else a new tarval is
+ * constructed and returned
+ *
+ * @note
+ * Illegal conversations will trigger an assertion
+ *
+ * @sa
+ * FIRM documentation for conversion rules
+ * mode_is_smaller defined in irmode.h
+ */
+tarval *tarval_convert_to(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
+ */
+
+/** 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_add(tarval *a, tarval *b);
+
+/** Subtraction from a tarval. */
+tarval *tarval_sub(tarval *a, tarval *b);
+
+/** Multiplication of tarvals. */
+tarval *tarval_mul(tarval *a, tarval *b);
+
+/** 'Exact' division. */
+tarval *tarval_quo(tarval *a, tarval *b);
+
+/** Integer division. */
+tarval *tarval_div(tarval *a, tarval *b);
+
+/** Remainder of integer division. */
+tarval *tarval_mod(tarval *a, tarval *b);
+
+/** Absolute value. */
+tarval *tarval_abs(tarval *a);
+
+/** Bitwise and. */
+tarval *tarval_and(tarval *a, tarval *b);
+
+/** Bitwise or. */
+tarval *tarval_or(tarval *a, tarval *b);
+
+/** Bitwise exclusive or. */
+tarval *tarval_eor(tarval *a, tarval *b);
+
+/** Left shift. */
+tarval *tarval_shl(tarval *a, tarval *b);
+
+/** Unsigned (logical) right shift. */
+tarval *tarval_shr(tarval *a, tarval *b);
+
+/** Signed (arithmetic) right shift. */
+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 *********** */
+
+/**
+ * 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 simpler...
+ */