X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fir%2Firverify.c;h=7a844d27193702a2934dfdd22ddb3de5c100e3e5;hb=e3f2b45b7e0b120a6c3e61d2df727f3eb1465aa0;hp=08fc2c8f0dd66f301c435b645a8d1bb7915d48f3;hpb=eb38e825ba0a4295779cd431856a379643cb347f;p=libfirm diff --git a/ir/ir/irverify.c b/ir/ir/irverify.c index 08fc2c8f0..7a844d271 100644 --- a/ir/ir/irverify.c +++ b/ir/ir/irverify.c @@ -1,20 +1,6 @@ /* - * Copyright (C) 1995-2011 University of Karlsruhe. All right reserved. - * * This file is part of libFirm. - * - * This file may be distributed and/or modified under the terms of the - * GNU General Public License version 2 as published by the Free Software - * Foundation and appearing in the file LICENSE.GPL included in the - * packaging of this file. - * - * Licensees holding valid libFirm Professional Edition licenses may use - * this file in accordance with the libFirm Commercial License. - * Agreement provided with the Software. - * - * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE - * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR - * PURPOSE. + * Copyright (C) 2012 University of Karlsruhe. */ /** @@ -77,13 +63,7 @@ static void show_entity_failure(const ir_node *node) if (ent) { ir_type *ent_type = get_entity_owner(ent); - - if (ent_type) { - ir_fprintf(stderr, "\nFIRM: irn_verify_irg() %+F::%s failed\n", - ent_type, get_entity_name(ent)); - } else { - fprintf(stderr, "\nFIRM: irn_verify_irg() ::%s failed\n", get_entity_name(ent)); - } + ir_fprintf(stderr, "\nFIRM: irn_verify_irg() %+F::%s failed\n", ent_type, get_entity_name(ent)); } else { fprintf(stderr, "\nFIRM: irn_verify_irg() failed\n", (void *)irg); } @@ -559,18 +539,16 @@ static int verify_node_Proj_Alloc(const ir_node *p) */ static int verify_node_Proj_Proj(const ir_node *p) { - ir_mode *mode = get_irn_mode(p); - ir_node *pred = get_Proj_pred(p); - long proj = get_Proj_proj(p); - long nr = get_Proj_proj(pred); - ir_type *mt; /* A method type */ - - pred = skip_Id(get_Proj_pred(pred)); - ASSERT_AND_RET((get_irn_mode(pred) == mode_T), "Proj from something not a tuple", 0); + ir_mode *mode = get_irn_mode(p); + ir_node *pred = get_Proj_pred(p); + ir_node *predpred = get_Proj_pred(pred); + long proj = get_Proj_proj(p); + long nr = get_Proj_proj(pred); - switch (get_irn_opcode(pred)) { - case iro_Start: - mt = get_entity_type(get_irg_entity(get_irn_irg(pred))); + switch (get_irn_opcode(predpred)) { + case iro_Start: { + ir_graph *irg = get_irn_irg(p); + ir_type *mt = get_entity_type(get_irg_entity(irg)); if (nr == pn_Start_T_args) { ASSERT_AND_RET( @@ -580,38 +558,39 @@ static int verify_node_Proj_Proj(const ir_node *p) (proj < (int)get_method_n_params(mt)), "More Projs for args than args in type", 0 ); - if ((mode_is_reference(mode)) && is_compound_type(get_method_param_type(mt, proj))) - /* value argument */ break; - - if (!irg_is_constrained(get_irn_irg(pred), IR_GRAPH_CONSTRAINT_BACKEND)) { + ir_type *param_type = get_method_param_type(mt, proj); + if (!irg_is_constrained(irg, IR_GRAPH_CONSTRAINT_BACKEND)) { ASSERT_AND_RET_DBG( - (mode == get_type_mode(get_method_param_type(mt, proj))), + (mode == get_type_mode(param_type)), "Mode of Proj from Start doesn't match mode of param type.", 0, show_proj_mode_failure(p, get_method_param_type(mt, proj)); ); } } break; + } - case iro_Call: - { - ASSERT_AND_RET( - (proj >= 0 && mode_is_datab(mode)), - "wrong Proj from Proj from Call", 0); - mt = get_Call_type(pred); - ASSERT_AND_RET(is_unknown_type(mt) || is_Method_type(mt), - "wrong call type on call", 0); - ASSERT_AND_RET( - (proj < (int)get_method_n_ress(mt)), - "More Projs for results than results in type.", 0); - if ((mode_is_reference(mode)) && is_compound_type(get_method_res_type(mt, proj))) - /* value result */ break; - - ASSERT_AND_RET( - (mode == get_type_mode(get_method_res_type(mt, proj))), - "Mode of Proj from Call doesn't match mode of result type.", 0); - } + case iro_Call: { + ASSERT_AND_RET( + (proj >= 0 && mode_is_datab(mode)), + "wrong Proj from Proj from Call", 0); + ir_type *mt = get_Call_type(predpred); + ASSERT_AND_RET(is_unknown_type(mt) || is_Method_type(mt), + "wrong call type on call", 0); + ASSERT_AND_RET( + (proj < (int)get_method_n_ress(mt)), + "More Projs for results than results in type.", 0); + ir_type *res_type = get_method_res_type(mt, proj); + /* value result */ + if ((mode_is_reference(mode)) && + (is_compound_type(res_type) || is_Array_type(res_type))) + break; + + ASSERT_AND_RET( + (mode == get_type_mode(get_method_res_type(mt, proj))), + "Mode of Proj from Call doesn't match mode of result type.", 0); break; + } case iro_Tuple: /* We don't test */ @@ -937,6 +916,14 @@ static int verify_node_SymConst(const ir_node *n) /* SymConst: BB --> ref */ mode_is_reference(mymode)) ,"SymConst node", 0); + if (SYMCONST_HAS_ENT(get_SymConst_kind(n))) { + ir_entity *ent = get_SymConst_entity(n); + /* the is_method_entity(ent) exception is for nested functions... */ + ASSERT_AND_RET_DBG((get_entity_owner(ent)->flags & tf_segment) + || is_method_entity(ent), + "SymConst node with non-segment entity", 0, + show_node_failure(n);); + } return 1; } @@ -962,6 +949,8 @@ static int verify_node_Sel(const ir_node *n) } ent = get_Sel_entity(n); ASSERT_AND_RET_DBG(ent, "Sel node with empty entity", 0, show_node_failure(n);); + ASSERT_AND_RET_DBG(!(get_entity_owner(ent)->flags & tf_segment), + "Sel node with global entity", 0, show_node_failure(n);); return 1; } @@ -1372,23 +1361,6 @@ static int verify_node_Conv(const ir_node *n) return 1; } -/** - * verify a Cast node - */ -static int verify_node_Cast(const ir_node *n) -{ - ir_mode *mymode = get_irn_mode(n); - ir_mode *op1mode = get_irn_mode(get_Cast_op(n)); - - ASSERT_AND_RET_DBG( - /* Conv: BB x datab1 --> datab2 */ - mode_is_data(op1mode) && op1mode == mymode, - "Cast node", 0, - show_unop_failure(n, "/* Conv: BB x datab1 --> datab2 */"); - ); - return 1; -} - /** * verify a Phi node */ @@ -1689,6 +1661,12 @@ int irn_verify_irg(const ir_node *n, ir_graph *irg) ); } + ASSERT_AND_RET_DBG( + !is_irn_start_block_placed(n) || get_nodes_block(n) == get_irg_start_block(irg), + "node should be in start block", 0, + ir_printf("node %+F", n); + ); + if (op->ops.verify_node) return op->ops.verify_node(n); @@ -2130,7 +2108,6 @@ void ir_register_verify_node_ops(void) register_verify_node_func(op_And, verify_node_And); register_verify_node_func(op_Block, verify_node_Block); register_verify_node_func(op_Call, verify_node_Call); - register_verify_node_func(op_Cast, verify_node_Cast); register_verify_node_func(op_Cmp, verify_node_Cmp); register_verify_node_func(op_Cond, verify_node_Cond); register_verify_node_func(op_Confirm, verify_node_Confirm);