Make fehler159 compilable.

[libfirm] / ir / tv / tv.c

diff --git a/ir/tv/tv.c b/ir/tv/tv.c
index b6f4b66..e0b51c1 100644 (file)
--- a/ir/tv/tv.c
+++ b/ir/tv/tv.c
@@ -127,10 +127,9 @@ static void _fail_verify(tarval *tv, const char* file, int line)
 {
        /* 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));
@@ -335,8 +334,7 @@ tarval *new_tarval_from_str(const char *str, size_t len, ir_mode *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] */
@@ -359,9 +357,7 @@ tarval *new_tarval_from_str(const char *str, size_t len, ir_mode *mode)
                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);
 }
 
 /*
@@ -492,8 +488,7 @@ tarval *get_tarval_max(ir_mode *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;
@@ -524,8 +519,7 @@ tarval *get_tarval_min(ir_mode *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;
@@ -558,8 +552,7 @@ tarval *get_tarval_null(ir_mode *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);
@@ -577,18 +570,14 @@ tarval *get_tarval_null(ir_mode *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)) {
        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;
@@ -606,18 +595,14 @@ tarval *get_tarval_one(ir_mode *mode) {
 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)) {
        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:
@@ -642,18 +627,15 @@ int tarval_is_constant(tarval *tv) {
 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)) {
        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;
@@ -671,58 +653,46 @@ tarval *get_tarval_nan(ir_mode *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_n_vector_elems(mode) > 1)
+               panic("vector arithmetic not implemented yet");
 
        if (get_mode_sort(mode) == irms_float_number) {
                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) {
                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) {
                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 ========================================
  */
 
 /*
@@ -731,11 +701,8 @@ tarval *get_tarval_minus_inf(ir_mode *mode) {
 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:
@@ -747,8 +714,7 @@ int tarval_is_negative(tarval *a) {
                return fc_is_negative(a->value);
 
        default:
-               assert(0 && "not implemented");
-               return 0;
+               panic("mode %F does not support negation value", a->mode);
        }
 }
 
@@ -793,7 +759,7 @@ pn_Cmp tarval_cmp(tarval *a, tarval *b) {
        assert(b);
 
        if (a == tarval_bad || b == tarval_bad) {
-               assert(0 && "Comparison with tarval_bad");
+               panic("Comparison with tarval_bad");
                return pn_Cmp_False;
        }
 
@@ -1025,9 +991,7 @@ tarval *tarval_neg(tarval *a) {
  * 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);
@@ -1037,51 +1001,32 @@ tarval *tarval_add(tarval *a, tarval *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;
 }
 
 /*
@@ -1099,17 +1044,15 @@ tarval *tarval_sub(tarval *a, tarval *b, ir_mode *dst_mode) {
        }
 
        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());
@@ -1582,7 +1525,7 @@ char *get_tarval_bitpattern(tarval *tv) {
        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++) {