#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
****************************************************************************/
if (!FIND_TARVAL(tv)) fail_verify(tv);
if (tv->length > 0 && !FIND_VALUE(tv->value, tv->length)) fail_verify(tv);
-
- return;
}
#endif /* NDEBUG */
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);
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:
}
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:
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:
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:
return tarval_bad;
}
- switch(get_mode_sort(mode)) {
+ switch (get_mode_sort(mode)) {
case irms_control_flow:
case irms_memory:
case irms_auxiliary:
return tarval_bad;
}
- switch(get_mode_sort(mode)) {
+ switch (get_mode_sort(mode)) {
case irms_control_flow:
case irms_memory:
case irms_auxiliary:
return tarval_bad;
}
- switch(get_mode_sort(mode)) {
+ switch (get_mode_sort(mode)) {
case irms_control_flow:
case irms_memory:
case irms_auxiliary:
}
tarval *get_tarval_nan(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;
}
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");
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_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");
}
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");
* 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:
tarval *tarval_add(tarval *a, tarval *b) {
tarval *res;
char *buffer;
- ir_mode *dst_mode, *src_mode = NULL;
+ ir_mode *imm_mode, *dst_mode = NULL;
assert(a);
assert(b);
}
if (mode_is_reference(a->mode)) {
- src_mode = a->mode;
- dst_mode = find_unsigned_mode(a->mode);
+ dst_mode = a->mode;
+ imm_mode = find_unsigned_mode(a->mode);
- if (dst_mode == NULL)
+ if (imm_mode == NULL)
return tarval_bad;
- a = tarval_convert_to(a, dst_mode);
- b = tarval_convert_to(b, dst_mode);
+ a = tarval_convert_to(a, imm_mode);
+ b = tarval_convert_to(b, imm_mode);
}
if (mode_is_reference(b->mode)) {
- src_mode = b->mode;
- dst_mode = find_unsigned_mode(b->mode);
+ dst_mode = b->mode;
+ imm_mode = find_unsigned_mode(b->mode);
- if (dst_mode == 0)
+ if (imm_mode == 0)
return tarval_bad;
- a = tarval_convert_to(a, dst_mode);
- b = tarval_convert_to(b, dst_mode);
+ a = tarval_convert_to(a, imm_mode);
+ b = tarval_convert_to(b, imm_mode);
}
assert(a->mode == b->mode);
default:
return tarval_bad;
}
- if (src_mode != NULL)
- return tarval_convert_to(res, src_mode);
+ if (dst_mode != NULL)
+ return tarval_convert_to(res, dst_mode);
return res;
}
/*
* subtraction
*/
-tarval *tarval_sub(tarval *a, tarval *b) {
- tarval *res;
+tarval *tarval_sub(tarval *a, tarval *b, ir_mode *dst_mode) {
char *buffer;
- ir_mode *dst_mode, *src_mode = NULL;
assert(a);
assert(b);
/* vector arithmetic not implemented yet */
return tarval_bad;
}
- if (mode_is_reference(a->mode)) {
- src_mode = a->mode;
- dst_mode = find_unsigned_mode(a->mode);
-
- if (dst_mode == NULL)
- return tarval_bad;
-
- a = tarval_convert_to(a, dst_mode);
- b = tarval_convert_to(b, dst_mode);
- }
- if (mode_is_reference(b->mode)) {
- src_mode = b->mode;
- dst_mode = find_unsigned_mode(b->mode);
- if (dst_mode == 0)
- return tarval_bad;
-
- a = tarval_convert_to(a, dst_mode);
- b = tarval_convert_to(b, dst_mode);
+ if (dst_mode != NULL) {
+ if (mode_is_reference(a->mode)) {
+ a = tarval_convert_to(a, dst_mode);
+ }
+ if (mode_is_reference(b->mode)) {
+ b = tarval_convert_to(b, dst_mode);
+ }
+ assert(a->mode == dst_mode);
}
-
assert(a->mode == b->mode);
switch (get_mode_sort(a->mode)) {
/* 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_sub(a->value, b->value, buffer);
- res = get_tarval_overflow(buffer, a->length, a->mode);
+ return get_tarval_overflow(buffer, a->length, a->mode);
case irms_float_number:
if (no_float)
return tarval_bad;
fc_sub(a->value, b->value, NULL);
- res = get_tarval_overflow(fc_get_buffer(), fc_get_buffer_length(), a->mode);
+ return get_tarval_overflow(fc_get_buffer(), fc_get_buffer_length(), a->mode);
default:
return tarval_bad;
}
- if (src_mode != NULL)
- return tarval_convert_to(res, src_mode);
- return res;
}
/*
/* 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;
* 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. */
/*
* 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