Bail out if we do not know how to assemble CPUID.

[libfirm] / ir / ir / irnode.c

diff --git a/ir/ir/irnode.c b/ir/ir/irnode.c
index 3269e20..fa66010 100644 (file)
--- a/ir/ir/irnode.c
+++ b/ir/ir/irnode.c
@@ -156,7 +156,7 @@ ir_node *new_ir_node(dbg_info *db, ir_graph *irg, ir_node *block, ir_op *op,
        assert(irg);
        assert(op);
        assert(mode);
-       p = obstack_alloc(irg->obst, node_size);
+       p = (char*)obstack_alloc(irg->obst, node_size);
        memset(p, 0, node_size);
        res = (ir_node *)(p + add_node_size);
 
@@ -372,19 +372,6 @@ void (set_irn_mode)(ir_node *node, ir_mode *mode)
        _set_irn_mode(node, mode);
 }
 
-/** Gets the string representation of the mode .*/
-const char *get_irn_modename(const ir_node *node)
-{
-       assert(node);
-       return get_mode_name(node->mode);
-}
-
-ident *get_irn_modeident(const ir_node *node)
-{
-       assert(node);
-       return get_mode_ident(node->mode);
-}
-
 ir_op *(get_irn_op)(const ir_node *node)
 {
        return _get_irn_op(node);
@@ -890,25 +877,6 @@ int (is_Const_all_one)(const ir_node *node)
 }
 
 
-/* The source language type.  Must be an atomic type.  Mode of type must
-   be mode of node. For tarvals from entities type must be pointer to
-   entity type. */
-ir_type *get_Const_type(const ir_node *node)
-{
-       assert(is_Const(node));
-       return node->attr.con.tp;
-}
-
-void set_Const_type(ir_node *node, ir_type *tp)
-{
-       assert(is_Const(node));
-       if (tp != firm_unknown_type) {
-               assert(is_atomic_type(tp));
-               assert(get_type_mode(tp) == get_irn_mode(node));
-       }
-       node->attr.con.tp = tp;
-}
-
 
 symconst_kind get_SymConst_kind(const ir_node *node)
 {
@@ -978,18 +946,6 @@ void set_SymConst_symbol(ir_node *node, union symconst_symbol sym)
        node->attr.symc.sym = sym;
 }
 
-ir_type *get_SymConst_value_type(const ir_node *node)
-{
-       assert(is_SymConst(node));
-       return node->attr.symc.tp;
-}
-
-void set_SymConst_value_type(ir_node *node, ir_type *tp)
-{
-       assert(is_SymConst(node));
-       node->attr.symc.tp = tp;
-}
-
 int get_Sel_n_indexs(const ir_node *node)
 {
        assert(is_Sel(node));
@@ -1294,7 +1250,7 @@ void (set_Phi_next)(ir_node *phi, ir_node *next)
 
 int is_memop(const ir_node *node)
 {
-       ir_opcode code = get_irn_opcode(node);
+       unsigned code = get_irn_opcode(node);
        return (code == iro_Load || code == iro_Store);
 }
 
@@ -1325,7 +1281,7 @@ void set_memop_ptr(ir_node *node, ir_node *ptr)
 ir_volatility get_Load_volatility(const ir_node *node)
 {
        assert(is_Load(node));
-       return node->attr.load.volatility;
+       return (ir_volatility)node->attr.load.volatility;
 }
 
 void set_Load_volatility(ir_node *node, ir_volatility volatility)
@@ -1337,7 +1293,7 @@ void set_Load_volatility(ir_node *node, ir_volatility volatility)
 ir_align get_Load_align(const ir_node *node)
 {
        assert(is_Load(node));
-       return node->attr.load.aligned;
+       return (ir_align)node->attr.load.aligned;
 }
 
 void set_Load_align(ir_node *node, ir_align align)
@@ -1350,7 +1306,7 @@ void set_Load_align(ir_node *node, ir_align align)
 ir_volatility get_Store_volatility(const ir_node *node)
 {
        assert(is_Store(node));
-       return node->attr.store.volatility;
+       return (ir_volatility)node->attr.store.volatility;
 }
 
 void set_Store_volatility(ir_node *node, ir_volatility volatility)
@@ -1362,7 +1318,7 @@ void set_Store_volatility(ir_node *node, ir_volatility volatility)
 ir_align get_Store_align(const ir_node *node)
 {
        assert(is_Store(node));
-       return node->attr.store.aligned;
+       return (ir_align)node->attr.store.aligned;
 }
 
 void set_Store_align(ir_node *node, ir_align align)
@@ -1410,55 +1366,14 @@ void add_Sync_pred(ir_node *node, ir_node *pred)
        add_irn_n(node, pred);
 }
 
-/* Returns the source language type of a Proj node. */
-ir_type *get_Proj_type(const ir_node *n)
-{
-       ir_type *tp   = firm_unknown_type;
-       ir_node *pred = get_Proj_pred(n);
-
-       switch (get_irn_opcode(pred)) {
-       case iro_Proj: {
-               ir_node *pred_pred;
-               /* Deal with Start / Call here: we need to know the Proj Nr. */
-               assert(get_irn_mode(pred) == mode_T);
-               pred_pred = get_Proj_pred(pred);
-
-               if (is_Start(pred_pred))  {
-                       ir_type *mtp = get_entity_type(get_irg_entity(get_irn_irg(pred_pred)));
-                       tp = get_method_param_type(mtp, get_Proj_proj(n));
-               } else if (is_Call(pred_pred)) {
-                       ir_type *mtp = get_Call_type(pred_pred);
-                       tp = get_method_res_type(mtp, get_Proj_proj(n));
-               }
-       } break;
-       case iro_Start: break;
-       case iro_Call: break;
-       case iro_Load: {
-               ir_node *a = get_Load_ptr(pred);
-               if (is_Sel(a))
-                       tp = get_entity_type(get_Sel_entity(a));
-       } break;
-       default:
-               break;
-       }
-       return tp;
-}
-
-long get_Proj_proj(const ir_node *node)
-{
-       assert(is_Proj(node));
-       return node->attr.proj;
-}
-
-void set_Proj_proj(ir_node *node, long proj)
+int (is_arg_Proj)(const ir_node *node)
 {
-       assert(is_Proj(node));
-       node->attr.proj = proj;
+       return _is_arg_Proj(node);
 }
 
-int (is_arg_Proj)(const ir_node *node)
+pn_Cmp (get_Proj_pn_cmp)(const ir_node *node)
 {
-       return _is_arg_Proj(node);
+       return _get_Proj_pn_cmp(node);
 }
 
 ir_node **get_Tuple_preds_arr(ir_node *node)
@@ -1716,14 +1631,6 @@ void (copy_node_attr)(ir_graph *irg, const ir_node *old_node, ir_node *new_node)
        _copy_node_attr(irg, old_node, new_node);
 }
 
-/* Return the type associated with the value produced by n
- * if the node remarks this type as it is the case for
- * Cast, Const, SymConst and some Proj nodes. */
-ir_type *(get_irn_type)(ir_node *node)
-{
-       return _get_irn_type(node);
-}
-
 /* Return the type attribute of a node n (SymConst, Call, Alloc, Free,
    Cast) or NULL.*/
 ir_type *(get_irn_type_attr)(ir_node *node)
@@ -1797,30 +1704,6 @@ const char *get_cond_jmp_predicate_name(cond_jmp_predicate pred)
 #undef X
 }
 
-/** the get_type operation must be always implemented and return a firm type */
-static ir_type *get_Default_type(const ir_node *n)
-{
-       (void) n;
-       return get_unknown_type();
-}
-
-/* Sets the get_type operation for an ir_op_ops. */
-ir_op_ops *firm_set_default_get_type(ir_opcode code, ir_op_ops *ops)
-{
-       switch (code) {
-       case iro_Const:    ops->get_type = get_Const_type; break;
-       case iro_SymConst: ops->get_type = get_SymConst_value_type; break;
-       case iro_Cast:     ops->get_type = get_Cast_type; break;
-       case iro_Proj:     ops->get_type = get_Proj_type; break;
-       default:
-               /* not allowed to be NULL */
-               if (! ops->get_type)
-                       ops->get_type = get_Default_type;
-               break;
-       }
-       return ops;
-}
-
 /** Return the attribute type of a SymConst node if exists */
 static ir_type *get_SymConst_attr_type(const ir_node *self)
 {