X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fir%2Firmode.c;h=d40714052ab21d5f5044bc438357805ba66460fc;hb=906eee79a84738775a2d36f1f75e359a2179e77e;hp=76af6b9554fca849eba7e2ce627ffb04b9c08227;hpb=b090dd3c70bf2cc57ddf2f4607d7aeb76d82606e;p=libfirm

diff --git a/ir/ir/irmode.c b/ir/ir/irmode.c
index 76af6b955..d40714052 100644
--- a/ir/ir/irmode.c
+++ b/ir/ir/irmode.c
@@ -20,6 +20,7 @@
 # include "array.h"
 
 #if 0
+static long long count = 0;
 #  define ANNOUNCE() printf(__FILE__": call no. %lld (%s)\n", count++, __FUNCTION__)
 #else
 #  define ANNOUNCE() ((void)0)
@@ -29,9 +30,8 @@
  * local values
  * * */
 
-static long long count = 0;
 
-/* dynamic array to hold all modes */
+/** dynamic array to hold all modes */
 static ir_mode * modes;
 /* dynamic arrays to hold special modes' values */
 static tarval** modes_min;
@@ -39,29 +39,33 @@ static tarval** modes_max;
 static tarval** modes_null;
 static tarval** modes_one;
 
-/* number of defined modes */
+/** number of defined modes */
 static int num_modes;
 
 /* * *
  * local functions
  * * */
 
-/* compare modes that don't need to have their code field
- * correctly set */
+/**
+ * Compare modes that don't need to have their code field
+ * correctly set
+ */
 static int modes_are_equal(ir_mode *m, ir_mode *n)
 {
   if (m == n) return 1;
   if ( (m->sort == n->sort) && (m->size == n->size) &&
-      (m->align == n->align) && (m->sign == n->sign) &&
-      (m->name == n->name) )
+      (m->align == n->align) && (m->sign == n->sign)
+     )
     return 1;
 
   return 0;
 }
 
-/* searches the modes array for the given mode and returns
+/**
+ * searches the modes array for the given mode and returns
  * a pointer on an equal mode already in the array, NULL if
- * none found */
+ * none found
+ */
 static ir_mode *find_mode(ir_mode *m)
 {
   int i;
@@ -74,7 +78,9 @@ static ir_mode *find_mode(ir_mode *m)
   return NULL;
 }
 
-/* sets special values of modes */
+/**
+ * sets special values of modes
+ */
 static void set_mode_values(ir_mode* mode)
 {
   modes_min[get_mode_modecode(mode)] = get_tarval_min(mode);
@@ -86,7 +92,7 @@ static void set_mode_values(ir_mode* mode)
  * globals defined in irmode.h
  * * */
 
-/** Predefined modes **/
+/* --- Predefined modes --- */
 
 /* FIRM internal modes: */
 ir_mode *mode_T;
@@ -138,9 +144,11 @@ INLINE ir_mode *get_modeX() { ANNOUNCE(); return mode_X; }
 INLINE ir_mode *get_modeM() { ANNOUNCE(); return mode_M; }
 INLINE ir_mode *get_modeBB() { ANNOUNCE(); return mode_BB; }
 
-/* ** Constructor ** */
-ir_mode *
-register_mode(ir_mode* new_mode)
+/**
+ * Registers a new mode if not defined yet, else returns
+ * the "equivalent" one.
+ */
+static ir_mode *register_mode(ir_mode* new_mode)
 {
   ir_mode *mode;
 
@@ -154,22 +162,25 @@ register_mode(ir_mode* new_mode)
   /* sanity checks */
   switch (new_mode->sort)
   {
-    case auxiliary:
-    case internal_boolean:
+    case irms_auxiliary:
+    case irms_internal_boolean:
       assert(0 && "internal modes cannot be user defined");
+      return NULL;
       break;
 
-    case float_number:
+    case irms_float_number:
       assert(0 && "not yet implemented");
+      return NULL;
       break;
 
-    case int_number:
-    case reference:
-    case character:
+    case irms_int_number:
+    case irms_reference:
+    case irms_character:
       break;
 
     default:
-      assert(0);
+      assert(0 && "wrong mode sort");
+      return NULL;
   }
 
   /* copy mode struct to modes array */
@@ -189,15 +200,24 @@ register_mode(ir_mode* new_mode)
   return mode;
 }
 
+/*
+ * Creates a new mode.
+ */
+ir_mode *new_ir_mode(const char *name, mode_sort sort, int bit_size, int align, int sign)
+{
+  ir_mode mode_tmpl, *res;
+
+  mode_tmpl.name    = new_id_from_str(name);
+  mode_tmpl.sort    = sort;
+  mode_tmpl.size    = bit_size;
+  mode_tmpl.align   = align;
+  mode_tmpl.sign    = sign ? 1 : 0;
+  mode_tmpl.tv_priv = NULL;
+
+  return register_mode(&mode_tmpl);
+}
+
 /* Functions for the direct access to all attributes od a ir_mode */
-#ifdef MODE_ACCESS_DEFINES
-#  undef get_mode_modecode
-#  undef get_mode_ident
-#  undef get_mode_name
-#  undef get_mode_sort
-#  undef get_mode_size
-#  undef get_mode_align
-#endif
 modecode
 get_mode_modecode(ir_mode *mode)
 {
@@ -226,27 +246,27 @@ get_mode_sort(ir_mode* mode)
   return mode->sort;
 }
 
-int
-get_mode_size(ir_mode *mode)
+INLINE int
+get_mode_size_bits(ir_mode *mode)
 {
   ANNOUNCE();
   return mode->size;
 }
 
+int get_mode_size_bytes(ir_mode *mode) {
+  ANNOUNCE();
+  int size = get_mode_size_bits(mode);
+  if ((size % 8) != 0) return -1;
+  return size / 8;
+}
+
 int
 get_mode_align (ir_mode *mode)
 {
   ANNOUNCE();
   return mode->align;
 }
-#ifdef MODE_ACCESS_DEFINES
-#  define get_mode_modecode(mode) (mode)->code
-#  define get_mode_ident(mode) (mode)->name
-#  define get_mode_name(mode) id_to_str((mode)->name)
-#  define get_mode_sort(mode) (mode)->sort
-#  define get_mode_size(mode) (mode)->size
-#  define get_mode_align(mode) (mode)->align
-#endif
+
 int
 get_mode_sign (ir_mode *mode)
 {
@@ -379,7 +399,7 @@ mode_is_float (ir_mode *mode)
 {
   ANNOUNCE();
   assert(mode);
-  return (get_mode_sort(mode) == float_number);
+  return (get_mode_sort(mode) == irms_float_number);
 }
 
 int
@@ -387,7 +407,7 @@ mode_is_int (ir_mode *mode)
 {
   ANNOUNCE();
   assert(mode);
-  return (get_mode_sort(mode) == int_number);
+  return (get_mode_sort(mode) == irms_int_number);
 }
 
 int
@@ -403,7 +423,7 @@ mode_is_data (ir_mode *mode)
 {
   ANNOUNCE();
   assert(mode);
-  return (mode_is_num(mode) || get_mode_sort(mode) == character || get_mode_sort(mode) == reference);
+  return (mode_is_num(mode) || get_mode_sort(mode) == irms_character || get_mode_sort(mode) == irms_reference);
 }
 
 int
@@ -411,7 +431,7 @@ mode_is_datab (ir_mode *mode)
 {
   ANNOUNCE();
   assert(mode);
-  return (mode_is_data(mode) || get_mode_sort(mode) == internal_boolean);
+  return (mode_is_data(mode) || get_mode_sort(mode) == irms_internal_boolean);
 }
 
 int
@@ -423,15 +443,15 @@ mode_is_dataM (ir_mode *mode)
 }
 #ifdef MODE_ACCESS_DEFINES
 #  define mode_is_signed(mode) (mode)->sign
-#  define mode_is_float(mode) ((mode)->sort == float_number)
-#  define mode_is_int(mode) ((mode)->sort == int_number)
-#  define mode_is_num(mode) (((mode)->sort == float_number) || ((mode)->sort == int_number))
-#  define mode_is_data(mode) (((mode)->sort == float_number) || ((mode)->sort == int_number) || ((mode)->sort == character) || ((mode)->sort == reference))
-#  define mode_is_datab(mode) (((mode)->sort == float_number) || ((mode)->sort == int_number) || ((mode)->sort == character) || ((mode)->sort == reference) || ((mode)->sort == internal_boolean))
-#  define mode_is_dataM(mode) (((mode)->sort == float_number) || ((mode)->sort == int_number) || ((mode)->sort == character) || ((mode)->sort == reference) || ((mode)->code == irm_M))
+#  define mode_is_float(mode) ((mode)->sort == irms_float_number)
+#  define mode_is_int(mode) ((mode)->sort == irms_int_number)
+#  define mode_is_num(mode) (((mode)->sort == irms_float_number) || ((mode)->sort == irms_int_number))
+#  define mode_is_data(mode) (((mode)->sort == irms_float_number) || ((mode)->sort == irms_int_number) || ((mode)->sort == irms_character) || ((mode)->sort == irms_reference))
+#  define mode_is_datab(mode) (((mode)->sort == irms_float_number) || ((mode)->sort == irms_int_number) || ((mode)->sort == irms_character) || ((mode)->sort == irms_reference) || ((mode)->sort == irms_internal_boolean))
+#  define mode_is_dataM(mode) (((mode)->sort == irms_float_number) || ((mode)->sort == irms_int_number) || ((mode)->sort == irms_character) || ((mode)->sort == irms_reference) || ((mode)->code == irm_M))
 #endif
 /* Returns true if sm can be converted to lm without loss. */
-bool
+int
 smaller_mode(ir_mode *sm, ir_mode *lm)
 {
   ANNOUNCE();
@@ -442,10 +462,10 @@ smaller_mode(ir_mode *sm, ir_mode *lm)
 
   switch(get_mode_sort(sm))
   {
-    case int_number:
+    case irms_int_number:
       switch(get_mode_sort(lm))
       {
-        case int_number:
+        case irms_int_number:
           /* 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
@@ -453,21 +473,21 @@ smaller_mode(ir_mode *sm, ir_mode *lm)
            */
           if (mode_is_signed(sm))
           {
-            if ( mode_is_signed(lm) && (get_mode_size(lm) > get_mode_size(sm)) )
+            if ( mode_is_signed(lm) && (get_mode_size_bits(lm) > get_mode_size_bits(sm)) )
               return 1;
           }
           else if (mode_is_signed(lm))
           {
-            if (get_mode_size(lm) > get_mode_size(sm) + 1)
+            if (get_mode_size_bits(lm) > get_mode_size_bits(sm) + 1)
               return 1;
           }
-          else if (get_mode_size(lm) > get_mode_size(sm))
+          else if (get_mode_size_bits(lm) > get_mode_size_bits(sm))
           {
             return 1;
           }
           break;
 
-        case float_number:
+        case irms_float_number:
           /* int to float works if the float is large enough */
           return 0;
 
@@ -476,15 +496,15 @@ smaller_mode(ir_mode *sm, ir_mode *lm)
       }
       break;
 
-    case float_number:
+    case irms_float_number:
       /* XXX currently only the three standard 32,64,80 bit floats
        * are supported which can safely be converted */
-      if ( (get_mode_sort(lm) == float_number)
-           && (get_mode_size(lm) > get_mode_size(sm)) )
+      if ( (get_mode_sort(lm) == irms_float_number)
+           && (get_mode_size_bits(lm) > get_mode_size_bits(sm)) )
          return 1;
       break;
 
-    case reference:
+    case irms_reference:
        /* do exist machines out there with different pointer lenghts ?*/
       return 0;
 
@@ -496,61 +516,67 @@ smaller_mode(ir_mode *sm, ir_mode *lm)
   return 0;
 }
 
-/** ** initialization ** **/
+/* ** initialization ** */
 void
 init_mode (void)
 {
   ANNOUNCE();
   /* init flexible array */
-  modes = NEW_ARR_F(ir_mode, irm_max);
-  modes_min = NEW_ARR_F(tarval*, irm_max);
-  modes_max = NEW_ARR_F(tarval*, irm_max);
+  modes      = NEW_ARR_F(ir_mode, irm_max);
+  modes_min  = NEW_ARR_F(tarval*, irm_max);
+  modes_max  = NEW_ARR_F(tarval*, irm_max);
   modes_null = NEW_ARR_F(tarval*, irm_max);
-  modes_one = NEW_ARR_F(tarval*, irm_max);
+  modes_one  = NEW_ARR_F(tarval*, irm_max);
 
   /* initialize predefined modes */
   /* Basic Block */
   mode_BB = &modes[irm_BB];
   mode_BB->name = id_from_str("BB", 2);
   mode_BB->code = irm_BB;
-  mode_BB->sort = auxiliary;
+  mode_BB->sort = irms_auxiliary;
   mode_BB->sign = 0;
+  mode_BB->tv_priv = NULL;
 
   /* eXecution */
   mode_X = &modes[irm_X];
   mode_X->name = id_from_str("X", 1);
   mode_X->code = irm_X;
-  mode_X->sort = auxiliary;
+  mode_X->sort = irms_auxiliary;
   mode_X->sign = 0;
+  mode_X->tv_priv = NULL;
 
   /* Memory */
   mode_M = &modes[irm_M];
   mode_M->name = id_from_str("M", 1);
   mode_M->code = irm_M;
-  mode_M->sort = auxiliary;
+  mode_M->sort = irms_auxiliary;
   mode_M->sign = 0;
+  mode_M->tv_priv = NULL;
 
   /* Tuple */
   mode_T = &modes[irm_T];
   mode_T->name = id_from_str("T", 1);
   mode_T->code = irm_T;
   mode_T->sign = 0;
+  mode_T->tv_priv = NULL;
 
   /* boolean */
   mode_b = &modes[irm_b];
   mode_b->name = id_from_str("b", 1);
   mode_b->code = irm_b;
-  mode_b->sort = internal_boolean;
+  mode_b->sort = irms_internal_boolean;
   mode_b->sign = 0;
+  mode_b->tv_priv = NULL;
 
   /* float */
   mode_F = &modes[irm_F];
   mode_F->name = id_from_str("F", 1);
   mode_F->code = irm_F;
-  mode_F->sort = float_number;
+  mode_F->sort = irms_float_number;
   mode_F->sign = 1;
   mode_F->align = 32;
   mode_F->size = 32;
+  mode_F->tv_priv = NULL;
 
   set_mode_values(mode_F);
 
@@ -558,10 +584,11 @@ init_mode (void)
   mode_D = &modes[irm_D];
   mode_D->name = id_from_str("D", 1);
   mode_D->code = irm_D;
-  mode_D->sort = float_number;
+  mode_D->sort = irms_float_number;
   mode_D->sign = 1;
   mode_D->align = 32;
   mode_D->size = 64;
+  mode_D->tv_priv = NULL;
 
   set_mode_values(mode_D);
 
@@ -569,10 +596,11 @@ init_mode (void)
   mode_E = &modes[irm_E];
   mode_E->name = id_from_str("E", 1);
   mode_E->code = irm_E;
-  mode_E->sort = float_number;
+  mode_E->sort = irms_float_number;
   mode_E->sign = 1;
   mode_E->align = 32;
   mode_E->size = 80;
+  mode_E->tv_priv = NULL;
 
   set_mode_values(mode_E);
 
@@ -580,10 +608,11 @@ init_mode (void)
   mode_Bs = &modes[irm_Bs];
   mode_Bs->name = id_from_str("Bs", 2);
   mode_Bs->code = irm_Bs;
-  mode_Bs->sort = int_number;
+  mode_Bs->sort = irms_int_number;
   mode_Bs->sign = 1;
   mode_Bs->align = 8;
   mode_Bs->size = 8;
+  mode_Bs->tv_priv = NULL;
 
   set_mode_values(mode_Bs);
 
@@ -591,10 +620,11 @@ init_mode (void)
   mode_Bu = &modes[irm_Bu];
   mode_Bu->name = id_from_str("Bu", 2);
   mode_Bu->code = irm_Bu;
-  mode_Bu->sort = int_number;
+  mode_Bu->sort = irms_int_number;
   mode_Bu->sign = 0;
   mode_Bu->align = 8;
   mode_Bu->size = 8;
+  mode_Bu->tv_priv = NULL;
 
   set_mode_values(mode_Bu);
 
@@ -602,10 +632,11 @@ init_mode (void)
   mode_Hs = &modes[irm_Hs];
   mode_Hs->name = id_from_str("Hs", 2);
   mode_Hs->code = irm_Hs;
-  mode_Hs->sort = int_number;
+  mode_Hs->sort = irms_int_number;
   mode_Hs->sign = 1;
   mode_Hs->align = 16;
   mode_Hs->size = 16;
+  mode_Hs->tv_priv = NULL;
 
   set_mode_values(mode_Hs);
 
@@ -613,10 +644,11 @@ init_mode (void)
   mode_Hu = &modes[irm_Hu];
   mode_Hu->name = id_from_str("Hu", 2);
   mode_Hu->code = irm_Hu;
-  mode_Hu->sort = int_number;
+  mode_Hu->sort = irms_int_number;
   mode_Hu->sign = 0;
   mode_Hu->align = 16;
   mode_Hu->size = 16;
+  mode_Hu->tv_priv = NULL;
 
   set_mode_values(mode_Hu);
 
@@ -624,10 +656,11 @@ init_mode (void)
   mode_Is = &modes[irm_Is];
   mode_Is->name = id_from_str("Is", 2);
   mode_Is->code = irm_Is;
-  mode_Is->sort = int_number;
+  mode_Is->sort = irms_int_number;
   mode_Is->sign = 1;
   mode_Is->align = 32;
   mode_Is->size = 32;
+  mode_Is->tv_priv = NULL;
 
   set_mode_values(mode_Is);
 
@@ -635,10 +668,11 @@ init_mode (void)
   mode_Iu = &modes[irm_Iu];
   mode_Iu->name = id_from_str("Iu", 2);
   mode_Iu->code = irm_Iu;
-  mode_Iu->sort = int_number;
+  mode_Iu->sort = irms_int_number;
   mode_Iu->sign = 0;
   mode_Iu->align = 32;
   mode_Iu->size = 32;
+  mode_Iu->tv_priv = NULL;
 
   set_mode_values(mode_Iu);
 
@@ -646,10 +680,11 @@ init_mode (void)
   mode_Ls = &modes[irm_Ls];
   mode_Ls->name = id_from_str("Ls", 2);
   mode_Ls->code = irm_Ls;
-  mode_Ls->sort = int_number;
+  mode_Ls->sort = irms_int_number;
   mode_Ls->sign = 1;
   mode_Ls->align = 32;
   mode_Ls->size = 64;
+  mode_Ls->tv_priv = NULL;
 
   set_mode_values(mode_Ls);
 
@@ -657,10 +692,11 @@ init_mode (void)
   mode_Lu = &modes[irm_Lu];
   mode_Lu->name = id_from_str("Lu", 2);
   mode_Lu->code = irm_Lu;
-  mode_Lu->sort = int_number;
+  mode_Lu->sort = irms_int_number;
   mode_Lu->sign = 0;
   mode_Lu->align = 32;
   mode_Lu->size = 64;
+  mode_Lu->tv_priv = NULL;
 
   set_mode_values(mode_Lu);
 
@@ -668,10 +704,11 @@ init_mode (void)
   mode_C = &modes[irm_C];
   mode_C->name = id_from_str("C", 1);
   mode_C->code = irm_C;
-  mode_C->sort = character;
+  mode_C->sort = irms_character;
   mode_C->sign = 0;
   mode_C->align = 8;
   mode_C->size = 8;
+  mode_C->tv_priv = NULL;
 
   set_mode_values(mode_C);
 
@@ -679,10 +716,11 @@ init_mode (void)
   mode_U = &modes[irm_U];
   mode_U->name = id_from_str("U", 1);
   mode_U->code = irm_U;
-  mode_U->sort = character;
+  mode_U->sort = irms_character;
   mode_U->sign = 0;
   mode_U->align = 16;
   mode_U->size = 16;
+  mode_U->tv_priv = NULL;
 
   set_mode_values(mode_U);
 
@@ -690,10 +728,11 @@ init_mode (void)
   mode_P = &modes[irm_P];
   mode_P->name = id_from_str("P", 1);
   mode_P->code = irm_P;
-  mode_P->sort = reference;
+  mode_P->sort = irms_reference;
   mode_P->sign = 0;
   mode_P->align = 32;
   mode_P->size = 32;
+  mode_P->tv_priv = NULL;
 
   num_modes = irm_max;
 }