X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;ds=sidebyside;f=ir%2Ftv%2Ftv.c;h=f13d52c851728c37407dcda1066d7628c7458e48;hb=a286e7dcdb4c41b2165c64fc85ed9eb021c08bc0;hp=2daab3ace6602a30b4e2a0a4dd730490951fe152;hpb=8cc52245e109070a5e9094803f74cc6432a44b1a;p=libfirm

diff --git a/ir/tv/tv.c b/ir/tv/tv.c
index 2daab3ace..f13d52c85 100644
--- a/ir/tv/tv.c
+++ b/ir/tv/tv.c
@@ -168,7 +168,12 @@ static tarval *get_tarval(const void *value, int length, ir_mode *mode) {
 	if (length > 0) {
 		/* if there already is such a value, it is returned, else value
 		 * is copied into the set */
-		tv.value = INSERT_VALUE(value, length);
+		char *temp = alloca(length);
+		memcpy(temp, value, length);
+		if (get_mode_arithmetic(mode) == irma_twos_complement) {
+			sign_extend(temp, mode);
+		}
+		tv.value = INSERT_VALUE(temp, length);
 	} else {
 		tv.value = value;
 	}
@@ -182,21 +187,30 @@ static tarval *get_tarval(const void *value, int length, ir_mode *mode) {
  */
 static tarval *get_tarval_overflow(const void *value, int length, ir_mode *mode)
 {
+	char *temp;
+
 	switch (get_mode_sort(mode)) {
+	case irms_reference:
+		/* addresses always wrap around */
+		temp = alloca(sc_get_buffer_length());
+		sc_val_from_ulong(-1, temp);
+		sc_and(temp, value, temp);
+		/* the sc_ module expects that all bits are set ... */
+		sign_extend(temp, mode);
+		return get_tarval(temp, length, mode);
+
 	case irms_int_number:
 		if (sc_comp(value, get_mode_max(mode)->value) == 1) {
 			switch (GET_OVERFLOW_MODE()) {
 			case TV_OVERFLOW_SATURATE:
 				return get_mode_max(mode);
 			case TV_OVERFLOW_WRAP:
-				{
-					char *temp = alloca(sc_get_buffer_length());
-					sc_val_from_ulong(-1, temp);
-					sc_and(temp, value, temp);
-					/* the sc_ module expects that all bits are set ... */
-					sign_extend(temp, mode);
-					return get_tarval(temp, length, mode);
-				}
+				temp = alloca(sc_get_buffer_length());
+				sc_val_from_ulong(-1, temp);
+				sc_and(temp, value, temp);
+				/* the sc_ module expects that all bits are set ... */
+				sign_extend(temp, mode);
+				return get_tarval(temp, length, mode);
 			case TV_OVERFLOW_BAD:
 				return tarval_bad;
 			default:
@@ -306,7 +320,7 @@ tarval *new_tarval_from_str(const char *str, size_t len, ir_mode *mode)
 tarval *new_tarval_from_long(long l, ir_mode *mode) {
 	assert(mode);
 
-	switch(get_mode_sort(mode))   {
+	switch (get_mode_sort(mode))   {
 	case irms_internal_boolean:
 		/* XXX C semantics ! */
 		return l ? tarval_b_true : tarval_b_false ;
@@ -424,7 +438,6 @@ tarval *get_tarval_max(ir_mode *mode) {
 	}
 
 	switch(get_mode_sort(mode)) {
-	case irms_reference:
 	case irms_control_flow:
 	case irms_memory:
 	case irms_auxiliary:
@@ -448,9 +461,10 @@ tarval *get_tarval_max(ir_mode *mode) {
 		}
 		return get_tarval(fc_get_buffer(), fc_get_buffer_length(), mode);
 
-		case irms_int_number:
-			sc_max_from_bits(get_mode_size_bits(mode), mode_is_signed(mode), NULL);
-			return get_tarval(sc_get_buffer(), sc_get_buffer_length(), mode);
+	case irms_reference:
+	case irms_int_number:
+		sc_max_from_bits(get_mode_size_bits(mode), mode_is_signed(mode), NULL);
+		return get_tarval(sc_get_buffer(), sc_get_buffer_length(), mode);
 	}
 	return tarval_bad;
 }
@@ -464,7 +478,6 @@ tarval *get_tarval_min(ir_mode *mode) {
 	}
 
 	switch(get_mode_sort(mode)) {
-	case irms_reference:
 	case irms_control_flow:
 	case irms_memory:
 	case irms_auxiliary:
@@ -488,15 +501,16 @@ tarval *get_tarval_min(ir_mode *mode) {
 		}
 		return get_tarval(fc_get_buffer(), fc_get_buffer_length(), mode);
 
-		case irms_int_number:
-			sc_min_from_bits(get_mode_size_bits(mode), mode_is_signed(mode), NULL);
-			return get_tarval(sc_get_buffer(), sc_get_buffer_length(), mode);
+	case irms_reference:
+	case irms_int_number:
+		sc_min_from_bits(get_mode_size_bits(mode), mode_is_signed(mode), NULL);
+		return get_tarval(sc_get_buffer(), sc_get_buffer_length(), mode);
 	}
 	return tarval_bad;
 }
 
 /** The bit pattern for the pointer NULL */
-static long _null_value;
+static long _null_value = 0;
 
 tarval *get_tarval_null(ir_mode *mode) {
 	assert(mode);
@@ -531,6 +545,7 @@ tarval *get_tarval_one(ir_mode *mode) {
 
 	if (get_mode_n_vector_elems(mode) > 1) {
 		/* vector arithmetic not implemented yet */
+		assert(0);
 		return tarval_bad;
 	}
 
@@ -538,26 +553,28 @@ tarval *get_tarval_one(ir_mode *mode) {
 	case irms_control_flow:
 	case irms_memory:
 	case irms_auxiliary:
-	case irms_internal_boolean:
-	case irms_reference:
 		assert(0);
 		break;
 
+	case irms_internal_boolean:
+		return tarval_b_true;
+
 	case irms_float_number:
 		return new_tarval_from_double(1.0, mode);
 
+	case irms_reference:
 	case irms_int_number:
 		return new_tarval_from_long(1l, mode);
-		break;
 	}
 	return tarval_bad;
 }
 
-tarval *get_tarval_minus_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;
 	}
 
@@ -565,16 +582,45 @@ tarval *get_tarval_minus_one(ir_mode *mode) {
 	case irms_control_flow:
 	case irms_memory:
 	case irms_auxiliary:
+		assert(0);
+		return tarval_bad;
+
+	case irms_int_number:
 	case irms_internal_boolean:
 	case irms_reference:
+		return tarval_not(get_mode_null(mode));
+
+
+	case irms_float_number:
+		return new_tarval_from_double(1.0, mode);
+	}
+	return tarval_bad;
+}
+
+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;
+	}
+
+	switch(get_mode_sort(mode)) {
+	case irms_control_flow:
+	case irms_memory:
+	case irms_auxiliary:
+	case irms_internal_boolean:
 		assert(0);
 		break;
 
+	case irms_reference:
+		return tarval_bad;
+
 	case irms_float_number:
 		return mode_is_signed(mode) ? new_tarval_from_double(-1.0, mode) : tarval_bad;
 
 	case irms_int_number:
-		return mode_is_signed(mode) ? new_tarval_from_long(-1l, mode) : tarval_bad;
+		return new_tarval_from_long(-1l, mode);
 	}
 	return tarval_bad;
 }
@@ -695,18 +741,24 @@ int tarval_is_negative(tarval *a) {
  * test if null, 1 means 'yes'
  */
 int tarval_is_null(tarval *a) {
-	ir_mode *m = get_tarval_mode(a);
-
-	return a == get_tarval_null(m);
+	return
+		a != tarval_bad &&
+		a == get_tarval_null(get_tarval_mode(a));
 }
 
 /*
  * test if one, 1 means 'yes'
  */
 int tarval_is_one(tarval *a) {
-	ir_mode *m = get_tarval_mode(a);
+	return
+		a != tarval_bad &&
+		a == get_tarval_one(get_tarval_mode(a));
+}
 
-	return a == get_tarval_one(m);
+int tarval_is_all_one(tarval *tv) {
+	return
+		tv != tarval_bad &&
+		tv == get_mode_all_one(get_tarval_mode(tv));
 }
 
 /*
@@ -737,7 +789,6 @@ pn_Cmp tarval_cmp(tarval *a, tarval *b) {
 	case irms_control_flow:
 	case irms_memory:
 	case irms_auxiliary:
-	case irms_reference:
 		if (a == b)
 			return pn_Cmp_Eq;
 		return pn_Cmp_False;
@@ -756,6 +807,7 @@ pn_Cmp tarval_cmp(tarval *a, tarval *b) {
 		case  2: return pn_Cmp_Uo;
 		default: return pn_Cmp_False;
 		}
+	case irms_reference:
 	case irms_int_number:
 		if (a == b)
 			return pn_Cmp_Eq;
@@ -772,13 +824,14 @@ pn_Cmp tarval_cmp(tarval *a, tarval *b) {
 /*
  * convert to other mode
  */
-tarval *tarval_convert_to(tarval *src, ir_mode *m) {
+tarval *tarval_convert_to(tarval *src, ir_mode *dst_mode) {
 	char *buffer;
+	fp_value *res;
 
 	assert(src);
-	assert(m);
+	assert(dst_mode);
 
-	if (src->mode == m) return src;
+	if (src->mode == dst_mode) return src;
 
 	if (get_mode_n_vector_elems(src->mode) > 1) {
 		/* vector arithmetic not implemented yet */
@@ -793,9 +846,9 @@ tarval *tarval_convert_to(tarval *src, ir_mode *m) {
 
 		/* cast float to something */
 	case irms_float_number:
-		switch (get_mode_sort(m)) {
+		switch (get_mode_sort(dst_mode)) {
 		case irms_float_number:
-			switch (get_mode_size_bits(m)) {
+			switch (get_mode_size_bits(dst_mode)) {
 			case 32:
 				fc_cast(src->value, 8, 23, NULL);
 				break;
@@ -808,25 +861,23 @@ tarval *tarval_convert_to(tarval *src, ir_mode *m) {
 			default:
 				break;
 			}
-			return get_tarval(fc_get_buffer(), fc_get_buffer_length(), m);
+			return get_tarval(fc_get_buffer(), fc_get_buffer_length(), dst_mode);
 
 		case irms_int_number:
 			switch (GET_FLOAT_TO_INT_MODE()) {
 			case TRUNCATE:
-				fc_int(src->value, NULL);
+				res = fc_int(src->value, NULL);
 				break;
 			case ROUND:
-				fc_rnd(src->value, NULL);
+				res = fc_rnd(src->value, NULL);
 				break;
 			default:
 				assert(0);
 				break;
 			}
-			/* FIXME: floating point unit can't produce a value in integer
-			 * representation
-			 * an intermediate representation is needed here first. */
-			/*  return get_tarval(); */
-			return tarval_bad;
+			if (! fc_flt2int(res, sc_get_buffer(), dst_mode))
+				return tarval_bad;
+			return get_tarval(sc_get_buffer(), sc_get_buffer_length(), dst_mode);
 
 		default:
 			/* the rest can't be converted */
@@ -836,12 +887,14 @@ tarval *tarval_convert_to(tarval *src, ir_mode *m) {
 
 	/* cast int/characters to something */
 	case irms_int_number:
-		switch (get_mode_sort(m)) {
+		switch (get_mode_sort(dst_mode)) {
+
+		case irms_reference:
 		case irms_int_number:
 			buffer = alloca(sc_get_buffer_length());
 			memcpy(buffer, src->value, sc_get_buffer_length());
-			sign_extend(buffer, m);
-			return get_tarval_overflow(buffer, src->length, m);
+			sign_extend(buffer, dst_mode);
+			return get_tarval_overflow(buffer, src->length, dst_mode);
 
 		case irms_internal_boolean:
 			/* XXX C semantics */
@@ -858,7 +911,7 @@ tarval *tarval_convert_to(tarval *src, ir_mode *m) {
 			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(m)) {
+			switch (get_mode_size_bits(dst_mode)) {
 			case 32:
 				fc_val_from_str(buffer, 0, 8, 23, NULL);
 				break;
@@ -869,13 +922,7 @@ tarval *tarval_convert_to(tarval *src, ir_mode *m) {
 				fc_val_from_str(buffer, 0, 15, 64, NULL);
 				break;
 			}
-			return get_tarval(fc_get_buffer(), fc_get_buffer_length(), m);
-
-		case irms_reference:
-			/* allow 0 to be casted */
-			if (src == get_mode_null(src->mode))
-				return get_mode_null(m);
-			break;
+			return get_tarval(fc_get_buffer(), fc_get_buffer_length(), dst_mode);
 
 		default:
 			break;
@@ -883,27 +930,18 @@ tarval *tarval_convert_to(tarval *src, ir_mode *m) {
 		break;
 
 	case irms_internal_boolean:
-		switch (get_mode_sort(m)) {
-		case irms_int_number:
-			if (src == tarval_b_true) return get_mode_one(m);
-			else return get_mode_null(m);
-
-		default:
-			break;
-		}
+		/* beware: this is C semantic for the INTERNAL boolean mode */
+		if (get_mode_sort(dst_mode) == irms_int_number)
+			return src == tarval_b_true ? get_mode_one(dst_mode) : get_mode_null(dst_mode);
 		break;
 
 	case irms_reference:
-		switch(get_mode_sort(m)) {
-		case irms_int_number:
+		if (get_mode_sort(dst_mode) == irms_int_number) {
 			buffer = alloca(sc_get_buffer_length());
 			memcpy(buffer, src->value, sc_get_buffer_length());
 			sign_extend(buffer, src->mode);
-			return get_tarval_overflow(buffer, src->length, m);
-		default:
-			break;
+			return get_tarval_overflow(buffer, src->length, dst_mode);
 		}
-
 		break;
 	}
 
@@ -921,6 +959,7 @@ tarval *tarval_not(tarval *a) {
 	/* works for vector mode without changes */
 
 	switch (get_mode_sort(a->mode)) {
+	case irms_reference:
 	case irms_int_number:
 		buffer = alloca(sc_get_buffer_length());
 		sc_not(a->value, buffer);
@@ -1136,6 +1175,33 @@ tarval *tarval_mod(tarval *a, tarval *b) {
 	return get_tarval(sc_get_buffer(), sc_get_buffer_length(), a->mode);
 }
 
+/*
+ * integer division AND remainder
+ * overflow is impossible, but look out for division by zero
+ */
+tarval *tarval_divmod(tarval *a, tarval *b, tarval **mod) {
+	int len = sc_get_buffer_length();
+	char *div_res = alloca(len);
+	char *mod_res = alloca(len);
+
+	assert(a);
+	assert(b);
+	assert((a->mode == b->mode) && mode_is_int(a->mode));
+
+	if (get_mode_n_vector_elems(a->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_divmod(a->value, b->value, div_res, mod_res);
+	*mod = get_tarval(mod_res, len, a->mode);
+	return get_tarval(div_res, len, a->mode);
+}
+
 /*
  * absolute value
  */
@@ -1478,7 +1544,7 @@ char *get_tarval_bitpattern(tarval *tv) {
 unsigned char get_tarval_sub_bits(tarval *tv, unsigned byte_ofs) {
 	switch (get_mode_arithmetic(tv->mode)) {
 	case irma_twos_complement:
-		return sc_sub_bits(tv->value, tv->length, byte_ofs);
+		return sc_sub_bits(tv->value, get_mode_size_bits(tv->mode), byte_ofs);
 	case irma_ieee754:
 		return fc_sub_bits(tv->value, get_mode_size_bits(tv->mode), byte_ofs);
 	default:
@@ -1511,29 +1577,6 @@ const tarval_mode_info *get_tarval_mode_output_option(ir_mode *mode) {
 	return mode->tv_priv;
 }
 
-/*
- * Identifying tarvals values for algebraic simplifications.
- *
- * Returns:
- *   - TV_CLASSIFY_NULL    for additive neutral or the NULL tarval for reference modes,
- *   - TV_CLASSIFY_ONE     for multiplicative neutral,
- *   - TV_CLASSIFY_ALL_ONE for bitwise-and neutral
- *   - TV_CLASSIFY_OTHER   else
- */
-tarval_classification_t classify_tarval(tarval *tv) {
-	if (!tv || tv == tarval_bad) return TV_CLASSIFY_OTHER;
-
-	if (tv == get_mode_null(tv->mode))
-		return TV_CLASSIFY_NULL;
-	else if (tv == get_mode_one(tv->mode))
-		return TV_CLASSIFY_ONE;
-	else if ((get_mode_sort(tv->mode) == irms_int_number)
-		&& (tv == new_tarval_from_long(-1, tv->mode)))
-		return TV_CLASSIFY_ALL_ONE;
-
-	return TV_CLASSIFY_OTHER;
-}
-
 /*
  * Returns non-zero if a given (integer) tarval has only one single bit
  * set.