/*
- * Copyright (C) 1995-2008 University of Karlsruhe. All right reserved.
+ * Copyright (C) 1995-2011 University of Karlsruhe. All right reserved.
*
* This file is part of libFirm.
*
#include <assert.h>
#include <stdlib.h>
#include <string.h>
-#ifdef HAVE_STRINGS_H
-#include <strings.h>
-#endif
#include <stdlib.h>
+#include <strings.h>
#include "bitfiddle.h"
#include "tv_t.h"
* private functions
****************************************************************************/
#ifndef NDEBUG
-static int hash_val(const void *value, unsigned int length);
-static int hash_tv(ir_tarval *tv);
+static unsigned hash_val(const void *value, size_t length);
+static unsigned hash_tv(ir_tarval *tv);
static void _fail_verify(ir_tarval *tv, const char* file, int line)
{
/* print a memory image of the tarval and throw an assertion */
#endif /* NDEBUG */
/** Hash a tarval. */
-static int hash_tv(ir_tarval *tv)
+static unsigned hash_tv(ir_tarval *tv)
{
- return (PTR_TO_INT(tv->value) ^ PTR_TO_INT(tv->mode)) + tv->length;
+ return (unsigned)((PTR_TO_INT(tv->value) ^ PTR_TO_INT(tv->mode)) + tv->length);
}
/** Hash a value. Treat it as a byte array. */
-static int hash_val(const void *value, unsigned int length)
+static unsigned hash_val(const void *value, size_t length)
{
- unsigned int i;
- unsigned int hash = 0;
+ size_t i;
+ unsigned hash = 0;
/* scramble the byte - array */
for (i = 0; i < length; ++i) {
}
/** finds tarval with value/mode or creates new tarval */
-static ir_tarval *get_tarval(const void *value, int length, ir_mode *mode)
+static ir_tarval *get_tarval(const void *value, size_t length, ir_mode *mode)
{
ir_tarval tv;
/**
* handle overflow
*/
-static ir_tarval *get_tarval_overflow(const void *value, int length, ir_mode *mode)
+static ir_tarval *get_tarval_overflow(const void *value, size_t length, ir_mode *mode)
{
char *temp;
return sc_val_to_long(tv->value);
}
-ir_tarval *new_tarval_from_double(long double d, ir_mode *mode)
+ir_tarval *new_tarval_from_long_double(long double d, ir_mode *mode)
{
const ieee_descriptor_t *desc;
return get_tarval(fc_get_buffer(), fc_get_buffer_length(), mode);
}
+ir_tarval *new_tarval_from_double(double d, ir_mode *mode)
+{
+ return new_tarval_from_long_double(d, mode);
+}
+
/* returns non-zero if can be converted to double */
int tarval_is_double(ir_tarval *tv)
{
return (get_mode_sort(tv->mode) == irms_float_number);
}
-long double get_tarval_double(ir_tarval *tv)
+long double get_tarval_long_double(ir_tarval *tv)
{
assert(tarval_is_double(tv));
return fc_val_to_ieee754((const fp_value*) tv->value);
}
+double get_tarval_double(ir_tarval *tv)
+{
+ return get_tarval_long_double(tv);
+}
+
/*
* Access routines for tarval fields ========================================
/*
* comparison
*/
-pn_Cmp tarval_cmp(ir_tarval *a, ir_tarval *b)
+ir_relation tarval_cmp(ir_tarval *a, ir_tarval *b)
{
carry_flag = -1;
}
if (a == tarval_undefined || b == tarval_undefined)
- return pn_Cmp_False;
+ return ir_relation_false;
if (a->mode != b->mode)
- return pn_Cmp_False;
+ return ir_relation_false;
if (get_mode_n_vector_elems(a->mode) > 1) {
/* vector arithmetic not implemented yet */
case irms_memory:
case irms_auxiliary:
if (a == b)
- return pn_Cmp_Eq;
- return pn_Cmp_False;
+ return ir_relation_equal;
+ return ir_relation_false;
case irms_float_number:
- /* it should be safe to enable this even if other arithmetic is disabled */
- /*if (no_float)
- return pn_Cmp_False;*/
/*
* BEWARE: we cannot compare a == b here, because
* a NaN is always Unordered to any other value, even to itself!
*/
switch (fc_comp((const fp_value*) a->value, (const fp_value*) b->value)) {
- case -1: return pn_Cmp_Lt;
- case 0: return pn_Cmp_Eq;
- case 1: return pn_Cmp_Gt;
- case 2: return pn_Cmp_Uo;
- default: return pn_Cmp_False;
+ case -1: return ir_relation_less;
+ case 0: return ir_relation_equal;
+ case 1: return ir_relation_greater;
+ case 2: return ir_relation_unordered;
+ default: return ir_relation_false;
}
case irms_reference:
case irms_int_number:
if (a == b)
- return pn_Cmp_Eq;
- return sc_comp(a->value, b->value) == 1 ? pn_Cmp_Gt : pn_Cmp_Lt;
+ return ir_relation_equal;
+ return sc_comp(a->value, b->value) == 1 ? ir_relation_greater : ir_relation_less;
case irms_internal_boolean:
if (a == b)
- return pn_Cmp_Eq;
- return a == tarval_b_true ? pn_Cmp_Gt : pn_Cmp_Lt;
+ return ir_relation_equal;
+ return a == tarval_b_true ? ir_relation_greater : ir_relation_less;
}
- return pn_Cmp_False;
+ return ir_relation_false;
}
/*
}
/*
- * floating point division
- */
-ir_tarval *tarval_quo(ir_tarval *a, ir_tarval *b)
-{
- assert((a->mode == b->mode) && mode_is_float(a->mode));
-
- carry_flag = -1;
-
- if (no_float)
- return tarval_bad;
-
- if (get_mode_n_vector_elems(a->mode) > 1) {
- /* vector arithmetic not implemented yet */
- return tarval_bad;
- }
-
- fc_div((const fp_value*) a->value, (const fp_value*) b->value, NULL);
- return get_tarval_overflow(fc_get_buffer(), fc_get_buffer_length(), a->mode);
-}
-
-/*
- * integer division
+ * division
* overflow is impossible, but look out for division by zero
*/
ir_tarval *tarval_div(ir_tarval *a, ir_tarval *b)
{
- assert((a->mode == b->mode) && mode_is_int(a->mode));
+ ir_mode *mode = a->mode;
+ assert(mode == b->mode);
carry_flag = -1;
- if (get_mode_n_vector_elems(a->mode) > 1) {
+ if (get_mode_n_vector_elems(mode) > 1) {
/* vector arithmetic not implemented yet */
return tarval_bad;
}
- /* x/0 error */
- if (b == get_mode_null(b->mode)) return tarval_bad;
- /* modes of a,b are equal */
- sc_div(a->value, b->value, NULL);
- return get_tarval(sc_get_buffer(), sc_get_buffer_length(), a->mode);
+ if (mode_is_int(mode)) {
+ /* x/0 error */
+ if (b == get_mode_null(mode))
+ return tarval_bad;
+
+ /* modes of a,b are equal */
+ sc_div(a->value, b->value, NULL);
+ return get_tarval(sc_get_buffer(), sc_get_buffer_length(), a->mode);
+ } else {
+ assert(mode_is_float(mode));
+ fc_div((const fp_value*) a->value, (const fp_value*) b->value, NULL);
+ return get_tarval_overflow(fc_get_buffer(), fc_get_buffer_length(), mode);
+ }
}
/*
projects / libfirm / blobdiff