adding assertion to prevent recursive compound types

[libfirm] / ir / tv / tv.c

diff --git a/ir/tv/tv.c b/ir/tv/tv.c
index eb4fc0e..dc793f6 100644 (file)
--- a/ir/tv/tv.c
+++ b/ir/tv/tv.c
@@ -408,21 +408,11 @@ long double get_tarval_double(tarval *tv)
 /*
  * Access routines for tarval fields ========================================
  */
-ir_mode *get_tarval_mode (tarval *tv)       /* get the mode of the tarval */
-{
-  ANNOUNCE();
-  assert(tv);
-  return tv->mode;
-}
 
-/*
-void *get_tarval_link (tarval *tv)
-{
-  ANNOUNCE ();
-  assert (tv);
-  return (tv->link);
+/* get the mode of the tarval */
+ir_mode *(get_tarval_mode)(const tarval *tv) {
+  return _get_tarval_mode(tv);
 }
-*/
 
 /*
  * Special value query functions ============================================
@@ -434,30 +424,24 @@ void *get_tarval_link (tarval *tv)
  * therefore the irmode functions should be prefered to the functions below.
  */
 
-tarval *get_tarval_bad(void)
-{
-  ANNOUNCE();
-  return tarval_bad;
+tarval *(get_tarval_bad)(void) {
+  return _get_tarval_bad();
 }
-tarval *get_tarval_undefined(void)
-{
-  ANNOUNCE();
-  return tarval_undefined;
+
+tarval *(get_tarval_undefined)(void) {
+  return _get_tarval_undefined();
 }
-tarval *get_tarval_b_false(void)
-{
-  ANNOUNCE();
-  return tarval_b_false;
+
+tarval *(get_tarval_b_false)(void) {
+  return _get_tarval_b_false();
 }
-tarval *get_tarval_b_true(void)
-{
-  ANNOUNCE();
-  return tarval_b_true;
+
+tarval *(get_tarval_b_true)(void) {
+  return _get_tarval_b_true();
 }
-tarval *get_tarval_P_void(void)
-{
-  ANNOUNCE();
-  return tarval_P_void;
+
+tarval *(get_tarval_P_void)(void) {
+  return _get_tarval_P_void();
 }
 
 tarval *get_tarval_max(ir_mode *mode)
@@ -799,10 +783,16 @@ pn_Cmp tarval_cmp(tarval *a, tarval *b)
   assert(a);
   assert(b);
 
-  if (a == tarval_bad || b == tarval_bad) assert(0 && "Comparison with tarval_bad");
-  if (a == tarval_undefined || b == tarval_undefined) return pn_Cmp_False;
-  if (a == b) return pn_Cmp_Eq;
-  if (a->mode != b->mode) return pn_Cmp_False;
+  if (a == tarval_bad || b == tarval_bad) {
+    assert(0 && "Comparison with tarval_bad");
+    return pn_Cmp_False;
+  }
+
+  if (a == tarval_undefined || b == tarval_undefined)
+    return pn_Cmp_False;
+
+  if (a->mode != b->mode)
+    return pn_Cmp_False;
 
   if (get_mode_n_vector_elems(a->mode) > 1) {
     /* vector arithmetic not implemented yet */
@@ -816,21 +806,31 @@ pn_Cmp tarval_cmp(tarval *a, tarval *b)
     case irms_memory:
     case irms_auxiliary:
     case irms_reference:
+      if (a == b)
+        return pn_Cmp_Eq;
       return pn_Cmp_False;
 
     case irms_float_number:
+      /*
+       * BEWARE: we cannot compare a == b here, because
+       * a NaN is always Unordered to any other value, even to itself!
+       */
       switch (fc_comp(a->value, b->value)) {
         case -1: return pn_Cmp_Lt;
-        case  0: assert(0 && "different tarvals compare equal"); return pn_Cmp_Eq;
+        case  0: return pn_Cmp_Eq;
         case  1: return pn_Cmp_Gt;
         case  2: return pn_Cmp_Uo;
         default: return pn_Cmp_False;
       }
     case irms_int_number:
     case irms_character:
+      if (a == b)
+        return pn_Cmp_Eq;
       return sc_comp(a->value, b->value) == 1 ? pn_Cmp_Gt : pn_Cmp_Lt;
 
     case irms_internal_boolean:
+      if (a == b)
+        return pn_Cmp_Eq;
       return a == tarval_b_true ? pn_Cmp_Gt : pn_Cmp_Lt;
   }
   return pn_Cmp_False;