* @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;
-/** Number of defined modes. */
-static int num_modes = 0;
-
/** 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 &&
ARR_APP1(ir_mode*, mode_list, mode);
mode->kind = k_ir_mode;
- if (num_modes >= irm_max) {
- mode->code = num_modes;
- }
- num_modes++;
+ mode->type = new_type_primitive(mode);
/* add the new mode to the irp list of modes */
add_irp_mode(mode);
mode_tmpl.sort = sort;
mode_tmpl.size = bit_size;
mode_tmpl.sign = sign ? 1 : 0;
- mode_tmpl.modulo_shift = (mode_tmpl.sort == irms_int_number) ? modulo_shift : 0;
+ mode_tmpl.modulo_shift = (mode_tmpl.sort == irms_int_number ||
+ mode_tmpl.sort == irms_reference) ? modulo_shift : 0;
mode_tmpl.vector_elem = 1;
mode_tmpl.arithmetic = arithmetic;
mode_tmpl.link = NULL;
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;
}
/* Functions for the direct access to all attributes of an ir_mode */
-ir_modecode (get_mode_modecode)(const ir_mode *mode) {
- return _get_mode_modecode(mode);
-}
-
ident *(get_mode_ident)(const ir_mode *mode) {
return _get_mode_ident(mode);
}
tarval *get_mode_min(ir_mode *mode) {
assert(mode);
- assert(get_mode_modecode(mode) < (ir_modecode) num_modes);
assert(mode_is_data(mode));
return mode->min;
tarval *get_mode_max(ir_mode *mode) {
assert(mode);
- assert(get_mode_modecode(mode) < (ir_modecode) num_modes);
assert(mode_is_data(mode));
return mode->max;
tarval *get_mode_null(ir_mode *mode) {
assert(mode);
- assert(get_mode_modecode(mode) < (ir_modecode) num_modes);
assert(mode_is_datab(mode));
return mode->null;
tarval *get_mode_one(ir_mode *mode) {
assert(mode);
- assert(get_mode_modecode(mode) < (ir_modecode) num_modes);
assert(mode_is_datab(mode));
return mode->one;
tarval *get_mode_minus_one(ir_mode *mode) {
assert(mode);
- assert(get_mode_modecode(mode) < (ir_modecode) num_modes);
assert(mode_is_data(mode));
return mode->minus_one;
tarval *get_mode_all_one(ir_mode *mode) {
assert(mode);
- assert(get_mode_modecode(mode) < (ir_modecode) num_modes);
assert(mode_is_datab(mode));
return mode->all_one;
}
tarval *get_mode_infinite(ir_mode *mode) {
assert(mode);
- assert(get_mode_modecode(mode) < (ir_modecode) num_modes);
assert(mode_is_float(mode));
return get_tarval_plus_inf(mode);
tarval *get_mode_NAN(ir_mode *mode) {
assert(mode);
- assert(get_mode_modecode(mode) < (ir_modecode) num_modes);
assert(mode_is_float(mode));
return get_tarval_nan(mode);
}
-int is_mode(void *thing) {
- if (get_kind(thing) == k_ir_mode)
- return 1;
- else
- return 0;
+int is_mode(const void *thing) {
+ return get_kind(thing) == k_ir_mode;
}
int (mode_is_signed)(const ir_mode *mode) {
break;
case irms_reference:
- /* do exist machines out there with different pointer lenghts ?*/
+ /* do exist machines out there with different pointer lengths ?*/
return 0;
case irms_internal_boolean:
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);
+ assert(lm);
+
+ if (sm == lm) return 1;
+
+ if (sm == mode_b)
+ return mode_is_int(lm);
+
+ sm_bits = get_mode_size_bits(sm);
+ lm_bits = get_mode_size_bits(lm);
+
+ arith = get_mode_arithmetic(sm);
+ if (arith != get_mode_arithmetic(lm))
+ return 0;
+
+ switch (arith) {
+ case irma_twos_complement:
+ case irma_ieee754:
+ return get_mode_size_bits(sm) <= get_mode_size_bits(lm);
+
+ default:
+ return 0;
+ }
+}
+
/* Return the signed integer equivalent mode for an reference mode. */
ir_mode *get_reference_mode_signed_eq(ir_mode *mode) {
assert(mode_is_reference(mode));
obstack_init(&modes);
mode_list = NEW_ARR_F(ir_mode*, 0);
- num_modes = 0;
/* initialize predefined modes */
/* Internal Modes */
/* Basic Block */
newmode.name = new_id_from_chars("BB", 2);
- newmode.code = irm_BB;
-
- mode_BB = register_mode(&newmode);
+ mode_BB = register_mode(&newmode);
/* eXecution */
newmode.name = new_id_from_chars("X", 1);
- newmode.code = irm_X;
-
- mode_X = register_mode(&newmode);
+ mode_X = register_mode(&newmode);
/* Memory Modes */
newmode.sort = irms_memory;
/* Memory */
newmode.name = new_id_from_chars("M", 1);
- newmode.code = irm_M;
-
- mode_M = register_mode(&newmode);
+ mode_M = register_mode(&newmode);
/* Auxiliary Modes */
newmode.sort = irms_auxiliary,
/* Tuple */
newmode.name = new_id_from_chars("T", 1);
- newmode.code = irm_T;
-
- mode_T = register_mode(&newmode);
+ mode_T = register_mode(&newmode);
/* ANY */
newmode.name = new_id_from_chars("ANY", 3);
- newmode.code = irm_ANY;
-
- mode_ANY = register_mode(&newmode);
+ mode_ANY = register_mode(&newmode);
/* BAD */
newmode.name = new_id_from_chars("BAD", 3);
- newmode.code = irm_BAD;
-
- mode_BAD = register_mode(&newmode);
+ mode_BAD = register_mode(&newmode);
/* Internal Boolean Modes */
newmode.sort = irms_internal_boolean;
/* boolean */
newmode.name = new_id_from_chars("b", 1);
- newmode.code = irm_b;
-
- mode_b = register_mode(&newmode);
+ mode_b = register_mode(&newmode);
/* Data Modes */
newmode.vector_elem = 1;
/* float */
newmode.name = new_id_from_chars("F", 1);
- newmode.code = irm_F;
newmode.sign = 1;
newmode.size = 32;
-
- mode_F = register_mode(&newmode);
+ mode_F = register_mode(&newmode);
/* double */
newmode.name = new_id_from_chars("D", 1);
- newmode.code = irm_D;
newmode.sign = 1;
newmode.size = 64;
-
- mode_D = register_mode(&newmode);
+ mode_D = register_mode(&newmode);
/* extended */
newmode.name = new_id_from_chars("E", 1);
- newmode.code = irm_E;
newmode.sign = 1;
- newmode.size = 80;
-
- mode_E = register_mode(&newmode);
+ /* 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);
/* Integer Number Modes */
newmode.sort = irms_int_number;
/* signed byte */
newmode.name = new_id_from_chars("Bs", 2);
- newmode.code = irm_Bs;
newmode.sign = 1;
newmode.size = 8;
newmode.modulo_shift = 32;
-
- mode_Bs = register_mode(&newmode);
+ mode_Bs = register_mode(&newmode);
/* unsigned byte */
newmode.name = new_id_from_chars("Bu", 2);
- newmode.code = irm_Bu;
newmode.arithmetic = irma_twos_complement;
newmode.sign = 0;
newmode.size = 8;
newmode.modulo_shift = 32;
-
- mode_Bu = register_mode(&newmode);
+ mode_Bu = register_mode(&newmode);
/* signed short integer */
newmode.name = new_id_from_chars("Hs", 2);
- newmode.code = irm_Hs;
newmode.sign = 1;
newmode.size = 16;
newmode.modulo_shift = 32;
-
- mode_Hs = register_mode(&newmode);
+ mode_Hs = register_mode(&newmode);
/* unsigned short integer */
newmode.name = new_id_from_chars("Hu", 2);
- newmode.code = irm_Hu;
newmode.sign = 0;
newmode.size = 16;
newmode.modulo_shift = 32;
-
- mode_Hu = register_mode(&newmode);
+ mode_Hu = register_mode(&newmode);
/* signed integer */
newmode.name = new_id_from_chars("Is", 2);
- newmode.code = irm_Is;
newmode.sign = 1;
newmode.size = 32;
newmode.modulo_shift = 32;
-
- mode_Is = register_mode(&newmode);
+ mode_Is = register_mode(&newmode);
/* unsigned integer */
newmode.name = new_id_from_chars("Iu", 2);
- newmode.code = irm_Iu;
newmode.sign = 0;
newmode.size = 32;
newmode.modulo_shift = 32;
-
- mode_Iu = register_mode(&newmode);
+ mode_Iu = register_mode(&newmode);
/* signed long integer */
newmode.name = new_id_from_chars("Ls", 2);
- newmode.code = irm_Ls;
newmode.sign = 1;
newmode.size = 64;
newmode.modulo_shift = 64;
-
- mode_Ls = register_mode(&newmode);
+ mode_Ls = register_mode(&newmode);
/* unsigned long integer */
newmode.name = new_id_from_chars("Lu", 2);
- newmode.code = irm_Lu;
newmode.sign = 0;
newmode.size = 64;
newmode.modulo_shift = 64;
-
- mode_Lu = register_mode(&newmode);
+ mode_Lu = register_mode(&newmode);
/* signed long long integer */
newmode.name = new_id_from_chars("LLs", 3);
- newmode.code = irm_LLs;
newmode.sign = 1;
newmode.size = 128;
newmode.modulo_shift = 128;
-
- mode_LLs = register_mode(&newmode);
+ mode_LLs = register_mode(&newmode);
/* unsigned long long integer */
newmode.name = new_id_from_chars("LLu", 3);
- newmode.code = irm_LLu;
newmode.sign = 0;
newmode.size = 128;
newmode.modulo_shift = 128;
-
- mode_LLu = register_mode(&newmode);
+ mode_LLu = register_mode(&newmode);
/* Reference Mode */
newmode.sort = irms_reference;
/* pointer */
newmode.name = new_id_from_chars("P", 1);
- newmode.code = irm_P;
newmode.sign = 0;
newmode.size = 32;
- newmode.modulo_shift = 0;
+ newmode.modulo_shift = 32;
newmode.eq_signed = mode_Is;
newmode.eq_unsigned = mode_Iu;
-
- mode_P = register_mode(&newmode);
+ mode_P = register_mode(&newmode);
/* set the machine specific modes to the predefined ones */
mode_P_code = mode_P;