3 * File name: ir/ir/irvrfy.c
4 * Purpose: Check irnodes for correctness.
5 * Author: Christian Schaefer
6 * Modified by: Goetz Lindenmaier. Till Riedel. Michael Beck.
9 * Copyright: (c) 1998-2003 Universit�t Karlsruhe
10 * Licence: This file protected by GPL - GNU GENERAL PUBLIC LICENSE.
19 # include "irgraph_t.h"
20 # include "ircgcons.h"
21 # include "irvrfy_t.h"
25 # include "irprintf.h"
27 /** if this flag is set, verify entity types in Load & Store nodes */
28 static int vrfy_entities = 0;
30 node_verification_t opt_do_node_verification = NODE_VERIFICATION_ON;
31 const char *firm_vrfy_failure_msg;
33 /* enable verification of Load/Store entities */
34 void vrfy_enable_entity_tests(int enable) {
35 vrfy_entities = enable;
39 * little helper for NULL modes
41 static const char *get_mode_name_ex(ir_mode *mode) {
44 return get_mode_name(mode);
47 void do_node_verification(node_verification_t mode) {
48 opt_do_node_verification = mode;
51 /** the last IRG, on which a verify error was found */
52 static ir_graph *last_irg_error = NULL;
55 * print the name of the entity of an verification failure
57 static void show_entity_failure(ir_node *node)
59 ir_graph *irg = get_irn_irg(node);
61 if (last_irg_error == irg)
66 if (irg == get_const_code_irg()) {
67 fprintf(stderr, "\nFIRM: irn_vrfy_irg() <of CONST_CODE_IRG> failed\n");
70 entity *ent = get_irg_entity(irg);
73 type *ent_type = get_entity_owner(ent);
76 if (ent_type == get_glob_type())
77 fprintf(stderr, "\nFIRM: irn_vrfy_irg() %s failed\n", get_entity_name(ent));
79 fprintf(stderr, "\nFIRM: irn_vrfy_irg() %s::%s failed\n", get_type_name(ent_type), get_entity_name(ent));
82 fprintf(stderr, "\nFIRM: irn_vrfy_irg() <NULL>::%s failed\n", get_entity_name(ent));
86 fprintf(stderr, "\nFIRM: irn_vrfy_irg() <IRG %p> failed\n", (void *)irg);
92 * Prints a failure for a Node
94 static void show_node_failure(ir_node *n)
96 show_entity_failure(n);
97 fprintf(stderr, " node %ld %s%s\n" ,
99 get_irn_opname(n), get_irn_modename(n)
104 * Prints a failure message for a binop
106 static void show_binop_failure(ir_node *n, const char *text)
108 ir_node *left = get_binop_left(n);
109 ir_node *right = get_binop_right(n);
111 show_entity_failure(n);
112 fprintf(stderr, " node %ld %s%s(%s%s, %s%s) did not match (%s)\n",
114 get_irn_opname(n), get_irn_modename(n),
115 get_irn_opname(left), get_irn_modename(left),
116 get_irn_opname(right), get_irn_modename(right),
121 * Prints a failure message for an unop
123 static void show_unop_failure(ir_node *n, const char *text)
125 ir_node *op = get_unop_op(n);
127 show_entity_failure(n);
128 fprintf(stderr, " node %ld %s%s(%s%s) did not match (%s)\n",
130 get_irn_opname(n), get_irn_modename(n),
131 get_irn_opname(op), get_irn_modename(op),
136 * Prints a failure message for an op with 3 operands
138 static void show_triop_failure(ir_node *n, const char *text)
140 ir_node *op0 = get_irn_n(n, 0);
141 ir_node *op1 = get_irn_n(n, 1);
142 ir_node *op2 = get_irn_n(n, 2);
144 show_entity_failure(n);
145 fprintf(stderr, " of node %ld %s%s(%s%s, %s%s, %s%s) did not match (%s)\n",
147 get_irn_opname(n), get_irn_modename(n),
148 get_irn_opname(op0), get_irn_modename(op0),
149 get_irn_opname(op1), get_irn_modename(op1),
150 get_irn_opname(op2), get_irn_modename(op2),
155 * Prints a failure message for a proj
157 static void show_proj_failure(ir_node *n)
159 ir_node *op = get_Proj_pred(n);
160 int proj = get_Proj_proj(n);
162 show_entity_failure(n);
163 fprintf(stderr, " node %ld %s%s %d(%s%s) failed\n" ,
165 get_irn_opname(n), get_irn_modename(n), proj,
166 get_irn_opname(op), get_irn_modename(op));
170 * Prints a failure message for a proj from Start
172 static void show_proj_mode_failure(ir_node *n, type *ty)
174 long proj = get_Proj_proj(n);
175 ir_mode *m = get_type_mode(ty);
177 show_entity_failure(n);
178 fprintf(stderr, " Proj %ld mode %s proj %ld (type %s mode %s) failed\n" ,
183 get_mode_name_ex(m));
187 * Prints a failure message for a proj
189 static void show_proj_failure_ent(ir_node *n, entity *ent)
191 ir_node *op = get_Proj_pred(n);
192 int proj = get_Proj_proj(n);
193 ir_mode *m = get_type_mode(get_entity_type(ent));
195 show_entity_failure(n);
196 fprintf(stderr, " node %ld %s%s %d(%s%s) entity %s(type %s mode %s)failed\n" ,
198 get_irn_opname(n), get_irn_modename(n), proj,
199 get_irn_opname(op), get_irn_modename(op),
200 get_entity_name(ent), get_type_name(get_entity_type(ent)),
201 get_mode_name_ex(m));
205 * Show a node and a graph
207 static void show_node_on_graph(ir_graph *irg, ir_node *n)
209 entity *ent = get_irg_entity(irg);
212 fprintf(stderr, "\nFIRM: irn_vrfy_irg() of entity %s, node %ld %s%s\n",
213 get_entity_name(ent),
214 get_irn_node_nr(n), get_irn_opname(n), get_irn_modename(n));
216 fprintf(stderr, "\nFIRM: irn_vrfy_irg() of graph %p, node %ld %s%s\n",
218 get_irn_node_nr(n), get_irn_opname(n), get_irn_modename(n));
224 static void show_call_param(ir_node *n, type *mt)
228 show_entity_failure(n);
229 fprintf(stderr, " Call type-check failed: %s(", get_type_name(mt));
230 for (i = 0; i < get_method_n_params(mt); ++i) {
231 fprintf(stderr, "%s ", get_mode_name_ex(get_type_mode(get_method_param_type(mt, i))));
233 fprintf(stderr, ") != CALL(");
235 for (i = 0; i < get_Call_n_params(n); ++i) {
236 fprintf(stderr, "%s ", get_mode_name_ex(get_irn_mode(get_Call_param(n, i))));
238 fprintf(stderr, ")\n");
245 static void show_return_modes(ir_graph *irg, ir_node *n, type *mt, int i)
247 entity *ent = get_irg_entity(irg);
249 show_entity_failure(n);
250 fprintf(stderr, " Return node %ld in entity \"%s\" mode %s different from type mode %s\n",
251 get_irn_node_nr(n), get_entity_name(ent),
252 get_mode_name_ex(get_irn_mode(get_Return_res(n, i))),
253 get_mode_name_ex(get_type_mode(get_method_res_type(mt, i)))
258 * Show return number of results
260 static void show_return_nres(ir_graph *irg, ir_node *n, type *mt)
262 entity *ent = get_irg_entity(irg);
264 show_entity_failure(n);
265 fprintf(stderr, " Return node %ld in entity \"%s\" has %d results different from type %d\n",
266 get_irn_node_nr(n), get_entity_name(ent),
267 get_Return_n_ress(n), get_method_n_ress(mt));
273 static void show_phi_failure(ir_node *phi, ir_node *pred, int pos)
275 show_entity_failure(phi);
276 fprintf(stderr, " Phi node %ld has mode %s different from predeccessor node %ld mode %s\n",
277 get_irn_node_nr(phi), get_mode_name_ex(get_irn_mode(phi)),
278 get_irn_node_nr(pred), get_mode_name_ex(get_irn_mode(pred)));
284 static void show_phi_inputs(ir_node *phi, ir_node *block)
286 show_entity_failure(phi);
287 fprintf(stderr, " Phi node %ld has %d inputs, its Block %ld has %d\n",
288 get_irn_node_nr(phi), get_irn_arity(phi),
289 get_irn_node_nr(block), get_irn_arity(block));
292 /** If the address is Sel or SymConst, return the entity. */
293 static entity *get_ptr_entity(ir_node *ptr) {
294 if (get_irn_op(ptr) == op_Sel) {
295 return get_Sel_entity(ptr);
296 } else if ((get_irn_op(ptr) == op_SymConst) && (get_SymConst_kind(ptr) == symconst_addr_ent)) {
297 return get_SymConst_entity(ptr);
303 * verify a Proj(Start) node
305 static int verify_node_Proj_Start(ir_node *n, ir_node *p) {
306 ir_mode *mode = get_irn_mode(p);
307 long proj = get_Proj_proj(p);
311 (proj == pn_Start_X_initial_exec && mode == mode_X) ||
312 (proj == pn_Start_M && mode == mode_M) ||
313 (proj == pn_Start_P_frame_base && mode_is_reference(mode)) ||
314 (proj == pn_Start_P_globals && mode_is_reference(mode)) ||
315 (proj == pn_Start_T_args && mode == mode_T) ||
316 (proj == pn_Start_P_value_arg_base && mode_is_reference(mode)) ||
317 (proj == pn_Start_P_value_arg_base && mode == mode_T) /* FIXME: only one of those */
319 "wrong Proj from Start", 0,
320 show_proj_failure(p);
326 * verify a Proj(Cond) node
328 static int verify_node_Proj_Cond(ir_node *pred, ir_node *p) {
329 ir_mode *mode = get_irn_mode(p);
330 long proj = get_Proj_proj(p);
334 (proj >= 0 && mode == mode_X && get_irn_mode(get_Cond_selector(pred)) == mode_b) || /* compare */
335 (mode == mode_X && mode_is_int(get_irn_mode(get_Cond_selector(pred)))) || /* switch */
336 is_Bad(get_Cond_selector(pred)) /* rare */
338 "wrong Proj from Cond", 0,
339 show_proj_failure(p);
345 * verify a Proj(Raise) node
347 static int verify_node_Proj_Raise(ir_node *n, ir_node *p) {
348 ir_mode *mode = get_irn_mode(p);
349 long proj = get_Proj_proj(p);
352 ((proj == pn_Raise_X && mode == mode_X) || (proj == pn_Raise_M && mode == mode_M)),
353 "wrong Proj from Raise", 0,
354 show_proj_failure(p);
360 * verify a Proj(InstOf) node
362 static int verify_node_Proj_InstOf(ir_node *n, ir_node *p) {
363 ir_mode *mode = get_irn_mode(p);
364 long proj = get_Proj_proj(p);
367 (proj >= 0 && mode == mode_X),
368 "wrong Proj from InstOf", 0,
369 show_proj_failure(p);
375 * verify a Proj(Call) node
377 static int verify_node_Proj_Call(ir_node *n, ir_node *p) {
378 ir_mode *mode = get_irn_mode(p);
379 long proj = get_Proj_proj(p);
382 ((proj == pn_Call_M_regular && mode == mode_M) ||
383 (proj == pn_Call_X_except && mode == mode_X) ||
384 (proj == pn_Call_T_result && mode == mode_T) ||
385 (proj == pn_Call_M_except && mode == mode_M) ||
386 (proj == pn_Call_P_value_res_base && mode == mode_P)),
387 "wrong Proj from Call", 0,
388 show_proj_failure(p);
390 if (proj == pn_Call_X_except)
392 get_irn_op(get_Call_mem(n)) != op_NoMem,
393 "Exception Proj from FunctionCall", 0);
394 else if (proj == pn_Call_M_regular || proj == pn_Call_M_except)
396 (get_irn_op(get_Call_mem(n)) != op_NoMem || 1),
397 "Memory Proj from FunctionCall", 0);
402 * verify a Proj(Quot) node
404 static int verify_node_Proj_Quot(ir_node *n, ir_node *p) {
405 ir_mode *mode = get_irn_mode(p);
406 long proj = get_Proj_proj(p);
409 ((proj == pn_Quot_M && mode == mode_M) ||
410 (proj == pn_Quot_X_except && mode == mode_X) ||
411 (proj == pn_Quot_res && mode_is_float(mode))),
412 "wrong Proj from Quot", 0,
413 show_proj_failure(p);
415 if (proj == pn_Quot_X_except)
417 get_irn_pinned(n) == op_pin_state_pinned,
418 "Exception Proj from unpinned Quot", 0);
419 else if (proj == pn_Quot_M)
421 get_irn_pinned(n) == op_pin_state_pinned,
422 "Memory Proj from unpinned Quot", 0);
427 * verify a Proj(DivMod) node
429 static int verify_node_Proj_DivMod(ir_node *n, ir_node *p) {
430 ir_mode *mode = get_irn_mode(p);
431 long proj = get_Proj_proj(p);
434 ((proj == pn_DivMod_M && mode == mode_M) ||
435 (proj == pn_DivMod_X_except && mode == mode_X) ||
436 (proj == pn_DivMod_res_div && mode_is_int(mode)) ||
437 (proj == pn_DivMod_res_mod && mode_is_int(mode))),
438 "wrong Proj from DivMod", 0,
439 show_proj_failure(p);
441 if (proj == pn_DivMod_X_except)
443 get_irn_pinned(n) == op_pin_state_pinned,
444 "Exception Proj from unpinned DivMod", 0);
445 else if (proj == pn_DivMod_M)
447 get_irn_pinned(n) == op_pin_state_pinned,
448 "Memory Proj from unpinned DivMod", 0);
453 * verify a Proj(Div) node
455 static int verify_node_Proj_Div(ir_node *n, ir_node *p) {
456 ir_mode *mode = get_irn_mode(p);
457 long proj = get_Proj_proj(p);
460 ((proj == pn_Div_M && mode == mode_M) ||
461 (proj == pn_Div_X_except && mode == mode_X) ||
462 (proj == pn_Div_res && mode_is_int(mode))),
463 "wrong Proj from Div", 0,
464 show_proj_failure(p);
466 if (proj == pn_Div_X_except)
468 get_irn_pinned(n) == op_pin_state_pinned,
469 "Exception Proj from unpinned Div", 0);
470 else if (proj == pn_Div_M)
472 get_irn_pinned(n) == op_pin_state_pinned,
473 "Memory Proj from unpinned Div", 0);
478 * verify a Proj(Mod) node
480 static int verify_node_Proj_Mod(ir_node *n, ir_node *p) {
481 ir_mode *mode = get_irn_mode(p);
482 long proj = get_Proj_proj(p);
485 ((proj == pn_Mod_M && mode == mode_M) ||
486 (proj == pn_Mod_X_except && mode == mode_X) ||
487 (proj == pn_Mod_res && mode_is_int(mode))),
488 "wrong Proj from Mod", 0,
489 show_proj_failure(p);
491 if (proj == pn_Mod_X_except)
493 get_irn_pinned(n) == op_pin_state_pinned,
494 "Exception Proj from unpinned Mod", 0);
495 else if (proj == pn_Mod_M)
497 get_irn_pinned(n) == op_pin_state_pinned,
498 "Memory Proj from unpinned Div", 0);
503 * verify a Proj(Cmp) node
505 static int verify_node_Proj_Cmp(ir_node *n, ir_node *p) {
506 ir_mode *mode = get_irn_mode(p);
507 long proj = get_Proj_proj(p);
510 (proj >= 0 && proj <= 15 && mode == mode_b),
511 "wrong Proj from Cmp", 0,
512 show_proj_failure(p);
518 * verify a Proj(Load) node
520 static int verify_node_Proj_Load(ir_node *n, ir_node *p) {
521 ir_mode *mode = get_irn_mode(p);
522 long proj = get_Proj_proj(p);
524 if (proj == pn_Load_res) {
525 ir_node *ptr = get_Load_ptr(n);
526 entity *ent = get_ptr_entity(ptr);
528 if (vrfy_entities && ent && get_irg_phase_state(current_ir_graph) == phase_high) {
529 /* do NOT check this for lowered phases, see comment on Store */
531 (mode == get_type_mode(get_entity_type(ent))),
532 "wrong data Proj from Load, entity type_mode failed", 0,
533 show_proj_failure_ent(p, ent);
538 mode_is_data(mode) && mode == get_Load_mode(n),
539 "wrong data Proj from Load", 0,
540 show_proj_failure(p);
546 ((proj == pn_Load_M && mode == mode_M) ||
547 (proj == pn_Load_X_except && mode == mode_X)),
548 "wrong Proj from Load", 0,
549 show_proj_failure(p);
552 if (proj == pn_Load_X_except)
554 get_irn_pinned(n) == op_pin_state_pinned,
555 "Exception Proj from unpinned Load", 0);
560 * verify a Proj(Store) node
562 static int verify_node_Proj_Store(ir_node *n, ir_node *p) {
563 ir_mode *mode = get_irn_mode(p);
564 long proj = get_Proj_proj(p);
567 ((proj == pn_Store_M && mode == mode_M) ||
568 (proj == pn_Store_X_except && mode == mode_X)),
569 "wrong Proj from Store", 0,
570 show_proj_failure(p);
572 if (proj == pn_Store_X_except)
574 get_irn_pinned(n) == op_pin_state_pinned,
575 "Exception Proj from unpinned Store", 0);
580 * verify a Proj(Alloc) node
582 static int verify_node_Proj_Alloc(ir_node *n, ir_node *p) {
583 ir_mode *mode = get_irn_mode(p);
584 long proj = get_Proj_proj(p);
588 (proj == pn_Alloc_M && mode == mode_M) ||
589 (proj == pn_Alloc_X_except /* && mode == mode_X*/) ||
590 (proj == pn_Alloc_res && mode_is_reference(mode))
592 "wrong Proj from Alloc", 0,
593 show_proj_failure(p);
599 * verify a Proj(Proj) node
601 static int verify_node_Proj_Proj(ir_node *pred, ir_node *p) {
602 ir_mode *mode = get_irn_mode(p);
603 long proj = get_Proj_proj(p);
604 long nr = get_Proj_proj(pred);
605 type *mt; /* A method type */
607 pred = skip_Id(get_Proj_pred(pred));
608 ASSERT_AND_RET((get_irn_mode(pred) == mode_T), "Proj from something not a tuple", 0);
610 switch (get_irn_opcode(pred)) {
612 mt = get_entity_type(get_irg_entity(get_irn_irg(pred)));
614 if (nr == pn_Start_T_args) {
616 (proj >= 0 && mode_is_data(mode)),
617 "wrong Proj from Proj from Start", 0);
619 (proj < get_method_n_params(mt)),
620 "More Projs for args than args in type", 0
622 if ((mode_is_reference(mode)) && is_compound_type(get_method_param_type(mt, proj)))
623 /* value argument */ break;
626 (mode == get_type_mode(get_method_param_type(mt, proj))),
627 "Mode of Proj from Start doesn't match mode of param type.", 0,
628 show_proj_mode_failure(p, get_method_param_type(mt, proj));
631 else if (nr == pn_Start_P_value_arg_base) {
633 (proj >= 0 && mode_is_reference(mode)),
634 "wrong Proj from Proj from Start", 0
637 (proj < get_method_n_params(mt)),
638 "More Projs for args than args in type", 0
646 (proj >= 0 && mode_is_data(mode)),
647 "wrong Proj from Proj from Call", 0);
648 mt = get_Call_type(pred);
650 (proj < get_method_n_ress(mt)),
651 "More Projs for results than results in type.", 0);
652 if ((mode_is_reference(mode)) && is_compound_type(get_method_res_type(mt, proj)))
653 /* value result */ break;
656 (mode == get_type_mode(get_method_res_type(mt, proj))),
657 "Mode of Proj from Call doesn't match mode of result type.", 0);
666 /* hmm, optimization did not remove it */
670 ASSERT_AND_RET(0, "Unknown opcode", 0);
676 * verify a Proj(Tuple) node
678 static int verify_node_Proj_Tuple(ir_node *n, ir_node *p) {
684 * verify a Proj(CallBegin) node
686 static int verify_node_Proj_CallBegin(ir_node *n, ir_node *p) {
691 * verify a Proj(EndReg) node
693 static int verify_node_Proj_EndReg(ir_node *n, ir_node *p) {
694 ASSERT_AND_RET((get_irp_ip_view_state() != ip_view_no),
695 "EndReg may only appear if ip view is constructed.", 0);
700 * verify a Proj(EndExcept) node
702 static int verify_node_Proj_EndExcept(ir_node *n, ir_node *p) {
703 ASSERT_AND_RET((get_irp_ip_view_state() != ip_view_no),
704 "EndExcept may only appear if ip view is constructed.", 0);
712 verify_node_Proj(ir_node *p, ir_graph *irg) {
716 pred = skip_Id(get_Proj_pred(p));
717 ASSERT_AND_RET(get_irn_mode(pred) == mode_T, "mode of a 'projed' node is not Tuple", 0);
719 op = get_irn_op(pred);
721 if (op->verify_proj_node)
722 return op->verify_proj_node(pred, p);
729 * verify a Block node
731 static int verify_node_Block(ir_node *n, ir_graph *irg) {
734 for (i = get_Block_n_cfgpreds(n) - 1; i >= 0; --i) {
735 ir_node *pred = get_Block_cfgpred(n, i);
739 (get_irn_mode(pred) == mode_X)
743 /* End block may only have Return, Raise or fragile ops as preds. */
744 if (n == get_irg_end_block(irg))
745 for (i = get_Block_n_cfgpreds(n) - 1; i >= 0; --i) {
746 ir_node *pred = skip_Proj(get_Block_cfgpred(n, i));
747 if (is_Proj(pred) || get_irn_op(pred) == op_Tuple)
748 break; /* We can not test properly. How many tuples are there? */
749 ASSERT_AND_RET(((get_irn_op(pred) == op_Return) ||
751 (get_irn_op(pred) == op_Raise) ||
752 is_fragile_op(pred) ),
753 "End Block node", 0);
755 /* irg attr must == graph we are in. */
756 if (! get_interprocedural_view()) {
757 ASSERT_AND_RET(((get_irn_irg(n) && get_irn_irg(n) == irg)), "Block node has wrong irg attribute", 0);
763 * verify a Start node
765 static int verify_node_Start(ir_node *n, ir_graph *irg) {
766 ir_mode *mymode = get_irn_mode(n);
769 /* Start: BB --> X x M x ref x data1 x ... x datan x ref */
770 mymode == mode_T, "Start node", 0
778 static int verify_node_Jmp(ir_node *n, ir_graph *irg) {
779 ir_mode *mymode = get_irn_mode(n);
783 mymode == mode_X, "Jmp node", 0
789 * verify an IJmp node
791 static int verify_node_IJmp(ir_node *n, ir_graph *irg) {
792 ir_mode *mymode = get_irn_mode(n);
793 ir_mode *op1mode = get_irn_mode(get_IJmp_target(n));
796 /* IJmp: BB x ref --> X */
797 mymode == mode_X && mode_is_reference(op1mode), "IJmp node", 0
803 * verify a Break node
805 static int verify_node_Break(ir_node *n, ir_graph *irg) {
806 ir_mode *mymode = get_irn_mode(n);
808 ASSERT_AND_RET((get_irp_ip_view_state() != ip_view_no),
809 "Break may only appear if ip view is constructed.", 0);
812 mymode == mode_X, "Break node", 0
820 static int verify_node_Cond(ir_node *n, ir_graph *irg) {
821 ir_mode *mymode = get_irn_mode(n);
822 ir_mode *op1mode = get_irn_mode(get_Cond_selector(n));
825 /* Cond: BB x b --> X x X */
826 (op1mode == mode_b ||
827 /* Cond: BB x int --> X^n */
828 mode_is_int(op1mode) ), "Cond node", 0
830 ASSERT_AND_RET(mymode == mode_T, "Cond mode is not a tuple", 0);
835 * verify a Return node
837 static int verify_node_Return(ir_node *n, ir_graph *irg) {
839 ir_mode *mymode = get_irn_mode(n);
840 ir_mode *mem_mode = get_irn_mode(get_Return_mem(n));
843 /* Return: BB x M x data1 x ... x datan --> X */
845 ASSERT_AND_RET( mem_mode == mode_M, "Return node", 0 ); /* operand M */
847 for (i = get_Return_n_ress(n) - 1; i >= 0; --i) {
848 ASSERT_AND_RET( mode_is_data(get_irn_mode(get_Return_res(n, i))), "Return node", 0 ); /* operand datai */
850 ASSERT_AND_RET( mymode == mode_X, "Result X", 0 ); /* result X */
851 /* Compare returned results with result types of method type */
852 mt = get_entity_type(get_irg_entity(irg));
853 ASSERT_AND_RET_DBG( get_Return_n_ress(n) == get_method_n_ress(mt),
854 "Number of results for Return doesn't match number of results in type.", 0,
855 show_return_nres(irg, n, mt););
856 for (i = get_Return_n_ress(n) - 1; i >= 0; --i) {
857 type *res_type = get_method_res_type(mt, i);
859 if (is_atomic_type(res_type)) {
861 get_irn_mode(get_Return_res(n, i)) == get_type_mode(res_type),
862 "Mode of result for Return doesn't match mode of result type.", 0,
863 show_return_modes(irg, n, mt, i);
868 mode_is_reference(get_irn_mode(get_Return_res(n, i))),
869 "Mode of result for Return doesn't match mode of result type.", 0,
870 show_return_modes(irg, n, mt, i);
878 * verify a Raise node
880 static int verify_node_Raise(ir_node *n, ir_graph *irg) {
881 ir_mode *mymode = get_irn_mode(n);
882 ir_mode *op1mode = get_irn_mode(get_Raise_mem(n));
883 ir_mode *op2mode = get_irn_mode(get_Raise_exo_ptr(n));
886 /* Sel: BB x M x ref --> X x M */
887 op1mode == mode_M && mode_is_reference(op2mode) &&
888 mymode == mode_T, "Raise node", 0
894 * verify a Const node
896 static int verify_node_Const(ir_node *n, ir_graph *irg) {
897 ir_mode *mymode = get_irn_mode(n);
900 /* Const: BB --> data */
901 (mode_is_data(mymode) ||
902 mymode == mode_b) /* we want boolean constants for static evaluation */
903 ,"Const node", 0 /* of Cmp. */
909 * verify a SymConst node
911 static int verify_node_SymConst(ir_node *n, ir_graph *irg) {
912 ir_mode *mymode = get_irn_mode(n);
914 if (get_SymConst_kind(n) == symconst_addr_ent) {
915 entity *ent = get_SymConst_entity(n);
916 if (is_Method_type(get_entity_type(ent)) &&
917 get_irn_irg(n) != get_const_code_irg()) {
919 ASSERT_AND_RET((get_entity_peculiarity(ent) != peculiarity_description),
920 "A constant must address an existing method.", 0);
925 /* SymConst: BB --> int*/
926 (mode_is_int(mymode) ||
927 /* SymConst: BB --> ref */
928 mode_is_reference(mymode))
929 ,"SymConst node", 0);
936 static int verify_node_Sel(ir_node *n, ir_graph *irg) {
938 ir_mode *mymode = get_irn_mode(n);
939 ir_mode *op1mode = get_irn_mode(get_Sel_mem(n));
940 ir_mode *op2mode = get_irn_mode(get_Sel_ptr(n));
944 /* Sel: BB x M x ref x int^n --> ref */
945 (op1mode == mode_M && op2mode == mymode && mode_is_reference(mymode)),
946 "Sel node", 0, show_node_failure(n)
949 for (i = get_Sel_n_indexs(n) - 1; i >= 0; --i) {
950 ASSERT_AND_RET_DBG(mode_is_int(get_irn_mode(get_Sel_index(n, i))), "Sel node", 0, show_node_failure(n));
952 ent = get_Sel_entity(n);
953 ASSERT_AND_RET_DBG(ent, "Sel node with empty entity", 0, show_node_failure(n));
958 * verify an InstOf node
960 static int verify_node_InstOf(ir_node *n, ir_graph *irg) {
961 ir_mode *mymode = get_irn_mode(n);
962 ir_mode *op1mode = get_irn_mode(get_InstOf_obj(n));
964 ASSERT_AND_RET(mode_T == mymode, "mode of Instof is not a tuple", 0);
965 ASSERT_AND_RET(mode_is_data(op1mode), "Instof not on data", 0);
972 static int verify_node_Call(ir_node *n, ir_graph *irg) {
973 ir_mode *mymode = get_irn_mode(n);
974 ir_mode *op1mode = get_irn_mode(get_Call_mem(n));
975 ir_mode *op2mode = get_irn_mode(get_Call_ptr(n));
979 /* Call: BB x M x ref x data1 x ... x datan
980 --> M x datan+1 x ... x data n+m */
981 ASSERT_AND_RET( op1mode == mode_M && mode_is_reference(op2mode), "Call node", 0 ); /* operand M x ref */
983 /* NoMem nodes are only allowed as memory input if the Call is NOT pinned */
985 (get_irn_op(get_Call_mem(n)) == op_NoMem) ||
986 (get_irn_op(get_Call_mem(n)) != op_NoMem && get_irn_pinned(n) == op_pin_state_pinned),
987 "Call node with wrong memory input", 0 );
989 mt = get_Call_type(n);
990 if(get_unknown_type() == mt) {
994 for (i = get_Call_n_params(n) - 1; i >= 0; --i) {
995 ASSERT_AND_RET( mode_is_data(get_irn_mode(get_Call_param(n, i))), "Call node", 0 ); /* operand datai */
998 ASSERT_AND_RET( mymode == mode_T, "Call result not a tuple", 0 ); /* result T */
999 /* Compare arguments of node with those of type */
1001 if (get_method_variadicity(mt) == variadicity_variadic) {
1003 get_Call_n_params(n) >= get_method_n_params(mt),
1004 "Number of args for Call doesn't match number of args in variadic type.",
1006 fprintf(stderr, "Call has %d params, method %s type %d\n",
1007 get_Call_n_params(n), get_type_name(mt), get_method_n_params(mt));
1012 get_Call_n_params(n) == get_method_n_params(mt),
1013 "Number of args for Call doesn't match number of args in non variadic type.",
1017 for (i = 0; i < get_method_n_params(mt); i++) {
1018 type *t = get_method_param_type(mt, i);
1020 if (is_atomic_type(t)) {
1022 get_irn_mode(get_Call_param(n, i)) == get_type_mode(t),
1023 "Mode of arg for Call doesn't match mode of arg type.", 0,
1024 show_call_param(n, mt);
1028 /* call with a compound type, mode must be reference */
1030 mode_is_reference(get_irn_mode(get_Call_param(n, i))),
1031 "Mode of arg for Call doesn't match mode of arg type.", 0,
1032 show_call_param(n, mt);
1038 if (Call_has_callees(n)) {
1039 for (i = 0; i < get_Call_n_callees(n); i++) {
1040 ASSERT_AND_RET(is_entity(get_Call_callee(n, i)), "callee array must contain entities.", 0);
1048 * verify an Add node
1050 static int verify_node_Add(ir_node *n, ir_graph *irg) {
1051 ir_mode *mymode = get_irn_mode(n);
1052 ir_mode *op1mode = get_irn_mode(get_Add_left(n));
1053 ir_mode *op2mode = get_irn_mode(get_Add_right(n));
1057 /* common Add: BB x numP x numP --> numP */
1058 (op1mode == mymode && op2mode == op1mode && mode_is_numP(mymode)) ||
1059 /* Pointer Add: BB x ref x int --> ref */
1060 (mode_is_reference(op1mode) && mode_is_int(op2mode) && op1mode == mymode) ||
1061 /* Pointer Add: BB x int x ref --> ref */
1062 (mode_is_int(op1mode) && op2mode == mymode && mode_is_reference(mymode))
1065 show_binop_failure(n, "/* common Add: BB x numP x numP --> numP */ |\n"
1066 "/* Pointer Add: BB x ref x int --> ref */ |\n"
1067 "/* Pointer Add: BB x int x ref --> ref */");
1075 static int verify_node_Sub(ir_node *n, ir_graph *irg) {
1076 ir_mode *mymode = get_irn_mode(n);
1077 ir_mode *op1mode = get_irn_mode(get_Sub_left(n));
1078 ir_mode *op2mode = get_irn_mode(get_Sub_right(n));
1081 /* common Sub: BB x numP x numP --> numP */
1082 ((mymode ==op1mode && mymode == op2mode && mode_is_numP(op1mode)) ||
1083 /* Pointer Sub: BB x ref x int --> ref */
1084 (op1mode == mymode && mode_is_int(op2mode) && mode_is_reference(mymode)) ||
1085 /* Pointer Sub: BB x int x ref --> ref */
1086 (mode_is_int(op1mode) && op2mode == mymode && mode_is_reference(mymode)) ||
1087 /* Pointer Sub: BB x ref x ref --> int */
1088 (op1mode == op2mode && mode_is_reference(op2mode) && mode_is_int(mymode))),
1090 show_binop_failure(n, "/* common Sub: BB x numP x numP --> numP */ |\n"
1091 "/* Pointer Sub: BB x ref x int --> ref */ |\n"
1092 "/* Pointer Sub: BB x int x ref --> ref */ |\n"
1093 "/* Pointer Sub: BB x ref x ref --> int */" );
1099 * verify a Minus node
1101 static int verify_node_Minus(ir_node *n, ir_graph *irg) {
1102 ir_mode *mymode = get_irn_mode(n);
1103 ir_mode *op1mode = get_irn_mode(get_Minus_op(n));
1106 /* Minus: BB x num --> num */
1107 op1mode == mymode && mode_is_num(op1mode), "Minus node", 0,
1108 show_unop_failure(n , "/* Minus: BB x num --> num */");
1116 static int verify_node_Mul(ir_node *n, ir_graph *irg) {
1117 ir_mode *mymode = get_irn_mode(n);
1118 ir_mode *op1mode = get_irn_mode(get_Mul_left(n));
1119 ir_mode *op2mode = get_irn_mode(get_Mul_right(n));
1122 /* Mul: BB x int1 x int1 --> int2 */
1123 ((mode_is_int(op1mode) && op2mode == op1mode && mode_is_int(mymode)) ||
1124 /* Mul: BB x float x float --> float */
1125 (mode_is_float(op1mode) && op2mode == op1mode && mymode == op1mode)),
1127 show_binop_failure(n, "/* Mul: BB x int1 x int1 --> int2 */ |\n"
1128 "/* Mul: BB x float x float --> float */");
1134 * verify a Quot node
1136 static int verify_node_Quot(ir_node *n, ir_graph *irg) {
1137 ir_mode *mymode = get_irn_mode(n);
1138 ir_mode *op1mode = get_irn_mode(get_Quot_mem(n));
1139 ir_mode *op2mode = get_irn_mode(get_Quot_left(n));
1140 ir_mode *op3mode = get_irn_mode(get_Quot_right(n));
1143 /* Quot: BB x M x float x float --> M x X x float */
1144 op1mode == mode_M && op2mode == op3mode &&
1145 get_mode_sort(op2mode) == irms_float_number &&
1148 show_binop_failure(n, "/* Quot: BB x M x float x float --> M x X x float */");
1154 * verify a DivMod node
1156 static int verify_node_DivMod(ir_node *n, ir_graph *irg) {
1157 ir_mode *mymode = get_irn_mode(n);
1158 ir_mode *op1mode = get_irn_mode(get_DivMod_mem(n));
1159 ir_mode *op2mode = get_irn_mode(get_DivMod_left(n));
1160 ir_mode *op3mode = get_irn_mode(get_DivMod_right(n));
1163 /* DivMod: BB x M x int x int --> M x X x int x int */
1164 op1mode == mode_M &&
1165 mode_is_int(op2mode) &&
1166 op3mode == op2mode &&
1176 static int verify_node_Div(ir_node *n, ir_graph *irg) {
1177 ir_mode *mymode = get_irn_mode(n);
1178 ir_mode *op1mode = get_irn_mode(get_Div_mem(n));
1179 ir_mode *op2mode = get_irn_mode(get_Div_left(n));
1180 ir_mode *op3mode = get_irn_mode(get_Div_right(n));
1183 /* Div: BB x M x int x int --> M x X x int */
1184 op1mode == mode_M &&
1185 op2mode == op3mode &&
1186 mode_is_int(op2mode) &&
1196 static int verify_node_Mod(ir_node *n, ir_graph *irg) {
1197 ir_mode *mymode = get_irn_mode(n);
1198 ir_mode *op1mode = get_irn_mode(get_Mod_mem(n));
1199 ir_mode *op2mode = get_irn_mode(get_Mod_left(n));
1200 ir_mode *op3mode = get_irn_mode(get_Mod_right(n));
1203 /* Mod: BB x M x int x int --> M x X x int */
1204 op1mode == mode_M &&
1205 op2mode == op3mode &&
1206 mode_is_int(op2mode) &&
1214 * verify an Abs node
1216 static int verify_node_Abs(ir_node *n, ir_graph *irg) {
1217 ir_mode *mymode = get_irn_mode(n);
1218 ir_mode *op1mode = get_irn_mode(get_Abs_op(n));
1221 /* Abs: BB x num --> num */
1222 op1mode == mymode &&
1223 mode_is_num (op1mode),
1225 show_unop_failure(n, "/* Abs: BB x num --> num */");
1231 * verify a logical And, Or, Eor node
1233 static int verify_node_Logic(ir_node *n, ir_graph *irg) {
1234 ir_mode *mymode = get_irn_mode(n);
1235 ir_mode *op1mode = get_irn_mode(get_binop_left(n));
1236 ir_mode *op2mode = get_irn_mode(get_binop_right(n));
1239 /* And or Or or Eor: BB x int x int --> int */
1240 mode_is_int(mymode) &&
1241 op2mode == op1mode &&
1243 "And, Or or Eor node", 0,
1244 show_binop_failure(n, "/* And or Or or Eor: BB x int x int --> int */");
1249 #define verify_node_And verify_node_Logic
1250 #define verify_node_Or verify_node_Logic
1251 #define verify_node_Eor verify_node_Logic
1256 static int verify_node_Not(ir_node *n, ir_graph *irg) {
1257 ir_mode *mymode = get_irn_mode(n);
1258 ir_mode *op1mode = get_irn_mode(get_Not_op(n));
1261 /* Not: BB x int --> int */
1262 mode_is_int(mymode) &&
1265 show_unop_failure(n, "/* Not: BB x int --> int */");
1273 static int verify_node_Cmp(ir_node *n, ir_graph *irg) {
1274 ir_mode *mymode = get_irn_mode(n);
1275 ir_mode *op1mode = get_irn_mode(get_Cmp_left(n));
1276 ir_mode *op2mode = get_irn_mode(get_Cmp_right(n));
1279 /* Cmp: BB x datab x datab --> b16 */
1280 mode_is_data (op1mode) &&
1281 op2mode == op1mode &&
1284 show_binop_failure(n, "/* Cmp: BB x datab x datab --> b16 */");
1290 * verify a Shift node
1292 static int verify_node_Shift(ir_node *n, ir_graph *irg) {
1293 ir_mode *mymode = get_irn_mode(n);
1294 ir_mode *op1mode = get_irn_mode(get_binop_left(n));
1295 ir_mode *op2mode = get_irn_mode(get_binop_right(n));
1298 /* Shl, Shr or Shrs: BB x int x int_u --> int */
1299 mode_is_int(op1mode) &&
1300 mode_is_int(op2mode) &&
1301 !mode_is_signed(op2mode) &&
1303 "Shl, Shr or Shrs node", 0,
1304 show_binop_failure(n, "/* Shl, Shr or Shrs: BB x int x int_u --> int */");
1309 #define verify_node_Shl verify_node_Shift
1310 #define verify_node_Shr verify_node_Shift
1311 #define verify_node_Shrs verify_node_Shift
1316 static int verify_node_Rot(ir_node *n, ir_graph *irg) {
1317 ir_mode *mymode = get_irn_mode(n);
1318 ir_mode *op1mode = get_irn_mode(get_Rot_left(n));
1319 ir_mode *op2mode = get_irn_mode(get_Rot_right(n));
1322 /* Rot: BB x int x int --> int */
1323 mode_is_int(op1mode) &&
1324 mode_is_int(op2mode) &&
1327 show_binop_failure(n, "/* Rot: BB x int x int --> int */");
1333 * verify a Conv node
1335 static int verify_node_Conv(ir_node *n, ir_graph *irg) {
1336 ir_mode *mymode = get_irn_mode(n);
1337 ir_mode *op1mode = get_irn_mode(get_Conv_op(n));
1340 /* Conv: BB x datab1 --> datab2 */
1341 mode_is_datab(op1mode) && mode_is_data(mymode),
1343 show_unop_failure(n, "/* Conv: BB x datab1 --> datab2 */");
1349 * verify a Cast node
1351 static int verify_node_Cast(ir_node *n, ir_graph *irg) {
1352 ir_mode *mymode = get_irn_mode(n);
1353 ir_mode *op1mode = get_irn_mode(get_Cast_op(n));
1356 /* Conv: BB x datab1 --> datab2 */
1357 mode_is_data(op1mode) && op1mode == mymode,
1359 show_unop_failure(n, "/* Conv: BB x datab1 --> datab2 */");
1367 static int verify_node_Phi(ir_node *n, ir_graph *irg) {
1368 ir_mode *mymode = get_irn_mode(n);
1369 ir_node *block = get_nodes_block(n);
1372 if (! is_Bad(block) && get_irg_phase_state(get_irn_irg(n)) != phase_building) {
1373 /* a Phi node MUST have the same number of inputs as its block */
1375 get_irn_arity(n) == get_irn_arity(block),
1376 "wrong number of inputs in Phi node", 0,
1377 show_phi_inputs(n, block);
1381 /* Phi: BB x dataM^n --> dataM */
1382 for (i = get_irn_arity(n) - 1; i >= 0; --i) {
1383 ir_node *pred = get_irn_n(n, i);
1384 if (!is_Bad(pred) && (get_irn_op(pred) != op_Unknown))
1386 get_irn_mode(pred) == mymode,
1388 show_phi_failure(n, pred, i);
1391 ASSERT_AND_RET( mode_is_dataM(mymode), "Phi node", 0 );
1396 * verify a Filter node
1398 static int verify_node_Filter(ir_node *n, ir_graph *irg) {
1399 ASSERT_AND_RET((get_irp_ip_view_state() != ip_view_no),
1400 "Filter may only appear if ip view is constructed.", 0);
1401 /* We should further do tests as for Proj and Phi. */
1406 * verify a Load node
1408 static int verify_node_Load(ir_node *n, ir_graph *irg) {
1409 ir_mode *mymode = get_irn_mode(n);
1410 ir_mode *op1mode = get_irn_mode(get_Load_mem(n));
1411 ir_mode *op2mode = get_irn_mode(get_Load_ptr(n));
1414 /* Load: BB x M x ref --> M x X x data */
1415 op1mode == mode_M && mode_is_reference(op2mode),
1418 ASSERT_AND_RET( mymode == mode_T, "Load node", 0 );
1421 * jack's gen_add_firm_code:simpleSel seems to build Load (Load
1422 * (Proj (Proj))) sometimes ...
1424 * interprete.c:ai_eval seems to assume that this happens, too
1426 * obset.c:get_abstval_any can't deal with this if the load has
1430 entity *ent = hunt_for_entity (get_Load_ptr (n), n);
1431 assert ((NULL != ent) || (mymode != mode_T));
1439 * verify a Store node
1441 static int verify_node_Store(ir_node *n, ir_graph *irg) {
1444 ir_mode *mymode = get_irn_mode(n);
1445 ir_mode *op1mode = get_irn_mode(get_Store_mem(n));
1446 ir_mode *op2mode = get_irn_mode(get_Store_ptr(n));
1447 ir_mode *op3mode = get_irn_mode(get_Store_value(n));
1450 /* Store: BB x M x ref x data --> M x X */
1451 op1mode == mode_M && mode_is_reference(op2mode) && mode_is_data(op3mode),
1454 ASSERT_AND_RET(mymode == mode_T, "Store node", 0);
1456 target = get_ptr_entity(get_Store_ptr(n));
1457 if (vrfy_entities && target && get_irg_phase_state(current_ir_graph) == phase_high) {
1459 * If lowered code, any Sels that add 0 may be removed, causing
1460 * an direct access to entities of array or compound type.
1461 * Prevent this by checking the phase.
1463 ASSERT_AND_RET( op3mode == get_type_mode(get_entity_type(target)),
1471 * verify an Alloc node
1473 static int verify_node_Alloc(ir_node *n, ir_graph *irg) {
1474 ir_mode *mymode = get_irn_mode(n);
1475 ir_mode *op1mode = get_irn_mode(get_Alloc_mem(n));
1476 ir_mode *op2mode = get_irn_mode(get_Alloc_size(n));
1479 /* Alloc: BB x M x int_u --> M x X x ref */
1480 op1mode == mode_M &&
1481 mode_is_int(op2mode) &&
1482 !mode_is_signed(op2mode) &&
1485 show_binop_failure(n, "/* Alloc: BB x M x int_u --> M x X x ref */");
1491 * verify a Free node
1493 static int verify_node_Free(ir_node *n, ir_graph *irg) {
1494 ir_mode *mymode = get_irn_mode(n);
1495 ir_mode *op1mode = get_irn_mode(get_Free_mem(n));
1496 ir_mode *op2mode = get_irn_mode(get_Free_ptr(n));
1497 ir_mode *op3mode = get_irn_mode(get_Free_size(n));
1500 /* Free: BB x M x ref x int_u --> M */
1501 op1mode == mode_M && mode_is_reference(op2mode) &&
1502 mode_is_int(op3mode) &&
1503 !mode_is_signed(op3mode) &&
1506 show_triop_failure(n, "/* Free: BB x M x ref x int_u --> M */");
1512 * verify a Sync node
1514 static int verify_node_Sync(ir_node *n, ir_graph *irg) {
1516 ir_mode *mymode = get_irn_mode(n);
1518 /* Sync: BB x M^n --> M */
1519 for (i = get_Sync_n_preds(n) - 1; i >= 0; --i) {
1520 ASSERT_AND_RET( get_irn_mode(get_Sync_pred(n, i)) == mode_M, "Sync node", 0 );
1522 ASSERT_AND_RET( mymode == mode_M, "Sync node", 0 );
1527 * verify a Confirm node
1529 static int verify_node_Confirm(ir_node *n, ir_graph *irg) {
1530 ir_mode *mymode = get_irn_mode(n);
1531 ir_mode *op1mode = get_irn_mode(get_Confirm_value(n));
1532 ir_mode *op2mode = get_irn_mode(get_Confirm_bound(n));
1535 /* Confirm: BB x T x T --> T */
1536 op1mode == mymode &&
1539 show_binop_failure(n, "/* Confirm: BB x T x T --> T */");
1547 static int verify_node_Mux(ir_node *n, ir_graph *irg) {
1548 ir_mode *mymode = get_irn_mode(n);
1549 ir_mode *op1mode = get_irn_mode(get_Mux_sel(n));
1550 ir_mode *op2mode = get_irn_mode(get_Mux_true(n));
1551 ir_mode *op3mode = get_irn_mode(get_Mux_false(n));
1554 /* Mux: BB x b x numP x numP --> numP */
1555 op1mode == mode_b &&
1556 op2mode == mymode &&
1557 op3mode == mymode &&
1558 mode_is_numP(mymode),
1566 * For each usage of a node, it is checked, if the block of the
1567 * node dominates the block of the usage (for phis: the predecessor
1568 * block of the phi for the corresponding edge).
1570 static int check_dominance_for_node(ir_node *irn)
1572 /* This won't work for blocks and the end node */
1573 if(!is_Block(irn) && irn != get_irg_end(current_ir_graph)) {
1575 ir_node *bl = get_nodes_block(irn);
1577 for(i = 0, n = get_irn_arity(irn); i < n; ++i) {
1578 ir_node *op = get_irn_n(irn, i);
1579 ir_node *def_bl = get_nodes_block(op);
1580 ir_node *use_bl = bl;
1583 use_bl = get_Block_cfgpred_block(bl, i);
1585 ASSERT_AND_RET_DBG(block_dominates(def_bl, use_bl),
1586 "the definition of a value used violates the dominance property", 0,
1588 "graph %+F: %+F of %+F must dominate %+F of user %+F\n",
1589 def_bl, op, use_bl, irn););
1597 int irn_vrfy_irg(ir_node *n, ir_graph *irg)
1602 if (!opt_do_node_verification)
1605 if (!get_interprocedural_view()) {
1607 * do NOT check placement in interprocedural view, as we don't always know
1608 * the "right" graph ...
1611 node_is_in_irgs_storage(irg, n),
1612 "Node is not stored on proper IR graph!", 0,
1613 show_node_on_graph(irg, n);
1615 assert(get_irn_irg(n) == irg);
1620 /* We don't want to test nodes whose predecessors are Bad,
1621 as we would have to special case that for each operation. */
1622 if (op != op_Phi && op != op_Block)
1623 for (i = get_irn_arity(n) - 1; i >= 0; --i) {
1624 if (is_Bad(get_irn_n(n, i)))
1628 if (op->verify_node)
1629 return op->verify_node(n, irg);
1635 int irn_vrfy(ir_node *n)
1638 #ifdef DEBUG_libfirm
1639 res = irn_vrfy_irg(n, current_ir_graph);
1644 /*-----------------------------------------------------------------*/
1645 /* Verify the whole graph. */
1646 /*-----------------------------------------------------------------*/
1648 /* This *is* used, except gcc doesn't notice that */
1649 static void vrfy_wrap(ir_node *node, void *env)
1653 *res = irn_vrfy(node);
1655 if(*res && get_irg_dom_state(current_ir_graph) == dom_consistent)
1656 *res = check_dominance_for_node(node);
1659 int irg_vrfy(ir_graph *irg)
1662 #ifdef DEBUG_libfirm
1665 rem = current_ir_graph;
1666 current_ir_graph = irg;
1667 last_irg_error = NULL;
1669 assert(get_irg_pinned(irg) == op_pin_state_pinned);
1670 if (get_irg_dom_state(current_ir_graph) != dom_consistent)
1671 compute_doms(current_ir_graph);
1672 irg_walk_graph(irg, vrfy_wrap, NULL, &res);
1674 current_ir_graph = rem;
1676 if (opt_do_node_verification == NODE_VERIFICATION_REPORT && ! res) {
1677 entity *ent = get_irg_entity(current_ir_graph);
1680 fprintf(stderr, "irg_verify: Verifying graph %s failed\n", get_entity_name(ent));
1682 fprintf(stderr, "irg_verify: Verifying graph %p failed\n", (void *)current_ir_graph);
1691 int irn_vrfy_irg_dump(ir_node *n, ir_graph *irg, const char **bad_string)
1694 node_verification_t old = opt_do_node_verification;
1696 firm_vrfy_failure_msg = NULL;
1697 opt_do_node_verification = NODE_VERIFICATION_ERROR_ONLY;
1698 res = irn_vrfy_irg(n, irg);
1699 opt_do_node_verification = old;
1700 *bad_string = firm_vrfy_failure_msg;
1706 typedef struct _vrfy_bad_env_t {
1711 static void check_bads(ir_node *node, void *env)
1713 vrfy_bad_env_t *venv = env;
1714 int i, arity = get_irn_arity(node);
1716 if (is_Block(node)) {
1717 if ((venv->flags & BAD_CF) == 0) {
1719 /* check for Bad Block predecessor */
1720 for (i = 0; i < arity; ++i) {
1721 ir_node *pred = get_irn_n(node, i);
1724 venv->res |= BAD_CF;
1726 if (opt_do_node_verification == NODE_VERIFICATION_REPORT) {
1727 fprintf(stderr, "irg_vrfy_bads: Block %ld has Bad predecessor\n", get_irn_node_nr(node));
1729 if (opt_do_node_verification == NODE_VERIFICATION_ON) {
1730 assert(0 && "Bad CF detected");
1737 if ((venv->flags & BAD_BLOCK) == 0) {
1739 /* check for Bad Block */
1740 if (is_Bad(get_nodes_block(node))) {
1741 venv->res |= BAD_BLOCK;
1743 if (opt_do_node_verification == NODE_VERIFICATION_REPORT) {
1744 fprintf(stderr, "irg_vrfy_bads: node %ld has Bad Block\n", get_irn_node_nr(node));
1746 if (opt_do_node_verification == NODE_VERIFICATION_ON) {
1747 assert(0 && "Bad CF detected");
1752 if ((venv->flags & TUPLE) == 0) {
1753 if (get_irn_op(node) == op_Tuple) {
1756 if (opt_do_node_verification == NODE_VERIFICATION_REPORT) {
1757 fprintf(stderr, "irg_vrfy_bads: node %ld is a Tuple\n", get_irn_node_nr(node));
1759 if (opt_do_node_verification == NODE_VERIFICATION_ON) {
1760 assert(0 && "Tuple detected");
1765 for (i = 0; i < arity; ++i) {
1766 ir_node *pred = get_irn_n(node, i);
1769 /* check for Phi with Bad inputs */
1770 if (is_Phi(node) && !is_Bad(get_nodes_block(node)) && is_Bad(get_irn_n(get_nodes_block(node), i))) {
1771 if (venv->flags & BAD_CF)
1774 venv->res |= BAD_CF;
1776 if (opt_do_node_verification == NODE_VERIFICATION_REPORT) {
1777 fprintf(stderr, "irg_vrfy_bads: Phi %ld has Bad Input\n", get_irn_node_nr(node));
1779 if (opt_do_node_verification == NODE_VERIFICATION_ON) {
1780 assert(0 && "Bad CF detected");
1785 /* Bad node input */
1786 if ((venv->flags & BAD_DF) == 0) {
1787 venv->res |= BAD_DF;
1789 if (opt_do_node_verification == NODE_VERIFICATION_REPORT) {
1790 fprintf(stderr, "irg_vrfy_bads: node %ld has Bad Input\n", get_irn_node_nr(node));
1792 if (opt_do_node_verification == NODE_VERIFICATION_ON) {
1793 assert(0 && "Bad NON-CF detected");
1802 * verify occurance of bad nodes
1804 int irg_vrfy_bads(ir_graph *irg, int flags)
1811 irg_walk_graph(irg, check_bads, NULL, &env);
1817 * set the default verify operation
1819 void firm_set_default_verifyer(ir_op *op)
1823 op->verify_node = verify_node_##a; \
1871 op->verify_node = NULL;
1877 op->verify_proj_node = verify_node_Proj_##a; \
1900 op->verify_proj_node = NULL;