#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_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);
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 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,
*/
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();