Let dfs() discover only memory nodes

[libfirm] / ir / tr / type.c

diff --git a/ir/tr/type.c b/ir/tr/type.c
index f208cbb..1a02978 100644 (file)
--- a/ir/tr/type.c
+++ b/ir/tr/type.c
@@ -99,12 +99,12 @@ void firm_init_type(dbg_info *builtin_db, unsigned def_cc_mask) {
 
        /* construct none and unknown type. */
        firm_none_type    = new_type(tpop_none,    mode_BAD, new_id_from_str("type_none"), builtin_db);
-       set_type_size_bits(firm_none_type, 0);
+       set_type_size_bytes(firm_none_type, 0);
        set_type_state (firm_none_type, layout_fixed);
        remove_irp_type(firm_none_type);
 
        firm_unknown_type = new_type(tpop_unknown, mode_ANY, new_id_from_str("type_unknown"), builtin_db);
-       set_type_size_bits(firm_unknown_type, 0);
+       set_type_size_bytes(firm_unknown_type, 0);
        set_type_state (firm_unknown_type, layout_fixed);
        remove_irp_type(firm_unknown_type);
 }
@@ -377,7 +377,7 @@ set_type_alignment_bytes(ir_type *tp, int align) {
 }
 
 /* Returns a human readable string for the enum entry. */
-const char *get_type_state_name(type_state s) {
+const char *get_type_state_name(ir_type_state s) {
 #define X(a)    case a: return #a;
        switch (s) {
                X(layout_undefined);
@@ -388,12 +388,12 @@ const char *get_type_state_name(type_state s) {
 }
 
 
-type_state (get_type_state)(const ir_type *tp) {
+ir_type_state (get_type_state)(const ir_type *tp) {
        return _get_type_state(tp);
 }
 
 void
-set_type_state(ir_type *tp, type_state state) {
+set_type_state(ir_type *tp, ir_type_state state) {
        assert(tp && tp->kind == k_type);
 
        if ((tp->type_op == type_pointer) || (tp->type_op == type_primitive) ||
@@ -472,6 +472,14 @@ int (type_not_visited)(const ir_type *tp) {
        return _type_not_visited(tp);
 }
 
+dbg_info *(get_type_dbg_info)(const ir_type *tp) {
+       return _get_type_dbg_info(tp);
+}
+
+void (set_type_dbg_info)(ir_type *tp, dbg_info *db) {
+       _set_type_dbg_info(tp, db);
+}
+
 int (is_type)(const void *thing) {
   return _is_type(thing);
 }
@@ -1231,6 +1239,7 @@ ir_type *new_type_method(ident *name, int n_param, int n_res) {
 }
 
 void free_method_entities(ir_type *method) {
+  (void) method;
        assert(method && (method->type_op == type_method));
 }
 
@@ -1606,6 +1615,7 @@ void free_array_automatic_entities(ir_type *array) {
 }
 
 void free_array_entities (ir_type *array) {
+       (void) array;
        assert(array && (array->type_op == type_array));
 }
 
@@ -1780,6 +1790,7 @@ ir_type *new_type_enumeration(ident *name, int n_enums) {
 }
 
 void free_enumeration_entities(ir_type *enumeration) {
+       (void) enumeration;
        assert(enumeration && (enumeration->type_op == type_enumeration));
 }
 void free_enumeration_attrs(ir_type *enumeration) {
@@ -1868,10 +1879,12 @@ ir_type *new_type_pointer(ident *name, ir_type *points_to, ir_mode *ptr_mode) {
 }
 
 void free_pointer_entities(ir_type *pointer) {
+       (void) pointer;
        assert(pointer && (pointer->type_op == type_pointer));
 }
 
 void free_pointer_attrs(ir_type *pointer) {
+       (void) pointer;
        assert(pointer && (pointer->type_op == type_pointer));
 }
 
@@ -1923,6 +1936,7 @@ ir_type *new_d_type_primitive(ident *name, ir_mode *mode, dbg_info *db) {
        ir_type *res = new_type(type_primitive, mode, name, db);
        res->size  = get_mode_size_bits(mode);
        res->flags |= tf_layout_fixed;
+       res->attr.ba.base_type = NULL;
        hook_new_type(res);
        return res;
 }
@@ -1931,7 +1945,7 @@ ir_type *new_type_primitive(ident *name, ir_mode *mode) {
        return new_d_type_primitive(name, mode, NULL);
 }
 
-/* typecheck */
+/* type check */
 int (is_Primitive_type)(const ir_type *primitive) {
        return _is_primitive_type(primitive);
 }
@@ -1945,6 +1959,17 @@ void set_primitive_mode(ir_type *tp, ir_mode *mode) {
        tp->mode = mode;
 }
 
+/* Return the base type of a primitive (bitfield) type or NULL if none. */
+ir_type *get_primitive_base_type(ir_type *tp) {
+       assert(is_Primitive_type(tp));
+       return tp->attr.ba.base_type;
+}
+
+/* Sets the base type of a primitive (bitfield) type. */
+void set_primitive_base_type(ir_type *tp, ir_type *base_tp) {
+       assert(is_Primitive_type(tp));
+       tp->attr.ba.base_type = base_tp;
+}
 
 /*-----------------------------------------------------------------*/
 /* common functionality                                            */