#define fail_verify(a) _fail_verify((a), __FILE__, __LINE__)
-/****************************************************************************
- * private variables
- ****************************************************************************/
-static struct set *tarvals = NULL; /* container for tarval structs */
-static struct set *values = NULL; /* container for values */
+/** A set containing all existing tarvals. */
+static struct set *tarvals = NULL;
+/** A set containing all existing values. */
+static struct set *values = NULL;
+
+/** The integer overflow mode. */
static tarval_int_overflow_mode_t int_overflow_mode = TV_OVERFLOW_WRAP;
/** if this is set non-zero, the constant folding for floating point is OFF */
static int no_float = 0;
+/** IEEE-754r half precision */
+static const ieee_descriptor_t half_desc = { 5, 10, 0, NORMAL };
+/** IEEE-754 single precision */
+static const ieee_descriptor_t single_desc = { 8, 23, 0, NORMAL };
+/** IEEE-754 double precision */
+static const ieee_descriptor_t double_desc = { 11, 52, 0, NORMAL };
+/** Intel x87 extended precision */
+static const ieee_descriptor_t extended_desc = { 15, 63, 1, NORMAL };
+
+/** IEEE-754r quad precision */
+static const ieee_descriptor_t quad_desc = { 15, 112, 0, NORMAL };
+
/****************************************************************************
* private functions
****************************************************************************/
{
/* print a memory image of the tarval and throw an assertion */
if (tv)
- printf("%s:%d: Invalid tarval:\n mode: %s\n value: [%p]\n", file, line, get_mode_name(tv->mode), tv->value);
+ panic("%s:%d: Invalid tarval: mode: %F\n value: [%p]", file, line, tv->mode, tv->value);
else
- printf("%s:%d: Invalid tarval (null)", file, line);
- assert(0);
+ panic("%s:%d: Invalid tarval (null)", file, line);
}
#ifdef __GNUC__
INLINE static void tarval_verify(tarval *tv) __attribute__ ((unused));
assert(tv1->kind == k_tarval);
assert(tv2->kind == k_tarval);
- if(tv1->mode < tv2->mode)
+ if (tv1->mode < tv2->mode)
return -1;
- if(tv1->mode > tv2->mode)
+ if (tv1->mode > tv2->mode)
return 1;
- if(tv1->length < tv2->length)
+ if (tv1->length < tv2->length)
return -1;
- if(tv1->length > tv2->length)
+ if (tv1->length > tv2->length)
return 1;
- if(tv1->value < tv2->value)
+ if (tv1->value < tv2->value)
return -1;
- if(tv1->value > tv2->value)
+ if (tv1->value > tv2->value)
return 1;
return 0;
tarval *tarval_reachable = &reserved_tv[4];
tarval *tarval_unreachable = &reserved_tv[5];
+/**
+ * get the float descriptor for given mode.
+ */
+static const ieee_descriptor_t *get_descriptor(const ir_mode *mode) {
+ switch (get_mode_size_bits(mode)) {
+ case 16: return &half_desc;
+ case 32: return &single_desc;
+ case 64: return &double_desc;
+ case 80:
+ case 96: return &extended_desc;
+ case 128: return &quad_desc;
+ default:
+ panic("Unsupported mode in get_descriptor()");
+ return NULL;
+ }
+}
+
/*
* public functions declared in tv.h
*/
*/
tarval *new_tarval_from_str(const char *str, size_t len, ir_mode *mode)
{
+ const ieee_descriptor_t *desc;
+
assert(str);
assert(len);
assert(mode);
case irms_control_flow:
case irms_memory:
case irms_auxiliary:
- assert(0);
- break;
+ panic("Unsupported tarval creation with mode %F", mode);
case irms_internal_boolean:
/* match [tT][rR][uU][eE]|[fF][aA][lL][sS][eE] */
return atoi(str) ? tarval_b_true : tarval_b_false;
case irms_float_number:
- switch (get_mode_size_bits(mode)) {
- case 32:
- fc_val_from_str(str, len, 8, 23, NULL);
- break;
- case 64:
- fc_val_from_str(str, len, 11, 52, NULL);
- break;
- case 80:
- case 96:
- fc_val_from_str(str, len, 15, 64, NULL);
- break;
- default:
- panic("Unsupported mode in new_tarval_from_str()");
- }
+ desc = get_descriptor(mode);
+ fc_val_from_str(str, len, desc, NULL);
return get_tarval(fc_get_buffer(), fc_get_buffer_length(), mode);
case irms_reference:
sc_val_from_str(str, len, NULL, mode);
return get_tarval(sc_get_buffer(), sc_get_buffer_length(), mode);
}
-
- assert(0); /* can't be reached, can it? */
- return NULL;
+ panic("Unsupported tarval creation with mode %F", mode);
}
/*
}
tarval *new_tarval_from_double(long double d, ir_mode *mode) {
- assert(mode && (get_mode_sort(mode) == irms_float_number));
+ const ieee_descriptor_t *desc;
- switch (get_mode_size_bits(mode)) {
- case 32:
- fc_val_from_ieee754(d, 8, 23, NULL);
- break;
- case 64:
- fc_val_from_ieee754(d, 11, 52, NULL);
- break;
- case 80:
- case 96:
- fc_val_from_ieee754(d, 15, 64, NULL);
- break;
- default:
- panic("Unsupported mode in new_tarval_from_double()");
- }
+ assert(mode && (get_mode_sort(mode) == irms_float_number));
+ desc = get_descriptor(mode);
+ fc_val_from_ieee754(d, desc, NULL);
return get_tarval(fc_get_buffer(), fc_get_buffer_length(), mode);
}
}
tarval *get_tarval_max(ir_mode *mode) {
- assert(mode);
+ const ieee_descriptor_t *desc;
+ assert(mode);
if (get_mode_n_vector_elems(mode) > 1) {
/* vector arithmetic not implemented yet */
return tarval_bad;
}
- switch(get_mode_sort(mode)) {
+ switch (get_mode_sort(mode)) {
case irms_control_flow:
case irms_memory:
case irms_auxiliary:
- assert(0);
- break;
+ panic("mode %F does not support maximum value", mode);
case irms_internal_boolean:
return tarval_b_true;
case irms_float_number:
- switch(get_mode_size_bits(mode)) {
- case 32:
- fc_get_max(8, 23, NULL);
- break;
- case 64:
- fc_get_max(11, 52, NULL);
- break;
- case 80:
- case 96:
- fc_get_max(15, 64, NULL);
- break;
- default:
- panic("Unsupported mode in get_tarval_max()");
- }
+ desc = get_descriptor(mode);
+ fc_get_max(desc, NULL);
return get_tarval(fc_get_buffer(), fc_get_buffer_length(), mode);
case irms_reference:
}
tarval *get_tarval_min(ir_mode *mode) {
- assert(mode);
+ const ieee_descriptor_t *desc;
+ assert(mode);
if (get_mode_n_vector_elems(mode) > 1) {
/* vector arithmetic not implemented yet */
return tarval_bad;
}
- switch(get_mode_sort(mode)) {
+ switch (get_mode_sort(mode)) {
case irms_control_flow:
case irms_memory:
case irms_auxiliary:
- assert(0);
- break;
+ panic("mode %F does not support minimum value", mode);
case irms_internal_boolean:
return tarval_b_false;
case irms_float_number:
- switch(get_mode_size_bits(mode)) {
- case 32:
- fc_get_min(8, 23, NULL);
- break;
- case 64:
- fc_get_min(11, 52, NULL);
- break;
- case 80:
- case 96:
- fc_get_min(15, 64, NULL);
- break;
- default:
- panic("Unsupported mode in get_tarval_min()");
- }
+ desc = get_descriptor(mode);
+ fc_get_min(desc, NULL);
return get_tarval(fc_get_buffer(), fc_get_buffer_length(), mode);
case irms_reference:
return tarval_bad;
}
- switch(get_mode_sort(mode)) {
+ switch (get_mode_sort(mode)) {
case irms_control_flow:
case irms_memory:
case irms_auxiliary:
- assert(0);
- break;
+ panic("mode %F does not support null value", mode);
case irms_float_number:
return new_tarval_from_double(0.0, mode);
tarval *get_tarval_one(ir_mode *mode) {
assert(mode);
- if (get_mode_n_vector_elems(mode) > 1) {
- /* vector arithmetic not implemented yet */
- assert(0);
- return tarval_bad;
- }
+ if (get_mode_n_vector_elems(mode) > 1)
+ panic("vector arithmetic not implemented yet");
- switch(get_mode_sort(mode)) {
+ switch (get_mode_sort(mode)) {
case irms_control_flow:
case irms_memory:
case irms_auxiliary:
- assert(0);
- break;
+ panic("mode %F does not support one value", mode);
case irms_internal_boolean:
return tarval_b_true;
tarval *get_tarval_all_one(ir_mode *mode) {
assert(mode);
- if (get_mode_n_vector_elems(mode) > 1) {
- /* vector arithmetic not implemented yet */
- assert(0);
- return tarval_bad;
- }
+ if (get_mode_n_vector_elems(mode) > 1)
+ panic("vector arithmetic not implemented yet");
- switch(get_mode_sort(mode)) {
+ switch (get_mode_sort(mode)) {
case irms_control_flow:
case irms_memory:
case irms_auxiliary:
- assert(0);
- return tarval_bad;
+ panic("mode %F does not support all-one value", mode);
case irms_int_number:
case irms_internal_boolean:
tarval *get_tarval_minus_one(ir_mode *mode) {
assert(mode);
- if (get_mode_n_vector_elems(mode) > 1) {
- /* vector arithmetic not implemented yet */
- return tarval_bad;
- }
+ if (get_mode_n_vector_elems(mode) > 1)
+ panic("vector arithmetic not implemented yet");
- switch(get_mode_sort(mode)) {
+ switch (get_mode_sort(mode)) {
case irms_control_flow:
case irms_memory:
case irms_auxiliary:
case irms_internal_boolean:
- assert(0);
- break;
+ panic("mode %F does not support minus one value", mode);
case irms_reference:
return tarval_bad;
}
tarval *get_tarval_nan(ir_mode *mode) {
- assert(mode);
+ const ieee_descriptor_t *desc;
- if (get_mode_n_vector_elems(mode) > 1) {
- /* vector arithmetic not implemented yet */
- return tarval_bad;
- }
+ assert(mode);
+ if (get_mode_n_vector_elems(mode) > 1)
+ panic("vector arithmetic not implemented yet");
if (get_mode_sort(mode) == irms_float_number) {
- switch(get_mode_size_bits(mode)) {
- case 32:
- fc_get_qnan(8, 23, NULL);
- break;
- case 64:
- fc_get_qnan(11, 52, NULL);
- break;
- case 80:
- case 96:
- fc_get_qnan(15, 64, NULL);
- break;
- default:
- panic("Unsupported mode in get_tarval_nan()");
- }
+ desc = get_descriptor(mode);
+ fc_get_qnan(desc, NULL);
return get_tarval(fc_get_buffer(), fc_get_buffer_length(), mode);
- } else {
- assert(0 && "tarval is not floating point");
- return tarval_bad;
- }
+ } else
+ panic("mode %F does not support NaN value", mode);
}
tarval *get_tarval_plus_inf(ir_mode *mode) {
assert(mode);
-
- if (get_mode_n_vector_elems(mode) > 1) {
- /* vector arithmetic not implemented yet */
- return tarval_bad;
- }
+ if (get_mode_n_vector_elems(mode) > 1)
+ panic("vector arithmetic not implemented yet");
if (get_mode_sort(mode) == irms_float_number) {
- switch(get_mode_size_bits(mode)) {
- case 32:
- fc_get_plusinf(8, 23, NULL);
- break;
- case 64:
- fc_get_plusinf(11, 52, NULL);
- break;
- case 80:
- case 96:
- fc_get_plusinf(15, 64, NULL);
- break;
- default:
- panic("Unsupported mode in get_tarval_plus_inf()");
- }
+ const ieee_descriptor_t *desc = get_descriptor(mode);
+ fc_get_plusinf(desc, NULL);
return get_tarval(fc_get_buffer(), fc_get_buffer_length(), mode);
- } else {
- assert(0 && "tarval is not floating point");
- return tarval_bad;
- }
+ } else
+ panic("mode %F does not support +inf value", mode);
}
tarval *get_tarval_minus_inf(ir_mode *mode) {
assert(mode);
- if (get_mode_n_vector_elems(mode) > 1) {
- /* vector arithmetic not implemented yet */
- return tarval_bad;
- }
+ if (get_mode_n_vector_elems(mode) > 1)
+ panic("vector arithmetic not implemented yet");
if (get_mode_sort(mode) == irms_float_number) {
- switch(get_mode_size_bits(mode)) {
- case 32:
- fc_get_minusinf(8, 23, NULL);
- break;
- case 64:
- fc_get_minusinf(11, 52, NULL);
- break;
- case 80:
- case 96:
- fc_get_minusinf(15, 64, NULL);
- break;
- default:
- panic("Unsupported mode in get_tarval_minus_inf()");
- }
+ const ieee_descriptor_t *desc = get_descriptor(mode);
+ fc_get_minusinf(desc, NULL);
return get_tarval(fc_get_buffer(), fc_get_buffer_length(), mode);
- } else {
- assert(0 && "tarval is not floating point");
- return tarval_bad;
- }
+ } else
+ panic("mode %F does not support -inf value", mode);
}
/*
- * Arithmethic operations on tarvals ========================================
+ * Arithmetic operations on tarvals ========================================
*/
/*
int tarval_is_negative(tarval *a) {
assert(a);
- if (get_mode_n_vector_elems(a->mode) > 1) {
- /* vector arithmetic not implemented yet */
- assert(0 && "tarval_is_negative is not allowed for vector modes");
- return 0;
- }
+ if (get_mode_n_vector_elems(a->mode) > 1)
+ panic("vector arithmetic not implemented yet");
switch (get_mode_sort(a->mode)) {
case irms_int_number:
return fc_is_negative(a->value);
default:
- assert(0 && "not implemented");
- return 0;
+ panic("mode %F does not support negation value", a->mode);
}
}
assert(b);
if (a == tarval_bad || b == tarval_bad) {
- assert(0 && "Comparison with tarval_bad");
+ panic("Comparison with tarval_bad");
return pn_Cmp_False;
}
* convert to other mode
*/
tarval *tarval_convert_to(tarval *src, ir_mode *dst_mode) {
- char *buffer;
- fp_value *res;
+ char *buffer;
+ fp_value *res;
+ const ieee_descriptor_t *desc;
assert(src);
assert(dst_mode);
case irms_float_number:
switch (get_mode_sort(dst_mode)) {
case irms_float_number:
- switch (get_mode_size_bits(dst_mode)) {
- case 32:
- fc_cast(src->value, 8, 23, NULL);
- break;
- case 64:
- fc_cast(src->value, 11, 52, NULL);
- break;
- case 80:
- case 96:
- fc_cast(src->value, 15, 64, NULL);
- break;
- default:
- panic("Unsupported mode in tarval_convert_to()");
- }
+ desc = get_descriptor(dst_mode);
+ fc_cast(src->value, desc, NULL);
return get_tarval(fc_get_buffer(), fc_get_buffer_length(), dst_mode);
case irms_int_number:
snprintf(buffer, 100, "%s",
sc_print(src->value, get_mode_size_bits(src->mode), SC_DEC, mode_is_signed(src->mode)));
buffer[100 - 1] = '\0';
- switch (get_mode_size_bits(dst_mode)) {
- case 32:
- fc_val_from_str(buffer, 0, 8, 23, NULL);
- break;
- case 64:
- fc_val_from_str(buffer, 0, 11, 52, NULL);
- break;
- case 80:
- case 96:
- fc_val_from_str(buffer, 0, 15, 64, NULL);
- break;
- default:
- panic("Unsupported mode in tarval_convert_to()");
- }
+ desc = get_descriptor(dst_mode);
+ fc_val_from_str(buffer, 0, desc, NULL);
return get_tarval(fc_get_buffer(), fc_get_buffer_length(), dst_mode);
default:
* addition
*/
tarval *tarval_add(tarval *a, tarval *b) {
- tarval *res;
- char *buffer;
- ir_mode *imm_mode, *dst_mode = NULL;
+ char *buffer;
assert(a);
assert(b);
return tarval_bad;
}
- if (mode_is_reference(a->mode)) {
- dst_mode = a->mode;
- imm_mode = find_unsigned_mode(a->mode);
-
- if (imm_mode == NULL)
- return tarval_bad;
-
- a = tarval_convert_to(a, imm_mode);
- b = tarval_convert_to(b, imm_mode);
- }
- if (mode_is_reference(b->mode)) {
- dst_mode = b->mode;
- imm_mode = find_unsigned_mode(b->mode);
-
- if (imm_mode == 0)
- return tarval_bad;
-
- a = tarval_convert_to(a, imm_mode);
- b = tarval_convert_to(b, imm_mode);
+ if (mode_is_reference(a->mode) && a->mode != b->mode) {
+ b = tarval_convert_to(b, a->mode);
+ } else if (mode_is_reference(b->mode) && b->mode != a->mode) {
+ a = tarval_convert_to(a, b->mode);
}
assert(a->mode == b->mode);
switch (get_mode_sort(a->mode)) {
+ case irms_reference:
case irms_int_number:
/* modes of a,b are equal, so result has mode of a as this might be the character */
buffer = alloca(sc_get_buffer_length());
sc_add(a->value, b->value, buffer);
- res = get_tarval_overflow(buffer, a->length, a->mode);
- break;
+ return get_tarval_overflow(buffer, a->length, a->mode);
case irms_float_number:
if (no_float)
return tarval_bad;
fc_add(a->value, b->value, NULL);
- res = get_tarval_overflow(fc_get_buffer(), fc_get_buffer_length(), a->mode);
- break;
+ return get_tarval_overflow(fc_get_buffer(), fc_get_buffer_length(), a->mode);
default:
return tarval_bad;
}
- if (dst_mode != NULL)
- return tarval_convert_to(res, dst_mode);
- return res;
}
/*
}
if (dst_mode != NULL) {
- if (mode_is_reference(a->mode)) {
+ if (a->mode != dst_mode)
a = tarval_convert_to(a, dst_mode);
- }
- if (mode_is_reference(b->mode)) {
+ if (b->mode != dst_mode)
b = tarval_convert_to(b, dst_mode);
- }
- assert(a->mode == dst_mode);
}
assert(a->mode == b->mode);
switch (get_mode_sort(a->mode)) {
+ case irms_reference:
case irms_int_number:
/* modes of a,b are equal, so result has mode of a as this might be the character */
buffer = alloca(sc_get_buffer_length());
/* works even for vector modes */
- switch(get_mode_sort(a->mode)) {
+ switch (get_mode_sort(a->mode)) {
case irms_internal_boolean:
return (a == tarval_b_false) ? a : b;
int i, j, pos = 0;
int n = get_mode_size_bits(tv->mode);
int bytes = (n + 7) / 8;
- char *res = xmalloc((n + 1) * sizeof(char));
+ char *res = XMALLOCN(char, n + 1);
unsigned char byte;
for(i = 0; i < bytes; i++) {
* precision loss.
*/
int tarval_ieee754_can_conv_lossless(tarval *tv, ir_mode *mode) {
- char exp_size, mant_size;
- switch (get_mode_size_bits(mode)) {
- case 32:
- exp_size = 8; mant_size = 23;
- break;
- case 64:
- exp_size = 11; mant_size = 52;
- break;
- case 80:
- case 96:
- exp_size = 15; mant_size = 64;
- break;
- default:
- panic("Unsupported mode in tarval_ieee754_can_conv_lossless()");
- return 0;
- }
- return fc_can_lossless_conv_to(tv->value, exp_size, mant_size);
+ const ieee_descriptor_t *desc = get_descriptor(mode);
+ return fc_can_lossless_conv_to(tv->value, desc);
}
/* Set the immediate precision for IEEE-754 results. */
return fc_is_exact();
}
+/* 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) {
+ const ieee_descriptor_t *desc;
+
+ assert(get_mode_arithmetic(mode) == irma_ieee754);
+ desc = get_descriptor(mode);
+
+ return desc->mantissa_size + desc->explicit_one;
+}
+
/* check if its the a floating point NaN */
int tarval_is_NaN(tarval *tv) {
if (! mode_is_float(tv->mode))
/*
* Initialization of the tarval module: called before init_mode()
*/
-void init_tarval_1(long null_value) {
+void init_tarval_1(long null_value, int support_quad_precision) {
/* if these assertion fail, tarval_is_constant() will follow ... */
assert(tarval_b_false == &reserved_tv[0] && "b_false MUST be the first reserved tarval!");
assert(tarval_b_true == &reserved_tv[1] && "b_true MUST be the second reserved tarval!");
* an initial size, which is the expected number of constants */
tarvals = new_set(cmp_tv, N_CONSTANTS);
values = new_set(memcmp, N_CONSTANTS);
- /* init strcalc with precision of 68 to support floating point values with 64
- * bit mantissa (needs extra bits for rounding and overflow) */
- init_strcalc(68);
- init_fltcalc(0);
+ /* calls init_strcalc() with needed size */
+ init_fltcalc(support_quad_precision ? 112 : 64);
}
/*
projects / libfirm / blobdiff