* Modified by: Goetz Lindenmaier. Till Riedel. Michael Beck.
* Created:
* CVS-ID: $Id$
- * Copyright: (c) 1998-2003 Universit�t Karlsruhe
+ * Copyright: (c) 1998-2003 Universität Karlsruhe
* Licence: This file protected by GPL - GNU GENERAL PUBLIC LICENSE.
*/
# 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 "irprintf.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 */
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;
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())
/**
* 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);
*/
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;
/**
* 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);
/**
* 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);
(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 */
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);
break;
default:
- ASSERT_AND_RET(0, "Unknown opcode", 0);
+ /* ASSERT_AND_RET(0, "Unknown opcode", 0); */
+ break;
}
return 1;
}
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);
+
+ 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
*/
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;
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) ),
mode_is_int(op1mode) ), "Cond node", 0
);
ASSERT_AND_RET(mymode == mode_T, "Cond mode is not a tuple", 0);
+
return 1;
}
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 */
"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(
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;
}
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
}
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(
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,
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 &&
+ mode_is_reference(op2mode) &&
+ mode_is_reference(op3mode),
+ "CopyB node", 0 ); /* operand M x ref x ref */
+
+ 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).
*/
-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(current_ir_graph)) {
- 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_DBG(block_dominates(def_bl, use_bl),
- "the definition of a value used violates the dominance property", 0,
- ir_fprintf(stderr,
- "graph %+F: %+F in %+F must dominate user %+F in %+F\n",
- current_ir_graph, op, def_bl, irn, use_bl););
- }
- }
+ /* 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;
ir_op *op;
- if (!opt_do_node_verification)
- return 1;
+ if (!get_node_verification_mode())
+ return 1;
if (!get_interprocedural_view()) {
/*
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;
- }
+ 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->verify_node)
- return op->verify_node(n, irg);
+ if (op->ops.verify_node)
+ return op->ops.verify_node(n, irg);
/* All went ok */
return 1;
/* 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 && get_irg_dom_state(current_ir_graph) == dom_consistent)
-// *res = check_dominance_for_node(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
current_ir_graph = irg;
last_irg_error = NULL;
- assert(get_irg_pinned(irg) == op_pin_state_pinned);
- irg_walk_graph(irg, vrfy_wrap, NULL, &res);
+ assert(get_irg_pinned(irg) == op_pin_state_pinned && "Verification need pinned graph");
+
+ 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) {
+ if (get_node_verification_mode() == FIRM_VERIFICATION_REPORT && ! res) {
entity *ent = get_irg_entity(current_ir_graph);
if (ent)
else
fprintf(stderr, "irg_verify: Verifying graph %p failed\n", (void *)current_ir_graph);
}
-
-
-#endif
+#endif /* DEBUG_libfirm */
return res;
}
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;
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;
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) {
assert(0 && "Bad CF detected");
}
}
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) {
assert(0 && "Bad CF detected");
}
}
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) {
assert(0 && "Tuple detected");
}
}
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) {
assert(0 && "Bad CF detected");
}
}
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) {
assert(0 && "Bad NON-CF detected");
}
}
}
/*
- * verify occurance of bad nodes
+ * verify occurrence of bad nodes
*/
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(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);
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);
CASE(CallBegin);
CASE(EndReg);
CASE(EndExcept);
+ CASE(CopyB);
+ CASE(Bound);
default:
- op->verify_proj_node = NULL;
+ /* leave NULL */;
}
#undef CASE
}
projects / libfirm / blobdiff