X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fir%2Firvrfy.c;h=dd356533f9c098ec90dedd715aed097c4fa7c9ab;hb=eda9d668d0e8c8246015b4c5e743316a6a835a23;hp=5e0f72a2b7025c576c27b1f4490ad4aee58db140;hpb=b35715bdc07a33661fbf28877324857a49e94af0;p=libfirm diff --git a/ir/ir/irvrfy.c b/ir/ir/irvrfy.c index 5e0f72a2b..dd356533f 100644 --- a/ir/ir/irvrfy.c +++ b/ir/ir/irvrfy.c @@ -1,32 +1,47 @@ /* - * Project: libFIRM - * File name: ir/ir/irvrfy.c - * Purpose: Check irnodes for correctness. - * Author: Christian Schaefer - * Modified by: Goetz Lindenmaier. Till Riedel. Michael Beck. - * Created: - * CVS-ID: $Id$ - * Copyright: (c) 1998-2003 Universität Karlsruhe - * Licence: This file protected by GPL - GNU GENERAL PUBLIC LICENSE. + * Copyright (C) 1995-2007 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. + */ + +/** + * @file + * @brief Check irnodes for correctness. + * @author Christian Schaefer, Goetz Lindenmaier, Till Riedel, Michael Beck + * @version $Id$ */ - #ifdef HAVE_CONFIG_H # include "config.h" #endif -# include "irprog.h" -# include "irop_t.h" -# include "irgraph_t.h" -# include "ircgcons.h" -# include "irvrfy_t.h" -# include "irgwalk.h" -# include "irdump.h" -# include "irdom_t.h" +#include "irprog.h" +#include "irop_t.h" +#include "irgraph_t.h" +#include "ircgcons.h" +#include "irvrfy_t.h" +#include "irgwalk.h" +#include "irdump.h" +#include "irdom_t.h" +#include "irprintf.h" +#include "irouts.h" +#include "irflag_t.h" /** if this flag is set, verify entity types in Load & Store nodes */ static int vrfy_entities = 0; -node_verification_t opt_do_node_verification = NODE_VERIFICATION_ON; const char *firm_vrfy_failure_msg; /* enable verification of Load/Store entities */ @@ -43,10 +58,6 @@ static const char *get_mode_name_ex(ir_mode *mode) { return get_mode_name(mode); } -void do_node_verification(node_verification_t mode) { - opt_do_node_verification = mode; -} - /** the last IRG, on which a verify error was found */ static ir_graph *last_irg_error = NULL; @@ -66,10 +77,10 @@ static void show_entity_failure(ir_node *node) fprintf(stderr, "\nFIRM: irn_vrfy_irg() failed\n"); } else { - entity *ent = get_irg_entity(irg); + ir_entity *ent = get_irg_entity(irg); if (ent) { - type *ent_type = get_entity_owner(ent); + ir_type *ent_type = get_entity_owner(ent); if (ent_type) { if (ent_type == get_glob_type()) @@ -168,7 +179,7 @@ static void show_proj_failure(ir_node *n) /** * Prints a failure message for a proj from Start */ -static void show_proj_mode_failure(ir_node *n, type *ty) +static void show_proj_mode_failure(ir_node *n, ir_type *ty) { long proj = get_Proj_proj(n); ir_mode *m = get_type_mode(ty); @@ -185,7 +196,7 @@ static void show_proj_mode_failure(ir_node *n, type *ty) /** * Prints a failure message for a proj */ -static void show_proj_failure_ent(ir_node *n, entity *ent) +static void show_proj_failure_ent(ir_node *n, ir_entity *ent) { ir_node *op = get_Proj_pred(n); int proj = get_Proj_proj(n); @@ -205,22 +216,13 @@ static void show_proj_failure_ent(ir_node *n, entity *ent) */ static void show_node_on_graph(ir_graph *irg, ir_node *n) { - entity *ent = get_irg_entity(irg); - - if (ent) - fprintf(stderr, "\nFIRM: irn_vrfy_irg() of entity %s, node %ld %s%s\n", - get_entity_name(ent), - get_irn_node_nr(n), get_irn_opname(n), get_irn_modename(n)); - else - fprintf(stderr, "\nFIRM: irn_vrfy_irg() of graph %p, node %ld %s%s\n", - (void *)irg, - get_irn_node_nr(n), get_irn_opname(n), get_irn_modename(n)); + ir_fprintf(stderr, "\nFIRM: irn_vrfy_irg() of %+F, node %+F\n", irg, n); } /** - * Show call params + * Show call parameters */ -static void show_call_param(ir_node *n, type *mt) +static void show_call_param(ir_node *n, ir_type *mt) { int i; @@ -241,9 +243,9 @@ static void show_call_param(ir_node *n, type *mt) /** * Show return modes */ -static void show_return_modes(ir_graph *irg, ir_node *n, type *mt, int i) +static void show_return_modes(ir_graph *irg, ir_node *n, ir_type *mt, int i) { - entity *ent = get_irg_entity(irg); + ir_entity *ent = get_irg_entity(irg); show_entity_failure(n); fprintf(stderr, " Return node %ld in entity \"%s\" mode %s different from type mode %s\n", @@ -256,9 +258,9 @@ static void show_return_modes(ir_graph *irg, ir_node *n, type *mt, int i) /** * Show return number of results */ -static void show_return_nres(ir_graph *irg, ir_node *n, type *mt) +static void show_return_nres(ir_graph *irg, ir_node *n, ir_type *mt) { - entity *ent = get_irg_entity(irg); + ir_entity *ent = get_irg_entity(irg); show_entity_failure(n); fprintf(stderr, " Return node %ld in entity \"%s\" has %d results different from type %d\n", @@ -289,7 +291,7 @@ static void show_phi_inputs(ir_node *phi, ir_node *block) } /** If the address is Sel or SymConst, return the entity. */ -static entity *get_ptr_entity(ir_node *ptr) { +static ir_entity *get_ptr_entity(ir_node *ptr) { if (get_irn_op(ptr) == op_Sel) { return get_Sel_entity(ptr); } else if ((get_irn_op(ptr) == op_SymConst) && (get_SymConst_kind(ptr) == symconst_addr_ent)) { @@ -311,6 +313,7 @@ static int verify_node_Proj_Start(ir_node *n, ir_node *p) { (proj == pn_Start_M && mode == mode_M) || (proj == pn_Start_P_frame_base && mode_is_reference(mode)) || (proj == pn_Start_P_globals && mode_is_reference(mode)) || + (proj == pn_Start_P_tls && mode_is_reference(mode)) || (proj == pn_Start_T_args && mode == mode_T) || (proj == pn_Start_P_value_arg_base && mode_is_reference(mode)) || (proj == pn_Start_P_value_arg_base && mode == mode_T) /* FIXME: only one of those */ @@ -522,7 +525,7 @@ static int verify_node_Proj_Load(ir_node *n, ir_node *p) { if (proj == pn_Load_res) { ir_node *ptr = get_Load_ptr(n); - entity *ent = get_ptr_entity(ptr); + ir_entity *ent = get_ptr_entity(ptr); if (vrfy_entities && ent && get_irg_phase_state(current_ir_graph) == phase_high) { /* do NOT check this for lowered phases, see comment on Store */ @@ -601,7 +604,7 @@ static int verify_node_Proj_Proj(ir_node *pred, ir_node *p) { ir_mode *mode = get_irn_mode(p); long proj = get_Proj_proj(p); long nr = get_Proj_proj(pred); - type *mt; /* A method type */ + 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); @@ -666,7 +669,8 @@ static int verify_node_Proj_Proj(ir_node *pred, ir_node *p) { break; default: - ASSERT_AND_RET(0, "Unknown opcode", 0); + /* ASSERT_AND_RET(0, "Unknown opcode", 0); */ + break; } return 1; } @@ -704,6 +708,51 @@ static int verify_node_Proj_EndExcept(ir_node *n, ir_node *p) { return 1; } +/** + * verify a Proj(CopyB) node + */ +static int verify_node_Proj_CopyB(ir_node *n, ir_node *p) { + ir_mode *mode = get_irn_mode(p); + long proj = get_Proj_proj(p); + + ASSERT_AND_RET_DBG( + ((proj == pn_CopyB_M_regular && mode == mode_M) || + (proj == pn_CopyB_X_except && mode == mode_X) || + (proj == pn_CopyB_M_except && mode == mode_M)), + "wrong Proj from CopyB", 0, + show_proj_failure(p); + ); + if (proj == pn_CopyB_X_except) + ASSERT_AND_RET( + get_irn_pinned(n) == op_pin_state_pinned, + "Exception Proj from unpinned CopyB", 0); + return 1; +} + +/** + * verify a Proj(Bound) node + */ +static int verify_node_Proj_Bound(ir_node *n, ir_node *p) { + ir_mode *mode = get_irn_mode(p); + long proj = get_Proj_proj(p); + + /* ignore Bound checks of Bad */ + if (is_Bad(get_Bound_index(n))) + return 1; + ASSERT_AND_RET_DBG( + ((proj == pn_Bound_M && mode == mode_M) || + (proj == pn_Bound_X_except && mode == mode_X) || + (proj == pn_Bound_res && mode == get_irn_mode(get_Bound_index(n)))), + "wrong Proj from Bound", 0, + show_proj_failure(p); + ); + if (proj == pn_Bound_X_except) + ASSERT_AND_RET( + get_irn_pinned(n) == op_pin_state_pinned, + "Exception Proj from unpinned Bound", 0); + return 1; +} + /** * verify a Proj node */ @@ -717,8 +766,8 @@ verify_node_Proj(ir_node *p, ir_graph *irg) { op = get_irn_op(pred); - if (op->verify_proj_node) - return op->verify_proj_node(pred, p); + if (op->ops.verify_proj_node) + return op->ops.verify_proj_node(pred, p); /* all went ok */ return 1; @@ -740,12 +789,12 @@ static int verify_node_Block(ir_node *n, ir_graph *irg) { } /* End block may only have Return, Raise or fragile ops as preds. */ - if (n == get_irg_end_block(irg)) + if (n == get_irg_end_block(irg) && get_irg_phase_state(irg) != phase_backend) for (i = get_Block_n_cfgpreds(n) - 1; i >= 0; --i) { ir_node *pred = skip_Proj(get_Block_cfgpred(n, i)); if (is_Proj(pred) || get_irn_op(pred) == op_Tuple) break; /* We can not test properly. How many tuples are there? */ - ASSERT_AND_RET(((get_irn_op(pred) == op_Return) || + ASSERT_AND_RET((is_Return(pred) || is_Bad(pred) || (get_irn_op(pred) == op_Raise) || is_fragile_op(pred) ), @@ -827,6 +876,7 @@ static int verify_node_Cond(ir_node *n, ir_graph *irg) { mode_is_int(op1mode) ), "Cond node", 0 ); ASSERT_AND_RET(mymode == mode_T, "Cond mode is not a tuple", 0); + return 1; } @@ -837,7 +887,7 @@ static int verify_node_Return(ir_node *n, ir_graph *irg) { int i; ir_mode *mymode = get_irn_mode(n); ir_mode *mem_mode = get_irn_mode(get_Return_mem(n)); - type *mt; + ir_type *mt; /* Return: BB x M x data1 x ... x datan --> X */ @@ -853,7 +903,7 @@ static int verify_node_Return(ir_node *n, ir_graph *irg) { "Number of results for Return doesn't match number of results in type.", 0, show_return_nres(irg, n, mt);); for (i = get_Return_n_ress(n) - 1; i >= 0; --i) { - type *res_type = get_method_res_type(mt, i); + ir_type *res_type = get_method_res_type(mt, i); if (is_atomic_type(res_type)) { ASSERT_AND_RET_DBG( @@ -901,6 +951,11 @@ static int verify_node_Const(ir_node *n, ir_graph *irg) { mymode == mode_b) /* we want boolean constants for static evaluation */ ,"Const node", 0 /* of Cmp. */ ); + ASSERT_AND_RET( + /* the modes of the constant and teh tarval must match */ + mymode == get_tarval_mode(get_Const_tarval(n)), + "Const node, tarval and node mode mismatch", 0 + ); return 1; } @@ -911,7 +966,7 @@ static int verify_node_SymConst(ir_node *n, ir_graph *irg) { ir_mode *mymode = get_irn_mode(n); if (get_SymConst_kind(n) == symconst_addr_ent) { - entity *ent = get_SymConst_entity(n); + ir_entity *ent = get_SymConst_entity(n); if (is_Method_type(get_entity_type(ent)) && get_irn_irg(n) != get_const_code_irg()) { #if 1 @@ -937,7 +992,7 @@ static int verify_node_Sel(ir_node *n, ir_graph *irg) { ir_mode *mymode = get_irn_mode(n); ir_mode *op1mode = get_irn_mode(get_Sel_mem(n)); ir_mode *op2mode = get_irn_mode(get_Sel_ptr(n)); - entity *ent; + ir_entity *ent; ASSERT_AND_RET_DBG( /* Sel: BB x M x ref x int^n --> ref */ @@ -972,7 +1027,7 @@ static int verify_node_Call(ir_node *n, ir_graph *irg) { ir_mode *mymode = get_irn_mode(n); ir_mode *op1mode = get_irn_mode(get_Call_mem(n)); ir_mode *op2mode = get_irn_mode(get_Call_ptr(n)); - type *mt; + ir_type *mt; int i; /* Call: BB x M x ref x data1 x ... x datan @@ -1014,7 +1069,7 @@ static int verify_node_Call(ir_node *n, ir_graph *irg) { } for (i = 0; i < get_method_n_params(mt); i++) { - type *t = get_method_param_type(mt, i); + ir_type *t = get_method_param_type(mt, i); if (is_atomic_type(t)) { ASSERT_AND_RET_DBG( @@ -1236,7 +1291,7 @@ static int verify_node_Logic(ir_node *n, ir_graph *irg) { ASSERT_AND_RET_DBG( /* And or Or or Eor: BB x int x int --> int */ - mode_is_int(mymode) && + (mode_is_int(mymode) || mymode == mode_b) && op2mode == op1mode && mymode == op2mode, "And, Or or Eor node", 0, @@ -1388,6 +1443,32 @@ static int verify_node_Phi(ir_node *n, ir_graph *irg) { ); } ASSERT_AND_RET( mode_is_dataM(mymode), "Phi node", 0 ); + + if (mymode == mode_M) { + for (i = get_Phi_n_preds(n) - 1; i >= 0; --i) { + int j; + ir_node *pred_i = get_Phi_pred(n, i); + + if (is_Bad(pred_i)) + continue; + for (j = i - 1; j >= 0; --j) { + ir_node *pred_j = get_Phi_pred(n, j); + + if (is_Bad(pred_j)) + continue; +#if 0 + /* currently this checks fails for blocks with exception + outputs (and these are NOT basic blocks). So it is disabled yet. */ + ASSERT_AND_RET_DBG( + (pred_i == pred_j) || (get_irn_n(pred_i, -1) != get_irn_n(pred_j, -1)), + "At least two different PhiM predecessors are in the same block", + 0, + ir_printf("%+F and %+F of %+F are in %+F\n", pred_i, pred_j, n, get_irn_n(pred_i, -1)) + ); +#endif + } + } + } return 1; } @@ -1409,11 +1490,13 @@ static int verify_node_Load(ir_node *n, ir_graph *irg) { ir_mode *op1mode = get_irn_mode(get_Load_mem(n)); ir_mode *op2mode = get_irn_mode(get_Load_ptr(n)); - ASSERT_AND_RET( - /* Load: BB x M x ref --> M x X x data */ - op1mode == mode_M && mode_is_reference(op2mode), - "Load node", 0 - ); + ASSERT_AND_RET(op1mode == mode_M, "Load node", 0); + if(get_irg_phase_state(irg) != phase_backend) { + ASSERT_AND_RET(mode_is_reference(op2mode), "Load node", 0 ); + } else { + ASSERT_AND_RET(mode_is_reference(op2mode) || + (mode_is_int(op2mode) && get_mode_size_bits(op2mode) == get_mode_size_bits(mode_P)), "Load node", 0 ); + } ASSERT_AND_RET( mymode == mode_T, "Load node", 0 ); /* @@ -1426,7 +1509,7 @@ static int verify_node_Load(ir_node *n, ir_graph *irg) { * mode_T * { - entity *ent = hunt_for_entity (get_Load_ptr (n), n); + ir_entity *ent = hunt_for_entity (get_Load_ptr (n), n); assert ((NULL != ent) || (mymode != mode_T)); } */ @@ -1438,18 +1521,20 @@ static int verify_node_Load(ir_node *n, ir_graph *irg) { * verify a Store node */ static int verify_node_Store(ir_node *n, ir_graph *irg) { - entity *target; + ir_entity *target; ir_mode *mymode = get_irn_mode(n); ir_mode *op1mode = get_irn_mode(get_Store_mem(n)); ir_mode *op2mode = get_irn_mode(get_Store_ptr(n)); ir_mode *op3mode = get_irn_mode(get_Store_value(n)); - ASSERT_AND_RET( - /* Store: BB x M x ref x data --> M x X */ - op1mode == mode_M && mode_is_reference(op2mode) && mode_is_data(op3mode), - "Store node", 0 - ); + ASSERT_AND_RET(op1mode == mode_M && mode_is_data(op3mode), "Store node", 0 ); + if(get_irg_phase_state(irg) != phase_backend) { + ASSERT_AND_RET(mode_is_reference(op2mode), "Store node", 0 ); + } else { + ASSERT_AND_RET(mode_is_reference(op2mode) || + (mode_is_int(op2mode) && get_mode_size_bits(op2mode) == get_mode_size_bits(mode_P)), "Store node", 0 ); + } ASSERT_AND_RET(mymode == mode_T, "Store node", 0); target = get_ptr_entity(get_Store_ptr(n)); @@ -1560,44 +1645,121 @@ static int verify_node_Mux(ir_node *n, ir_graph *irg) { return 1; } -/* +/** + * verify a CopyB node + */ +static int verify_node_CopyB(ir_node *n, ir_graph *irg) { + ir_mode *mymode = get_irn_mode(n); + ir_mode *op1mode = get_irn_mode(get_CopyB_mem(n)); + ir_mode *op2mode = get_irn_mode(get_CopyB_dst(n)); + ir_mode *op3mode = get_irn_mode(get_CopyB_src(n)); + ir_type *t = get_CopyB_type(n); + + /* CopyB: BB x M x ref x ref --> M x X */ + ASSERT_AND_RET(mymode == mode_T && op1mode == mode_M, "CopyB node", 0); + if(get_irg_phase_state(irg) != phase_backend) { + ASSERT_AND_RET(mode_is_reference(op2mode) && mode_is_reference(op3mode), + "CopyB node", 0 ); + } else { + ASSERT_AND_RET(mode_is_reference(op2mode) || + (mode_is_int(op2mode) && get_mode_size_bits(op2mode) == get_mode_size_bits(mode_P)), "Load node", 0 ); + ASSERT_AND_RET(mode_is_reference(op3mode) || + (mode_is_int(op3mode) && get_mode_size_bits(op3mode) == get_mode_size_bits(mode_P)), "Load node", 0 ); + } + + ASSERT_AND_RET( + is_compound_type(t), + "CopyB node should copy compound types only", 0 ); + + /* NoMem nodes are only allowed as memory input if the CopyB is NOT pinned. + This should happen RARELY, as CopyB COPIES MEMORY */ + ASSERT_AND_RET( + (get_irn_op(get_CopyB_mem(n)) == op_NoMem) || + (get_irn_op(get_CopyB_mem(n)) != op_NoMem && get_irn_pinned(n) == op_pin_state_pinned), + "CopyB node with wrong memory input", 0 ); + return 1; +} + +/** + * verify a Bound node + */ +static int verify_node_Bound(ir_node *n, ir_graph *irg) { + ir_mode *mymode = get_irn_mode(n); + ir_mode *op1mode = get_irn_mode(get_Bound_mem(n)); + ir_mode *op2mode = get_irn_mode(get_Bound_index(n)); + ir_mode *op3mode = get_irn_mode(get_Bound_lower(n)); + ir_mode *op4mode = get_irn_mode(get_Bound_upper(n)); + + /* Bound: BB x M x ref x ref --> M x X */ + ASSERT_AND_RET( + mymode == mode_T && + op1mode == mode_M && + op2mode == op3mode && + op3mode == op4mode && + mode_is_int(op3mode), + "Bound node", 0 ); /* operand M x int x int x int */ + + /* NoMem nodes are only allowed as memory input if the Bound is NOT pinned. + This should happen RARELY, as Bound COPIES MEMORY */ + ASSERT_AND_RET( + (get_irn_op(get_Bound_mem(n)) == op_NoMem) || + (get_irn_op(get_Bound_mem(n)) != op_NoMem && get_irn_pinned(n) == op_pin_state_pinned), + "Bound node with wrong memory input", 0 ); + return 1; +} + +/** * Check dominance. * For each usage of a node, it is checked, if the block of the * node dominates the block of the usage (for phis: the predecessor * block of the phi for the corresponding edge). + * + * @return non-zero on success, 0 on dominance error */ -static int check_dominance_for_node(ir_node *irn) +static int check_dominance_for_node(ir_node *use) { - /* This won't work for blocks and the end node */ - if(!is_Block(irn) && irn != get_irg_end(get_irn_irg(irn))) { - int i, n; - ir_node *bl = get_nodes_block(irn); - - for(i = 0, n = get_irn_arity(irn); i < n; ++i) { - ir_node *op = get_irn_n(irn, i); - ir_node *def_bl = get_nodes_block(op); - ir_node *use_bl = bl; - - if(is_Phi(irn)) - use_bl = get_Block_cfgpred_block(bl, i); - - ASSERT_AND_RET(block_dominates(def_bl, use_bl), - "the definition of a value used violates the dominance property", 0); - } - } + /* This won't work for blocks and the end node */ + if (!is_Block(use) && use != get_irg_end(current_ir_graph)) { + int i; + ir_node *bl = get_nodes_block(use); - return 1; -} + for (i = get_irn_arity(use) - 1; i >= 0; --i) { + ir_node *def = get_irn_n(use, i); + ir_node *def_bl = get_nodes_block(def); + ir_node *use_bl = bl; + + /* ignore dead definition blocks, will be removed */ + if (is_Block_dead(def_bl) || get_Block_dom_depth(def_bl) == -1) + continue; + + if (is_Phi(use)) + use_bl = get_Block_cfgpred_block(bl, i); + /* ignore dead use blocks, will be removed */ + if (is_Block_dead(use_bl) || get_Block_dom_depth(use_bl) == -1) + continue; + + ASSERT_AND_RET_DBG( + block_dominates(def_bl, use_bl), + "the definition of a value used violates the dominance property", 0, + ir_fprintf(stderr, + "graph %+F: %+F of %+F must dominate %+F of user %+F input %d\n", + current_ir_graph, def_bl, def, use_bl, use, i + ); + ); + } + } + return 1; +} +/* Tests the modes of n and its predecessors. */ int irn_vrfy_irg(ir_node *n, ir_graph *irg) { int i; - int result = 1; ir_op *op; - if (!opt_do_node_verification) - return 1; + if (!get_node_verification_mode()) + return 1; if (!get_interprocedural_view()) { /* @@ -1610,30 +1772,28 @@ int irn_vrfy_irg(ir_node *n, ir_graph *irg) show_node_on_graph(irg, n); ); assert(get_irn_irg(n) == irg); + { + unsigned idx = get_irn_idx(n); + ir_node *node_from_map = get_idx_irn(irg, idx); + ASSERT_AND_RET_DBG(node_from_map == n, "Node index and index map entry differ", 0, ir_printf("node %+F node in map %+F(%p)", n, node_from_map, node_from_map)); + } } op = get_irn_op(n); /* We don't want to test nodes whose predecessors are Bad, as we would have to special case that for each operation. */ - if (op != op_Phi && op != op_Block) - for (i = get_irn_arity(n) - 1; i >= 0; --i) { - if (is_Bad(get_irn_n(n, i))) - return 1; - } - - /* - * Check, if the dominance property is fulfilled - * for all operands of the node. - */ - if(get_irg_dom_state(irg) == dom_consistent) - result &= check_dominance_for_node(n); - - if (op->verify_node) - result &= op->verify_node(n, irg); + if (op != op_Phi && op != op_Block) + for (i = get_irn_arity(n) - 1; i >= 0; --i) { + if (is_Bad(get_irn_n(n, i))) + return 1; + } + + if (op->ops.verify_node) + return op->ops.verify_node(n, irg); /* All went ok */ - return result; + return 1; } int irn_vrfy(ir_node *n) @@ -1649,15 +1809,36 @@ int irn_vrfy(ir_node *n) /* Verify the whole graph. */ /*-----------------------------------------------------------------*/ -/* This *is* used, except gcc doesn't notice that */ -static void vrfy_wrap(ir_node *node, void *env) +#ifdef DEBUG_libfirm +/** + * Walker to check every node + */ +static void vrfy_wrap(ir_node *node, void *env) { + int *res = env; + *res = irn_vrfy(node); +} + +/** + * Walker to check every node including SSA property. + * Only called if dominance info is available. + */ +static void vrfy_wrap_ssa(ir_node *node, void *env) { int *res = env; *res = irn_vrfy(node); + if (*res) + *res = check_dominance_for_node(node); } -int irg_vrfy(ir_graph *irg) +#endif /* DEBUG_libfirm */ + +/* + * Calls irn_vrfy for each node in irg. + * Graph must be in state "op_pin_state_pinned". + * If dominance info is available, check the SSA property. + */ +int irg_verify(ir_graph *irg, unsigned flags) { int res = 1; #ifdef DEBUG_libfirm @@ -1667,26 +1848,30 @@ int irg_vrfy(ir_graph *irg) current_ir_graph = irg; last_irg_error = NULL; - assert(get_irg_pinned(irg) == op_pin_state_pinned); + assert(get_irg_pinned(irg) == op_pin_state_pinned && "Verification need pinned graph"); - irg_walk_graph(irg, vrfy_wrap, NULL, &res); + if (flags & VRFY_ENFORCE_SSA) + compute_doms(irg); + + irg_walk_graph( + irg, + get_irg_dom_state(irg) == dom_consistent && + get_irg_pinned(irg) == op_pin_state_pinned ? + vrfy_wrap_ssa : vrfy_wrap, + NULL, &res + ); current_ir_graph = rem; - if (opt_do_node_verification == NODE_VERIFICATION_REPORT && ! res) { - entity *ent = get_irg_entity(current_ir_graph); + if (get_node_verification_mode() == FIRM_VERIFICATION_REPORT && ! res) { + ir_entity *ent = get_irg_entity(current_ir_graph); if (ent) fprintf(stderr, "irg_verify: Verifying graph %s failed\n", get_entity_name(ent)); else fprintf(stderr, "irg_verify: Verifying graph %p failed\n", (void *)current_ir_graph); } - - if(get_irg_dom_state(irg) == dom_consistent) { - - } - -#endif +#endif /* DEBUG_libfirm */ return res; } @@ -1694,12 +1879,15 @@ int irg_vrfy(ir_graph *irg) int irn_vrfy_irg_dump(ir_node *n, ir_graph *irg, const char **bad_string) { int res; - node_verification_t old = opt_do_node_verification; + firm_verification_t old = get_node_verification_mode(); firm_vrfy_failure_msg = NULL; - opt_do_node_verification = NODE_VERIFICATION_ERROR_ONLY; + do_node_verification(FIRM_VERIFICATION_ERROR_ONLY); res = irn_vrfy_irg(n, irg); - opt_do_node_verification = old; + if (res && get_irg_dom_state(irg) == dom_consistent && + get_irg_pinned(irg) == op_pin_state_pinned) + res = check_dominance_for_node(n); + do_node_verification(old); *bad_string = firm_vrfy_failure_msg; return res; @@ -1711,6 +1899,9 @@ typedef struct _vrfy_bad_env_t { int res; } vrfy_bad_env_t; +/** + * Pre-Walker: check Bad predecessors of node. + */ static void check_bads(ir_node *node, void *env) { vrfy_bad_env_t *venv = env; @@ -1726,10 +1917,11 @@ static void check_bads(ir_node *node, void *env) if (is_Bad(pred)) { venv->res |= BAD_CF; - if (opt_do_node_verification == NODE_VERIFICATION_REPORT) { + if (get_node_verification_mode() == FIRM_VERIFICATION_REPORT) { fprintf(stderr, "irg_vrfy_bads: Block %ld has Bad predecessor\n", get_irn_node_nr(node)); } - if (opt_do_node_verification == NODE_VERIFICATION_ON) { + if (get_node_verification_mode() == FIRM_VERIFICATION_ON) { + dump_ir_block_graph(current_ir_graph, "-assert"); assert(0 && "Bad CF detected"); } } @@ -1743,10 +1935,11 @@ static void check_bads(ir_node *node, void *env) if (is_Bad(get_nodes_block(node))) { venv->res |= BAD_BLOCK; - if (opt_do_node_verification == NODE_VERIFICATION_REPORT) { + if (get_node_verification_mode() == FIRM_VERIFICATION_REPORT) { fprintf(stderr, "irg_vrfy_bads: node %ld has Bad Block\n", get_irn_node_nr(node)); } - if (opt_do_node_verification == NODE_VERIFICATION_ON) { + if (get_node_verification_mode() == FIRM_VERIFICATION_ON) { + dump_ir_block_graph(current_ir_graph, "-assert"); assert(0 && "Bad CF detected"); } } @@ -1756,10 +1949,11 @@ static void check_bads(ir_node *node, void *env) if (get_irn_op(node) == op_Tuple) { venv->res |= TUPLE; - if (opt_do_node_verification == NODE_VERIFICATION_REPORT) { + if (get_node_verification_mode() == FIRM_VERIFICATION_REPORT) { fprintf(stderr, "irg_vrfy_bads: node %ld is a Tuple\n", get_irn_node_nr(node)); } - if (opt_do_node_verification == NODE_VERIFICATION_ON) { + if (get_node_verification_mode() == FIRM_VERIFICATION_ON) { + dump_ir_block_graph(current_ir_graph, "-assert"); assert(0 && "Tuple detected"); } } @@ -1776,10 +1970,11 @@ static void check_bads(ir_node *node, void *env) else { venv->res |= BAD_CF; - if (opt_do_node_verification == NODE_VERIFICATION_REPORT) { + if (get_node_verification_mode() == FIRM_VERIFICATION_REPORT) { fprintf(stderr, "irg_vrfy_bads: Phi %ld has Bad Input\n", get_irn_node_nr(node)); } - if (opt_do_node_verification == NODE_VERIFICATION_ON) { + if (get_node_verification_mode() == FIRM_VERIFICATION_ON) { + dump_ir_block_graph(current_ir_graph, "-assert"); assert(0 && "Bad CF detected"); } } @@ -1789,10 +1984,11 @@ static void check_bads(ir_node *node, void *env) if ((venv->flags & BAD_DF) == 0) { venv->res |= BAD_DF; - if (opt_do_node_verification == NODE_VERIFICATION_REPORT) { + if (get_node_verification_mode() == FIRM_VERIFICATION_REPORT) { fprintf(stderr, "irg_vrfy_bads: node %ld has Bad Input\n", get_irn_node_nr(node)); } - if (opt_do_node_verification == NODE_VERIFICATION_ON) { + if (get_node_verification_mode() == FIRM_VERIFICATION_ON) { + dump_ir_block_graph(current_ir_graph, "-assert"); assert(0 && "Bad NON-CF detected"); } } @@ -1802,7 +1998,7 @@ static void check_bads(ir_node *node, void *env) } /* - * verify occurance of bad nodes + * verify occurrence of bad nodes */ int irg_vrfy_bads(ir_graph *irg, int flags) { @@ -1819,14 +2015,14 @@ int irg_vrfy_bads(ir_graph *irg, int flags) /* * set the default verify operation */ -void firm_set_default_verifyer(ir_op *op) +void firm_set_default_verifyer(ir_opcode code, ir_op_ops *ops) { -#define CASE(a) \ - case iro_##a: \ - op->verify_node = verify_node_##a; \ +#define CASE(a) \ + case iro_##a: \ + ops->verify_node = verify_node_##a; \ break - switch (op->code) { + switch (code) { CASE(Proj); CASE(Block); CASE(Start); @@ -1870,17 +2066,19 @@ void firm_set_default_verifyer(ir_op *op) CASE(Sync); CASE(Confirm); CASE(Mux); + CASE(CopyB); + CASE(Bound); default: - op->verify_node = NULL; + /* leave NULL */; } #undef CASE #define CASE(a) \ case iro_##a: \ - op->verify_proj_node = verify_node_Proj_##a; \ + ops->verify_proj_node = verify_node_Proj_##a; \ break - switch (op->code) { + switch (code) { CASE(Start); CASE(Cond); CASE(Raise); @@ -1899,8 +2097,10 @@ void firm_set_default_verifyer(ir_op *op) CASE(CallBegin); CASE(EndReg); CASE(EndExcept); + CASE(CopyB); + CASE(Bound); default: - op->verify_proj_node = NULL; + /* leave NULL */; } #undef CASE }