fix wrong assert, expor copy_node_attr function to public API

[libfirm] / ir / tr / type.c

diff --git a/ir/tr/type.c b/ir/tr/type.c
index 764b657..77020be 100644 (file)
--- a/ir/tr/type.c
+++ b/ir/tr/type.c
@@ -47,9 +47,7 @@
 
 #include "config.h"
 
-#ifdef HAVE_STRING_H
-# include <string.h>
-#endif
+#include <string.h>
 #include <stdlib.h>
 #include <stddef.h>
 
@@ -71,6 +69,7 @@
 /*-----------------------------------------------------------------*/
 
 ir_type *firm_none_type;    ir_type *get_none_type(void)    { return firm_none_type;    }
+ir_type *firm_code_type;    ir_type *get_code_type(void)    { return firm_code_type;    }
 ir_type *firm_unknown_type; ir_type *get_unknown_type(void) { return firm_unknown_type; }
 
 
@@ -98,6 +97,10 @@ void firm_init_type(dbg_info *builtin_db, unsigned def_cc_mask) {
        set_type_state (firm_none_type, layout_fixed);
        remove_irp_type(firm_none_type);
 
+       firm_code_type    = new_type(tpop_code, mode_ANY, new_id_from_str("type_code"), builtin_db);
+       set_type_state(firm_code_type, layout_fixed);
+       remove_irp_type(firm_code_type);
+
        firm_unknown_type = new_type(tpop_unknown, mode_ANY, new_id_from_str("type_unknown"), builtin_db);
        set_type_size_bytes(firm_unknown_type, 0);
        set_type_state (firm_unknown_type, layout_fixed);
@@ -115,7 +118,7 @@ void (inc_master_type_visited)(void)             { _inc_master_type_visited(); }
  * Creates a new type representation.
  */
 ir_type *
-new_type(tp_op *type_op, ir_mode *mode, ident *name, dbg_info *db) {
+new_type(const tp_op *type_op, ir_mode *mode, ident *name, dbg_info *db) {
        ir_type *res;
        int node_size;
 
@@ -150,7 +153,8 @@ new_type(tp_op *type_op, ir_mode *mode, ident *name, dbg_info *db) {
 void free_type(ir_type *tp) {
        const tp_op *op = get_type_tpop(tp);
 
-       if ((get_type_tpop(tp) == tpop_none) || (get_type_tpop(tp) == tpop_unknown))
+       if ((get_type_tpop(tp) == tpop_none) || (get_type_tpop(tp) == tpop_unknown)
+                       || (get_type_tpop(tp) == tpop_code))
                return;
        /* Remove from list of all types */
        remove_irp_type(tp);
@@ -1328,6 +1332,26 @@ ir_entity *get_method_value_param_ent(ir_type *method, int pos) {
        return method->attr.ma.params[pos].ent;
 }
 
+/*
+ * Sets the type that represents the copied value arguments.
+ */
+void set_method_value_param_type(ir_type *method, ir_type *tp) {
+       int i, n;
+
+       assert(method && (method->type_op == type_method));
+       assert(is_value_param_type(tp));
+       assert(get_method_n_params(method) == get_struct_n_members(tp));
+
+       method->attr.ma.value_params = tp;
+
+       n = get_struct_n_members(tp);
+       for (i = 0; i < n; i++)
+       {
+               ir_entity *ent = get_struct_member(tp, i);
+               method->attr.ma.params[i].ent = ent;
+       }
+}
+
 /*
  * Returns a type that represents the copied value arguments.
  */
@@ -1392,7 +1416,7 @@ ir_type *get_method_value_res_type(const ir_type *method) {
 }
 
 /* Returns the null-terminated name of this variadicity. */
-const char *get_variadicity_name(variadicity vari) {
+const char *get_variadicity_name(ir_variadicity vari) {
 #define X(a)    case a: return #a
        switch (vari) {
        X(variadicity_non_variadic);
@@ -1403,12 +1427,12 @@ const char *get_variadicity_name(variadicity vari) {
 #undef X
 }
 
-variadicity get_method_variadicity(const ir_type *method) {
+ir_variadicity get_method_variadicity(const ir_type *method) {
        assert(method && (method->type_op == type_method));
        return method->attr.ma.variadicity;
 }
 
-void set_method_variadicity(ir_type *method, variadicity vari) {
+void set_method_variadicity(ir_type *method, ir_variadicity vari) {
        assert(method && (method->type_op == type_method));
        method->attr.ma.variadicity = vari;
 }
@@ -2028,6 +2052,11 @@ int is_compound_type(const ir_type *tp) {
        return tp->type_op->flags & TP_OP_FLAG_COMPOUND;
 }
 
+int is_code_type(const ir_type *tp) {
+       assert(tp && tp->kind == k_type);
+       return tp->type_op == tpop_code;
+}
+
 /* Checks, whether a type is a frame type */
 int is_frame_type(const ir_type *tp) {
        return tp->flags & tf_frame_type;
@@ -2043,6 +2072,18 @@ int is_lowered_type(const ir_type *tp) {
        return tp->flags & tf_lowered_type;
 }
 
+/* Makes a new value type. */
+ir_type *new_type_value(ident *name) {
+       ir_type *res = new_type_struct(name);
+
+       res->flags |= tf_value_param_type;
+
+       /* Remove type from type list.  Must be treated differently than other types. */
+       remove_irp_type(res);
+
+       return res;
+}
+
 /* Makes a new frame type. */
 ir_type *new_type_frame(ident *name) {
        ir_type *res = new_type_class(name);