#define ASSERT_AND_RET(expr, string, ret) \
do { \
if (opt_do_node_verification == NODE_VERIFICATION_ON) {\
- if (!(expr)) dump_ir_block_graph(current_ir_graph, "-assert"); \
+ if (!(expr) && current_ir_graph != get_const_code_irg()) \
+ dump_ir_block_graph(current_ir_graph, "-assert"); \
assert((expr) && string); } \
if (!(expr)) { \
if (opt_do_node_verification == NODE_VERIFICATION_REPORT) \
#endif
+/** if this flag is set, verify entity types in Load & Store nodes */
+static int vrfy_entities = 0;
+
/* @@@ replace use of array "in" by access functions. */
ir_node **get_irn_in(ir_node *node);
static node_verification_t opt_do_node_verification = NODE_VERIFICATION_ON;
static const char *bad_msg;
+/* enable verification of Load/Store entities */
+void vrfy_enable_entity_tests(int enable)
+{
+ vrfy_entities = enable;
+}
+
/**
* little helper for NULL modes
*/
"wrong Proj from Call", 0,
show_proj_failure(p);
);
- break;
- case iro_FuncCall:
- ASSERT_AND_RET_DBG(
- ((proj == pn_Call_M_regular && mode == mode_M) ||
- (proj == pn_Call_X_except && mode == mode_X) ||
- (proj == pn_Call_T_result && mode == mode_T) ||
- (proj == pn_Call_M_except && mode == mode_M) ||
- (proj == pn_Call_P_value_res_base && mode == mode_P)),
- "wrong Proj from FuncCall", 0,
- show_proj_failure(p);
- );
break;
case iro_Quot:
(proj == pn_Div_X_except && mode == mode_X) ||
(proj == pn_Div_res && mode_is_int(mode))),
"wrong Proj from Div or Mod", 0,
- show_proj_failure(p);
+ show_proj_failure(p);
);
break;
if (proj == pn_Load_res) {
ir_node *ptr = get_Load_ptr(pred);
entity *ent = get_ptr_entity(ptr);
- if (ent) {
+
+ if (vrfy_entities && ent && get_irg_phase_state(current_ir_graph) == phase_high) {
+ /* do NOT check this for lowered phases, see comment on Store */
ASSERT_AND_RET_DBG(
(mode == get_type_mode(get_entity_type(ent))),
"wrong data Proj from Load, entity type_mode failed", 0,
}
else {
ASSERT_AND_RET_DBG(
- mode_is_data(mode),
+ mode_is_data(mode) && mode == get_Load_mode(pred),
"wrong data Proj from Load", 0,
show_proj_failure(p);
);
((proj == pn_Store_M && mode == mode_M) ||
(proj == pn_Store_X_except && mode == mode_X)),
"wrong Proj from Store", 0,
- show_proj_failure(p);
+ show_proj_failure(p);
);
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_FuncCall:
- {
- ASSERT_AND_RET(
- (proj >= 0 && mode_is_data(mode)),
- "wrong Proj from Proj from FuncCall", 0);
- mt = get_FuncCall_type(pred);
- ASSERT_AND_RET(
- (proj < 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 FuncCall doesn't match mode of result type.", 0);
}
break;
if (!opt_do_node_verification) return 1;
- if (! interprocedural_view) {
+ if (! get_interprocedural_view()) {
/*
* do NOT check placement in interprocedural view, as we don't always know
* the "right" graph ...
"End Block node", 0);
}
/* irg attr must == graph we are in. */
- if (! interprocedural_view) {
+ if (! get_interprocedural_view()) {
ASSERT_AND_RET(((get_irn_irg(n) && get_irn_irg(n) == irg)), "Block node has wrong irg attribute", 0);
}
/* Call: BB x M x ref x data1 x ... x datan
--> M x datan+1 x ... x data n+m */
ASSERT_AND_RET( op1mode == mode_M && mode_is_reference(op2mode), "Call node", 0 ); /* operand M x ref */
+
+ mt = get_Call_type(n);
+ if(get_unknown_type() == mt) {
+ break;
+ }
+
for (i=3; i < get_irn_arity(n); i++) {
ASSERT_AND_RET( mode_is_data(get_irn_mode(in[i])), "Call node", 0 ); /* operand datai */
};
ASSERT_AND_RET( mymode == mode_T, "Call result not a tuple", 0 ); /* result T */
/* Compare arguments of node with those of type */
- mt = get_Call_type(n);
if (get_method_variadicity(mt) == variadicity_variadic) {
ASSERT_AND_RET_DBG(
}
for (i = 0; i < get_method_n_params(mt); i++) {
- type *t = get_method_param_type(mt, i);
+ type *t = get_method_param_type(mt, i);
- if (is_atomic_type(t)) {
- ASSERT_AND_RET_DBG(
- get_irn_mode(get_Call_param(n, i)) == get_type_mode(t),
- "Mode of arg for Call doesn't match mode of arg type.", 0,
- show_call_param(n, mt);
- );
- }
- else {
- /* call with a compound type, mode must be reference */
- ASSERT_AND_RET_DBG(
- mode_is_reference(get_irn_mode(get_Call_param(n, i))),
- "Mode of arg for Call doesn't match mode of arg type.", 0,
- show_call_param(n, mt);
- );
- }
+ if (is_atomic_type(t)) {
+ ASSERT_AND_RET_DBG(
+ get_irn_mode(get_Call_param(n, i)) == get_type_mode(t),
+ "Mode of arg for Call doesn't match mode of arg type.", 0,
+ show_call_param(n, mt);
+ );
+ }
+ else {
+ /* call with a compound type, mode must be reference */
+ ASSERT_AND_RET_DBG(
+ mode_is_reference(get_irn_mode(get_Call_param(n, i))),
+ "Mode of arg for Call doesn't match mode of arg type.", 0,
+ show_call_param(n, mt);
+ );
+ }
+ }
+
+#if 0
+ if (Call_has_callees(n)) {
+ for (i = 0; i < get_Call_n_callees(n); i++) {
+ ASSERT_AND_RET(is_entity(get_Call_callee(n, i)), "callee array must contain entities.", 0);
+ }
}
+#endif
break;
case iro_Add:
ASSERT_AND_RET(mymode == mode_T, "Store node", 0);
entity *target = get_ptr_entity(in[2]);
- if (target) {
- ASSERT_AND_RET(op3mode == get_type_mode(get_entity_type(target)), "Store node", 0);
+ if (vrfy_entities && target && get_irg_phase_state(current_ir_graph) == phase_high) {
+ /*
+ * If lowered code, any Sels that add 0 may be removed, causing
+ * an direct access to entities of array or compound type.
+ * Prevent this by checking the phase.
+ */
+ ASSERT_AND_RET( op3mode == get_type_mode(get_entity_type(target)),
+ "Store node", 0);
}
break;
assert(get_irg_pinned(irg) == op_pin_state_pinned);
- irg_walk(irg->end, vrfy_wrap, NULL, &res);
+ irg_walk_graph(irg, vrfy_wrap, NULL, &res);
current_ir_graph = rem;
return res;
}
+
+
+typedef struct _vrfy_bad_env_t {
+ int flags;
+ int res;
+} vrfy_bad_env_t;
+
+static void check_bads(ir_node *node, void *env)
+{
+ vrfy_bad_env_t *venv = env;
+ int i, arity = get_irn_arity(node);
+
+ if (is_Block(node)) {
+ if ((venv->flags & BAD_CF) == 0) {
+
+ /* check for Bad Block predecessor */
+ for (i = 0; i < arity; ++i) {
+ ir_node *pred = get_irn_n(node, i);
+
+ if (is_Bad(pred)) {
+ venv->res |= BAD_CF;
+
+ if (opt_do_node_verification == NODE_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) {
+ assert(0 && "Bad CF detected");
+ }
+ }
+ }
+ }
+ }
+ else {
+ if ((venv->flags & BAD_BLOCK) == 0) {
+
+ /* check for Bad Block */
+ if (is_Bad(get_nodes_block(node))) {
+ venv->res |= BAD_BLOCK;
+
+ if (opt_do_node_verification == NODE_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) {
+ assert(0 && "Bad CF detected");
+ }
+ }
+ }
+
+ if ((venv->flags & TUPLE) == 0) {
+ if (get_irn_op(node) == op_Tuple) {
+ venv->res |= TUPLE;
+
+ if (opt_do_node_verification == NODE_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) {
+ assert(0 && "Tuple detected");
+ }
+ }
+ }
+
+ for (i = 0; i < arity; ++i) {
+ ir_node *pred = get_irn_n(node, i);
+
+ if (is_Bad(pred)) {
+ /* check for Phi with Bad inputs */
+ if (is_Phi(node) && !is_Bad(get_nodes_block(node)) && is_Bad(get_irn_n(get_nodes_block(node), i))) {
+ if (venv->flags & BAD_CF)
+ continue;
+ else {
+ venv->res |= BAD_CF;
+
+ if (opt_do_node_verification == NODE_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) {
+ assert(0 && "Bad CF detected");
+ }
+ }
+ }
+
+ /* Bad node input */
+ if ((venv->flags & BAD_DF) == 0) {
+ venv->res |= BAD_DF;
+
+ if (opt_do_node_verification == NODE_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) {
+ assert(0 && "Bad NON-CF detected");
+ }
+ }
+ }
+ }
+ }
+}
+
+/*
+ * verify occurance of bad nodes
+ */
+int irg_vrfy_bads(ir_graph *irg, int flags)
+{
+ vrfy_bad_env_t env;
+
+ env.flags = flags;
+ env.res = 0;
+
+ irg_walk_graph(irg, check_bads, NULL, &env);
+
+ return env.res;
+}