little cleanup

[libfirm] / ir / tr / entity.c

diff --git a/ir/tr/entity.c b/ir/tr/entity.c
index 905a8fa..cac4e82 100644 (file)
--- a/ir/tr/entity.c
+++ b/ir/tr/entity.c
@@ -123,7 +123,7 @@ new_rd_entity (dbg_info *db, type *owner, ident *name, type *type)
     res->value              = new_SymConst(sym, symconst_addr_ent);
     current_ir_graph        = rem;
     res->variability        = variability_constant;
-    res->irg_add_properties = irg_no_property;
+    res->irg_add_properties = mtp_property_inherited;
     res->param_access       = NULL;
     res->param_weight       = NULL;
   }
@@ -201,7 +201,7 @@ static void free_entity_attrs(entity *ent) {
   }
   if (ent->param_weight) {
     DEL_ARR_F(ent->param_weight);
-    ent->param_weight;
+    ent->param_weight = NULL;
   }
 }
 
@@ -518,15 +518,14 @@ int is_irn_const_expression(ir_node *n) {
   case iro_Const:
   case iro_SymConst:
   case iro_Unknown:
-    return true; break;
+    return 1;
   case iro_Conv:
   case iro_Cast:
     return is_irn_const_expression(get_irn_n(n, 0));
   default:
-    return false;
     break;
   }
-  return false;
+  return 0;
 }
 
 /*
@@ -622,15 +621,15 @@ int is_proper_compound_graph_path(compound_graph_path *gr, int pos) {
     node = get_compound_graph_path_node(gr, i);
     if (node == NULL)
       /* Path not yet complete. */
-      return true;
+      return 1;
     if (get_entity_owner(node) != owner)
-      return false;
+      return 0;
     owner = get_entity_type(node);
   }
   if (pos == get_compound_graph_path_length(gr))
     if (!is_atomic_type(owner))
-      return false;
-  return true;
+      return 0;
+  return 1;
 }
 
 /* Returns the length of a graph path */
@@ -711,14 +710,14 @@ static int equal_paths(compound_graph_path *path1, int *visited_indicees, compou
   int len1 = get_compound_graph_path_length(path1);
   int len2 = get_compound_graph_path_length(path2);
 
-  if (len2 > len1) return false;
+  if (len2 > len1) return 0;
 
   for (i = 0; i < len1; i++) {
     type   *tp;
     entity *node1 = get_compound_graph_path_node(path1, i);
     entity *node2 = get_compound_graph_path_node(path2, i);
 
-    if (node1 != node2) return false;
+    if (node1 != node2) return 0;
 
     tp = get_entity_owner(node1);
     if (is_Array_type(tp)) {
@@ -730,13 +729,13 @@ static int equal_paths(compound_graph_path *path1, int *visited_indicees, compou
       low = get_array_lower_bound_int(tp, 0);
       if (low + visited_indicees[i] < get_compound_graph_path_array_index(path2, i)) {
         visited_indicees[i]++;
-        return false;
+        return 0;
       }
       else
         assert(low + visited_indicees[i] == get_compound_graph_path_array_index(path2, i));
     }
   }
-  return true;
+  return 1;
 }
 
 /* Returns the position of a value with the given path.
@@ -1278,9 +1277,9 @@ int is_compound_entity(entity *ent) {
 
 /**
  * @todo not implemented!!! */
-bool equal_entity(entity *ent1, entity *ent2) {
+int equal_entity(entity *ent1, entity *ent2) {
   fprintf(stderr, " calling unimplemented equal entity!!! \n");
-  return true;
+  return 1;
 }
 
 
@@ -1305,26 +1304,63 @@ int (entity_not_visited)(entity *ent) {
   return _entity_not_visited(ent);
 }
 
-unsigned (get_entity_additional_properties)(const entity *ent) {
-  return _get_entity_additional_properties(ent);
-}
+/* Returns the mask of the additional entity properties. */
+unsigned get_entity_additional_properties(entity *ent) {
+  ir_graph *irg;
 
-void (set_entity_additional_properties)(entity *ent, unsigned property_mask) {
-  _set_entity_additional_properties(ent, property_mask);
-}
+  assert(is_Method_type(get_entity_type(ent)));
+
+  /* first check, if the graph has additional properties */
+  irg = get_entity_irg(ent);
+
+  if (irg)
+    return get_irg_additional_properties(irg);
 
-void (set_entity_additional_property)(entity *ent, unsigned flag) {
-  _set_entity_additional_property(ent, (irg_additional_property)flag);
+  if (ent->irg_add_properties & mtp_property_inherited)
+    return get_method_additional_properties(get_entity_type(ent));
+
+  return ent->irg_add_properties;
 }
 
-/* Returns the calling convention of an entities graph. */
-unsigned (get_entity_calling_convention)(const entity *ent) {
-  return _get_entity_calling_convention(ent);
+/* Sets the mask of the additional graph properties. */
+void set_entity_additional_properties(entity *ent, unsigned property_mask)
+{
+  ir_graph *irg;
+
+  assert(is_Method_type(get_entity_type(ent)));
+
+  /* first check, if the graph exists */
+  irg = get_entity_irg(ent);
+  if (irg)
+    set_irg_additional_properties(irg, property_mask);
+  else {
+    /* do not allow to set the mtp_property_inherited flag or
+     * the automatic inheritance of flags will not work */
+    ent->irg_add_properties = property_mask & ~mtp_property_inherited;
+  }
 }
 
-/* Sets the calling convention of an entities graph. */
-void (set_entity_calling_convention)(entity *ent, unsigned cc_mask) {
-  _set_entity_calling_convention(ent, cc_mask);
+/* Sets one additional graph property. */
+void set_entity_additional_property(entity *ent, mtp_additional_property flag)
+{
+  ir_graph *irg;
+
+  assert(is_Method_type(get_entity_type(ent)));
+
+  /* first check, if the graph exists */
+  irg = get_entity_irg(ent);
+  if (irg)
+    set_irg_additional_property(irg, flag);
+  else {
+    unsigned mask = ent->irg_add_properties;
+
+    if (mask & mtp_property_inherited)
+      mask = get_method_additional_properties(get_entity_type(ent));
+
+    /* do not allow to set the mtp_property_inherited flag or
+     * the automatic inheritance of flags will not work */
+    ent->irg_add_properties = mask | (flag & ~mtp_property_inherited);
+  }
 }
 
 void firm_init_entity(void)