* @author Martin Trapp, Christian Schaefer, Goetz Lindenmaier, Mathias Heil
* @version $Id$
*/
-#ifdef HAVE_CONFIG_H
-# include "config.h"
-#endif
+#include "config.h"
-#ifdef HAVE_STDLIB_H
-# include <stdlib.h>
-#endif
-#ifdef HAVE_STRING_H
-# include <string.h>
-#endif
+#include <stdlib.h>
+#include <string.h>
-# include <stddef.h>
+#include <stddef.h>
-# include "irprog_t.h"
-# include "irmode_t.h"
-# include "ident.h"
-# include "tv_t.h"
-# include "obst.h"
-# include "irhooks.h"
-# include "irtools.h"
-# include "array.h"
+#include "irprog_t.h"
+#include "irmode_t.h"
+#include "ident.h"
+#include "tv_t.h"
+#include "obst.h"
+#include "irhooks.h"
+#include "irtools.h"
+#include "array.h"
+#include "error.h"
/** Obstack to hold all modes. */
static struct obstack modes;
/** The list of all currently existing modes. */
static ir_mode **mode_list;
+const char *get_mode_arithmetic_name(ir_mode_arithmetic ari)
+{
+#define X(a) case a: return #a
+ switch (ari) {
+ X(irma_uninitialized);
+ X(irma_none);
+ X(irma_twos_complement);
+ X(irma_ones_complement);
+ X(irma_int_BCD);
+ X(irma_ieee754);
+ X(irma_float_BCD);
+ default: return "<unknown>";
+ }
+#undef X
+}
+
/**
* Compare modes that don't need to have their code field
* correctly set
*
* TODO: Add other fields
**/
-static INLINE int modes_are_equal(const ir_mode *m, const ir_mode *n) {
+static inline int modes_are_equal(const ir_mode *m, const ir_mode *n) {
if (m == n) return 1;
if (m->sort == n->sort &&
m->arithmetic == n->arithmetic &&
case irms_control_flow:
case irms_memory:
case irms_internal_boolean:
- assert(0 && "internal modes cannot be user defined");
- break;
+ panic("internal modes cannot be user defined");
case irms_float_number:
case irms_int_number:
case irms_reference:
mode = register_mode(&mode_tmpl);
+ break;
}
+ assert(mode != NULL);
return mode;
}
case irms_control_flow:
case irms_memory:
case irms_internal_boolean:
- assert(0 && "internal modes cannot be user defined");
- break;
+ panic("internal modes cannot be user defined");
case irms_reference:
- assert(0 && "only integer and floating point modes can be vectorized");
- break;
+ panic("only integer and floating point modes can be vectorized");
case irms_float_number:
- assert(0 && "not yet implemented");
- break;
+ panic("not yet implemented");
case irms_int_number:
mode = register_mode(&mode_tmpl);
}
+ assert(mode != NULL);
return mode;
}
return get_tarval_nan(mode);
}
-int is_mode(void *thing) {
+int is_mode(const void *thing) {
if (get_kind(thing) == k_ir_mode)
return 1;
else
/* Returns true if sm can be converted to lm without loss. */
int smaller_mode(const ir_mode *sm, const ir_mode *lm) {
int sm_bits, lm_bits;
+
+ assert(sm);
+ assert(lm);
+
+ if (sm == lm) return 1;
+
+ sm_bits = get_mode_size_bits(sm);
+ lm_bits = get_mode_size_bits(lm);
+
+ switch (get_mode_sort(sm)) {
+ case irms_int_number:
+ switch (get_mode_sort(lm)) {
+ case irms_int_number:
+ if (get_mode_arithmetic(sm) != get_mode_arithmetic(lm))
+ return 0;
+
+ /* only two complement implemented */
+ assert(get_mode_arithmetic(sm) == irma_twos_complement);
+
+ /* integers are convertable if
+ * - both have the same sign and lm is the larger one
+ * - lm is the signed one and is at least two bits larger
+ * (one for the sign, one for the highest bit of sm)
+ * - sm & lm are two_complement and lm has greater or equal number of bits
+ */
+ if (mode_is_signed(sm)) {
+ if (!mode_is_signed(lm))
+ return 0;
+ return sm_bits <= lm_bits;
+ } else {
+ if (mode_is_signed(lm)) {
+ return sm_bits < lm_bits;
+ }
+ return sm_bits <= lm_bits;
+ }
+ break;
+
+ case irms_float_number:
+ /* int to float works if the float is large enough */
+ return 0;
+
+ default:
+ break;
+ }
+ break;
+
+ case irms_float_number:
+ if (get_mode_arithmetic(sm) == get_mode_arithmetic(lm)) {
+ if ( (get_mode_sort(lm) == irms_float_number)
+ && (get_mode_size_bits(lm) >= get_mode_size_bits(sm)) )
+ return 1;
+ }
+ break;
+
+ case irms_reference:
+ /* do exist machines out there with different pointer lenghts ?*/
+ return 0;
+
+ case irms_internal_boolean:
+ return mode_is_int(lm);
+
+ default:
+ break;
+ }
+
+ /* else */
+ return 0;
+}
+
+/* Returns true if a value of mode sm can be converted into mode lm
+ and backwards without loss. */
+int values_in_mode(const ir_mode *sm, const ir_mode *lm) {
+ int sm_bits, lm_bits;
ir_mode_arithmetic arith;
assert(sm);
newmode.name = new_id_from_chars("E", 1);
newmode.code = irm_E;
newmode.sign = 1;
- newmode.size = 80;
+ /* note that the tarval module is calculating with 80 bits, but we use
+ * 96 bits, as that is what will be stored to memory by most hardware */
+ newmode.size = 96;
mode_E = register_mode(&newmode);