#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;
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);
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,
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 );
ASSERT_AND_RET(op1mode == mode_M && mode_is_datab(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);
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)), "CopyB node", 0 );
- ASSERT_AND_RET(mode_is_reference(op3mode) ||
- (mode_is_int(op3mode) && get_mode_size_bits(op3mode) == get_mode_size_bits(mode_P)), "CopyB node", 0 );
}
ASSERT_AND_RET(
* 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();