#include "irprintf.h"
#include "irouts.h"
#include "irflag_t.h"
+#include "irpass_t.h"
/** if this flag is set, verify entity types in Load & Store nodes */
static int vrfy_entities = 0;
ir_type *ent_type = get_entity_owner(ent);
if (ent_type) {
- if (ent_type == get_glob_type())
- fprintf(stderr, "\nFIRM: irn_vrfy_irg() %s failed\n", get_entity_name(ent));
- else
- fprintf(stderr, "\nFIRM: irn_vrfy_irg() %s::%s failed\n", get_type_name(ent_type), get_entity_name(ent));
+ ir_fprintf(stderr, "\nFIRM: irn_vrfy_irg() %+F::%s failed\n",
+ ent_type, get_entity_name(ent));
} else {
fprintf(stderr, "\nFIRM: irn_vrfy_irg() <NULL>::%s failed\n", get_entity_name(ent));
}
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);
+ char type_name[256];
+ ir_print_type(type_name, sizeof(type_name), ty);
show_entity_failure(n);
fprintf(stderr, " Proj %ld mode %s proj %ld (type %s mode %s) failed\n" ,
get_irn_node_nr(n),
get_irn_modename(n),
proj,
- get_type_name(ty),
+ type_name,
get_mode_name_ex(m));
}
ir_node *op = get_Proj_pred(n);
int proj = get_Proj_proj(n);
ir_mode *m = get_type_mode(get_entity_type(ent));
+ char type_name[256];
+ ir_print_type(type_name, sizeof(type_name), get_entity_type(ent));
show_entity_failure(n);
fprintf(stderr, " node %ld %s%s %d(%s%s) entity %s(type %s mode %s)failed\n" ,
get_irn_node_nr(n),
get_irn_opname(n), get_irn_modename(n), proj,
get_irn_opname(op), get_irn_modename(op),
- get_entity_name(ent), get_type_name(get_entity_type(ent)),
+ get_entity_name(ent), type_name,
get_mode_name_ex(m));
}
*/
static void show_call_param(ir_node *n, ir_type *mt) {
int i;
+ char type_name[256];
+ ir_print_type(type_name, sizeof(type_name), mt);
show_entity_failure(n);
- fprintf(stderr, " Call type-check failed: %s(", get_type_name(mt));
+ fprintf(stderr, " Call type-check failed: %s(", type_name);
for (i = 0; i < get_method_n_params(mt); ++i) {
fprintf(stderr, "%s ", get_mode_name_ex(get_type_mode(get_method_param_type(mt, i))));
}
ASSERT_AND_RET_DBG(
(
(proj == pn_Start_X_initial_exec && mode == mode_X) ||
- (proj == pn_Start_M && mode == mode_M) ||
- (proj == pn_Start_P_frame_base && 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 */
+ (proj == pn_Start_M && mode == mode_M) ||
+ (proj == pn_Start_P_frame_base && mode_is_reference(mode)) ||
+ (proj == pn_Start_P_tls && mode_is_reference(mode)) ||
+ (proj == pn_Start_T_args && mode == mode_T)
),
"wrong Proj from Start", 0,
show_proj_failure(p);
ASSERT_AND_RET_DBG(
(
- (proj == pn_InstOf_M_regular && mode == mode_M) ||
+ (proj == pn_InstOf_M && mode == mode_M) ||
(proj == pn_InstOf_X_regular && mode == mode_X) ||
(proj == pn_InstOf_X_except && mode == mode_X) ||
- (proj == pn_InstOf_res && mode_is_reference(mode)) ||
- (proj == pn_InstOf_M_except && mode == mode_M)
+ (proj == pn_InstOf_res && mode_is_reference(mode))
),
"wrong Proj from InstOf", 0,
show_proj_failure(p);
ASSERT_AND_RET_DBG(
(
- (proj == pn_Call_M_regular && mode == mode_M) ||
+ (proj == pn_Call_M && mode == mode_M) ||
(proj == pn_Call_X_regular && mode == mode_X) ||
(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_is_reference(mode))
),
"wrong Proj from Call", 0,
ASSERT_AND_RET(
!is_NoMem(get_Call_mem(n)),
"Exception Proj from FunctionCall", 0);
- else if (proj == pn_Call_M_regular || proj == pn_Call_M_except)
+ else if (proj == pn_Call_M)
ASSERT_AND_RET(
(!is_NoMem(get_Call_mem(n)) || 1),
"Memory Proj from FunctionCall", 0);
show_proj_mode_failure(p, get_method_param_type(mt, proj));
);
}
- } else if (nr == pn_Start_P_value_arg_base) {
- ASSERT_AND_RET(
- (proj >= 0 && mode_is_reference(mode)),
- "wrong Proj from Proj from Start", 0
- );
- ASSERT_AND_RET(
- (proj < get_method_n_params(mt)),
- "More Projs for args than args in type", 0
- );
}
break;
ASSERT_AND_RET_DBG(
(
- (proj == pn_CopyB_M_regular && mode == mode_M) ||
+ (proj == pn_CopyB_M && mode == mode_M) ||
(proj == pn_CopyB_X_regular && mode == mode_X) ||
- (proj == pn_CopyB_X_except && mode == mode_X) ||
- (proj == pn_CopyB_M_except && mode == mode_M)
+ (proj == pn_CopyB_X_except && mode == mode_X)
),
"wrong Proj from CopyB", 0,
show_proj_failure(p);
verify_node_Proj(ir_node *p, ir_graph *irg) {
ir_node *pred;
ir_op *op;
- (void) irg;
pred = skip_Id(get_Proj_pred(p));
ASSERT_AND_RET(get_irn_mode(pred) == mode_T, "mode of a 'projed' node is not Tuple", 0);
+ ASSERT_AND_RET(get_irg_pinned(irg) == op_pin_state_floats || get_nodes_block(pred) == get_nodes_block(p), "Proj must be in same block as its predecessor", 0);
op = get_irn_op(pred);
/**
* verify a SymConst node
*/
-static int verify_node_SymConst(ir_node *n, ir_graph *irg) {
+static int verify_node_SymConst(ir_node *n, ir_graph *irg)
+{
ir_mode *mymode = get_irn_mode(n);
(void) irg;
- if (get_SymConst_kind(n) == symconst_addr_ent) {
- 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
- ASSERT_AND_RET((get_entity_peculiarity(ent) != peculiarity_description),
- "A constant must address an existing method.", 0);
-#endif
- }
- }
ASSERT_AND_RET(
/* SymConst: BB --> int*/
(mode_is_int(mymode) ||
get_Call_n_params(n) >= get_method_n_params(mt),
"Number of args for Call doesn't match number of args in variadic type.",
0,
- ir_fprintf(stderr, "Call %+F has %d params, method %s type %d\n",
- n, get_Call_n_params(n), get_type_name(mt), get_method_n_params(mt));
+ ir_fprintf(stderr, "Call %+F has %d params, type %d\n",
+ n, get_Call_n_params(n), get_method_n_params(mt));
);
} else {
ASSERT_AND_RET_DBG(
get_Call_n_params(n) == get_method_n_params(mt),
"Number of args for Call doesn't match number of args in non variadic type.",
0,
- ir_fprintf(stderr, "Call %+F has %d params, method %s type %d\n",
- n, get_Call_n_params(n), get_type_name(mt), get_method_n_params(mt));
+ ir_fprintf(stderr, "Call %+F has %d params, type %d\n",
+ n, get_Call_n_params(n), get_method_n_params(mt));
);
}
int i;
(void) irg;
+ /* a Phi node MUST have the same number of inputs as its block
+ * Exception is a phi with 0 inputs which is used when (re)constructing the
+ * SSA form */
if (! is_Bad(block) && get_irg_phase_state(get_irn_irg(n)) != phase_building && get_irn_arity(n) > 0) {
- /* a Phi node MUST have the same number of inputs as its block */
ASSERT_AND_RET_DBG(
get_irn_arity(n) == get_irn_arity(block),
"wrong number of inputs in Phi node", 0,
* do NOT check placement in interprocedural view, as we don't always know
* the "right" graph ...
*/
+
+#ifndef NDEBUG
+ /* this seems to be an expensive check in VS compile (9% over all runtime),
+ so do NOT run it in release mode */
ASSERT_AND_RET_DBG(
node_is_in_irgs_storage(irg, n),
"Node is not stored on proper IR graph!", 0,
show_node_on_graph(irg, n);
);
+#endif
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));
+ 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", n, node_from_map, node_from_map));
}
}
*/
static void vrfy_wrap(ir_node *node, void *env) {
int *res = env;
- *res = irn_vrfy(node);
+ *res = irn_vrfy_irg(node, current_ir_graph);
}
/**
static void vrfy_wrap_ssa(ir_node *node, void *env) {
int *res = env;
- *res = irn_vrfy(node);
+ *res = irn_vrfy_irg(node, current_ir_graph);
if (*res) {
*res = check_dominance_for_node(node);
}
NULL, &res
);
- current_ir_graph = rem;
-
if (get_node_verification_mode() == FIRM_VERIFICATION_REPORT && ! res) {
- ir_entity *ent = get_irg_entity(current_ir_graph);
+ ir_entity *ent = get_irg_entity(irg);
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);
+ fprintf(stderr, "irg_verify: Verifying graph %p failed\n", (void *)irg);
}
+
+ current_ir_graph = rem;
#else
(void)irg;
(void)flags;
return res;
}
+struct pass_t {
+ ir_graph_pass_t pass;
+ unsigned flags;
+};
+
+/**
+ * Wrapper to irg_verify to be run as an ir_graph pass.
+ */
+static int irg_verify_wrapper(ir_graph *irg, void *context) {
+ struct pass_t *pass = context;
+ irg_verify(irg, pass->flags);
+ /* do NOT rerun the pass if verify is ok :-) */
+ return 0;
+}
+
+/* Creates an ir_graph pass for irg_verify(). */
+ir_graph_pass_t *irg_verify_pass(const char *name, unsigned flags) {
+ struct pass_t *pass = XMALLOCZ(struct pass_t);
+
+ def_graph_pass_constructor(
+ &pass->pass, name ? name : "irg_verify", irg_verify_wrapper);
+
+ /* neither dump for verify */
+ pass->pass.dump_irg = (DUMP_ON_IRG_FUNC)ir_prog_no_dump;
+ pass->pass.verify_irg = (RUN_ON_IRG_FUNC)ir_prog_no_verify;
+
+ pass->flags = flags;
+ return &pass->pass;
+}
+
+/* create a verify pass */
int irn_vrfy_irg_dump(ir_node *n, ir_graph *irg, const char **bad_string) {
int res;
firm_verification_t old = get_node_verification_mode();