2 * Copyright (C) 1995-2008 University of Karlsruhe. All right reserved.
4 * This file is part of libFirm.
6 * This file may be distributed and/or modified under the terms of the
7 * GNU General Public License version 2 as published by the Free Software
8 * Foundation and appearing in the file LICENSE.GPL included in the
9 * packaging of this file.
11 * Licensees holding valid libFirm Professional Edition licenses may use
12 * this file in accordance with the libFirm Commercial License.
13 * Agreement provided with the Software.
15 * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
16 * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR
22 * @brief Check irnodes for correctness.
23 * @author Christian Schaefer, Goetz Lindenmaier, Till Riedel, Michael Beck
30 #include "irgraph_t.h"
40 /** if this flag is set, verify entity types in Load & Store nodes */
41 static int vrfy_entities = 0;
43 const char *firm_vrfy_failure_msg;
45 /* enable verification of Load/Store entities */
46 void vrfy_enable_entity_tests(int enable) {
47 vrfy_entities = enable;
53 * little helper for NULL modes
55 static const char *get_mode_name_ex(ir_mode *mode) {
58 return get_mode_name(mode);
61 /** the last IRG, on which a verification error was found */
62 static ir_graph *last_irg_error = NULL;
65 * print the name of the entity of an verification failure
67 * @param node the node caused the failure
69 static void show_entity_failure(ir_node *node) {
70 ir_graph *irg = get_irn_irg(node);
72 if (last_irg_error == irg)
77 if (irg == get_const_code_irg()) {
78 fprintf(stderr, "\nFIRM: irn_vrfy_irg() <of CONST_CODE_IRG> failed\n");
80 ir_entity *ent = get_irg_entity(irg);
83 ir_type *ent_type = get_entity_owner(ent);
86 if (ent_type == get_glob_type())
87 fprintf(stderr, "\nFIRM: irn_vrfy_irg() %s failed\n", get_entity_name(ent));
89 fprintf(stderr, "\nFIRM: irn_vrfy_irg() %s::%s failed\n", get_type_name(ent_type), get_entity_name(ent));
91 fprintf(stderr, "\nFIRM: irn_vrfy_irg() <NULL>::%s failed\n", get_entity_name(ent));
94 fprintf(stderr, "\nFIRM: irn_vrfy_irg() <IRG %p> failed\n", (void *)irg);
100 * Prints a failure for a Node
102 static void show_node_failure(ir_node *n) {
103 show_entity_failure(n);
104 fprintf(stderr, " node %ld %s%s\n" ,
106 get_irn_opname(n), get_irn_modename(n)
111 * Prints a failure message for a binop
113 static void show_binop_failure(ir_node *n, const char *text) {
114 ir_node *left = get_binop_left(n);
115 ir_node *right = get_binop_right(n);
117 show_entity_failure(n);
118 fprintf(stderr, " node %ld %s%s(%s%s, %s%s) did not match (%s)\n",
120 get_irn_opname(n), get_irn_modename(n),
121 get_irn_opname(left), get_irn_modename(left),
122 get_irn_opname(right), get_irn_modename(right),
127 * Prints a failure message for an unop
129 static void show_unop_failure(ir_node *n, const char *text) {
130 ir_node *op = get_unop_op(n);
132 show_entity_failure(n);
133 fprintf(stderr, " node %ld %s%s(%s%s) did not match (%s)\n",
135 get_irn_opname(n), get_irn_modename(n),
136 get_irn_opname(op), get_irn_modename(op),
141 * Prints a failure message for an op with 3 operands
143 static void show_triop_failure(ir_node *n, const char *text) {
144 ir_node *op0 = get_irn_n(n, 0);
145 ir_node *op1 = get_irn_n(n, 1);
146 ir_node *op2 = get_irn_n(n, 2);
148 show_entity_failure(n);
149 fprintf(stderr, " of node %ld %s%s(%s%s, %s%s, %s%s) did not match (%s)\n",
151 get_irn_opname(n), get_irn_modename(n),
152 get_irn_opname(op0), get_irn_modename(op0),
153 get_irn_opname(op1), get_irn_modename(op1),
154 get_irn_opname(op2), get_irn_modename(op2),
159 * Prints a failure message for a proj
161 static void show_proj_failure(ir_node *n) {
162 ir_node *op = get_Proj_pred(n);
163 int proj = get_Proj_proj(n);
165 show_entity_failure(n);
166 fprintf(stderr, " node %ld %s%s %d(%s%s) failed\n" ,
168 get_irn_opname(n), get_irn_modename(n), proj,
169 get_irn_opname(op), get_irn_modename(op));
173 * Prints a failure message for a proj from Start
175 static void show_proj_mode_failure(ir_node *n, ir_type *ty) {
176 long proj = get_Proj_proj(n);
177 ir_mode *m = get_type_mode(ty);
179 show_entity_failure(n);
180 fprintf(stderr, " Proj %ld mode %s proj %ld (type %s mode %s) failed\n" ,
185 get_mode_name_ex(m));
189 * Prints a failure message for a proj
191 static void show_proj_failure_ent(ir_node *n, ir_entity *ent) {
192 ir_node *op = get_Proj_pred(n);
193 int proj = get_Proj_proj(n);
194 ir_mode *m = get_type_mode(get_entity_type(ent));
196 show_entity_failure(n);
197 fprintf(stderr, " node %ld %s%s %d(%s%s) entity %s(type %s mode %s)failed\n" ,
199 get_irn_opname(n), get_irn_modename(n), proj,
200 get_irn_opname(op), get_irn_modename(op),
201 get_entity_name(ent), get_type_name(get_entity_type(ent)),
202 get_mode_name_ex(m));
206 * Show a node and a graph
208 static void show_node_on_graph(ir_graph *irg, ir_node *n) {
209 ir_fprintf(stderr, "\nFIRM: irn_vrfy_irg() of %+F, node %+F\n", irg, n);
213 * Show call parameters
215 static void show_call_param(ir_node *n, ir_type *mt) {
218 show_entity_failure(n);
219 fprintf(stderr, " Call type-check failed: %s(", get_type_name(mt));
220 for (i = 0; i < get_method_n_params(mt); ++i) {
221 fprintf(stderr, "%s ", get_mode_name_ex(get_type_mode(get_method_param_type(mt, i))));
223 fprintf(stderr, ") != CALL(");
225 for (i = 0; i < get_Call_n_params(n); ++i) {
226 fprintf(stderr, "%s ", get_mode_name_ex(get_irn_mode(get_Call_param(n, i))));
228 fprintf(stderr, ")\n");
234 static void show_return_modes(ir_graph *irg, ir_node *n, ir_type *mt, int i) {
235 ir_entity *ent = get_irg_entity(irg);
237 show_entity_failure(n);
238 fprintf(stderr, " Return node %ld in entity \"%s\" mode %s different from type mode %s\n",
239 get_irn_node_nr(n), get_entity_name(ent),
240 get_mode_name_ex(get_irn_mode(get_Return_res(n, i))),
241 get_mode_name_ex(get_type_mode(get_method_res_type(mt, i)))
246 * Show return number of results
248 static void show_return_nres(ir_graph *irg, ir_node *n, ir_type *mt) {
249 ir_entity *ent = get_irg_entity(irg);
251 show_entity_failure(n);
252 fprintf(stderr, " Return node %ld in entity \"%s\" has %d results different from type %d\n",
253 get_irn_node_nr(n), get_entity_name(ent),
254 get_Return_n_ress(n), get_method_n_ress(mt));
260 static void show_phi_failure(ir_node *phi, ir_node *pred, int pos) {
262 show_entity_failure(phi);
263 fprintf(stderr, " Phi node %ld has mode %s different from predeccessor node %ld mode %s\n",
264 get_irn_node_nr(phi), get_mode_name_ex(get_irn_mode(phi)),
265 get_irn_node_nr(pred), get_mode_name_ex(get_irn_mode(pred)));
271 static void show_phi_inputs(ir_node *phi, ir_node *block) {
272 show_entity_failure(phi);
273 fprintf(stderr, " Phi node %ld has %d inputs, its Block %ld has %d\n",
274 get_irn_node_nr(phi), get_irn_arity(phi),
275 get_irn_node_nr(block), get_irn_arity(block));
278 #endif /* #ifndef NDEBUG */
281 * If the address is Sel or SymConst, return the entity.
283 * @param ptr the node representing the address
285 static ir_entity *get_ptr_entity(ir_node *ptr) {
287 return get_Sel_entity(ptr);
288 } else if (is_SymConst_addr_ent(ptr)) {
289 return get_SymConst_entity(ptr);
295 * verify a Proj(Start) node
297 static int verify_node_Proj_Start(ir_node *n, ir_node *p) {
298 ir_mode *mode = get_irn_mode(p);
299 long proj = get_Proj_proj(p);
304 (proj == pn_Start_X_initial_exec && mode == mode_X) ||
305 (proj == pn_Start_M && mode == mode_M) ||
306 (proj == pn_Start_P_frame_base && mode_is_reference(mode)) ||
307 (proj == pn_Start_P_tls && mode_is_reference(mode)) ||
308 (proj == pn_Start_T_args && mode == mode_T)
310 "wrong Proj from Start", 0,
311 show_proj_failure(p);
317 * verify a Proj(Cond) node
319 static int verify_node_Proj_Cond(ir_node *pred, ir_node *p) {
320 ir_mode *mode = get_irn_mode(p);
321 long proj = get_Proj_proj(p);
325 (proj >= 0 && mode == mode_X && get_irn_mode(get_Cond_selector(pred)) == mode_b) || /* compare */
326 (mode == mode_X && mode_is_int(get_irn_mode(get_Cond_selector(pred)))) || /* switch */
327 is_Bad(get_Cond_selector(pred)) /* rare */
329 "wrong Proj from Cond", 0,
330 show_proj_failure(p);
336 * verify a Proj(Raise) node
338 static int verify_node_Proj_Raise(ir_node *n, ir_node *p) {
339 ir_mode *mode = get_irn_mode(p);
340 long proj = get_Proj_proj(p);
344 ((proj == pn_Raise_X && mode == mode_X) || (proj == pn_Raise_M && mode == mode_M)),
345 "wrong Proj from Raise", 0,
346 show_proj_failure(p);
352 * verify a Proj(InstOf) node
354 static int verify_node_Proj_InstOf(ir_node *n, ir_node *p) {
355 ir_mode *mode = get_irn_mode(p);
356 long proj = get_Proj_proj(p);
361 (proj == pn_InstOf_M_regular && mode == mode_M) ||
362 (proj == pn_InstOf_X_regular && mode == mode_X) ||
363 (proj == pn_InstOf_X_except && mode == mode_X) ||
364 (proj == pn_InstOf_res && mode_is_reference(mode)) ||
365 (proj == pn_InstOf_M_except && mode == mode_M)
367 "wrong Proj from InstOf", 0,
368 show_proj_failure(p);
374 * verify a Proj(Call) node
376 static int verify_node_Proj_Call(ir_node *n, ir_node *p) {
377 ir_mode *mode = get_irn_mode(p);
378 long proj = get_Proj_proj(p);
382 (proj == pn_Call_M_regular && mode == mode_M) ||
383 (proj == pn_Call_X_regular && mode == mode_X) ||
384 (proj == pn_Call_X_except && mode == mode_X) ||
385 (proj == pn_Call_T_result && mode == mode_T) ||
386 (proj == pn_Call_M_except && mode == mode_M) ||
387 (proj == pn_Call_P_value_res_base && mode_is_reference(mode))
389 "wrong Proj from Call", 0,
390 show_proj_failure(p);
392 /* if we have exception flow, we must have a real Memory input */
393 if (proj == pn_Call_X_regular)
395 !is_NoMem(get_Call_mem(n)),
396 "Regular Proj from FunctionCall", 0);
397 else if (proj == pn_Call_X_except)
399 !is_NoMem(get_Call_mem(n)),
400 "Exception Proj from FunctionCall", 0);
401 else if (proj == pn_Call_M_regular || proj == pn_Call_M_except)
403 (!is_NoMem(get_Call_mem(n)) || 1),
404 "Memory Proj from FunctionCall", 0);
409 * verify a Proj(Quot) node
411 static int verify_node_Proj_Quot(ir_node *n, ir_node *p) {
412 ir_mode *mode = get_irn_mode(p);
413 long proj = get_Proj_proj(p);
417 (proj == pn_Quot_M && mode == mode_M) ||
418 (proj == pn_Quot_X_regular && mode == mode_X) ||
419 (proj == pn_Quot_X_except && mode == mode_X) ||
420 (proj == pn_Quot_res && mode_is_float(mode) && mode == get_Quot_resmode(n))
422 "wrong Proj from Quot", 0,
423 show_proj_failure(p);
425 if (proj == pn_Quot_X_regular)
427 get_irn_pinned(n) == op_pin_state_pinned,
428 "Regular Proj from unpinned Quot", 0);
429 else if (proj == pn_Quot_X_except)
431 get_irn_pinned(n) == op_pin_state_pinned,
432 "Exception Proj from unpinned Quot", 0);
433 else if (proj == pn_Quot_M)
435 get_irn_pinned(n) == op_pin_state_pinned,
436 "Memory Proj from unpinned Quot", 0);
441 * verify a Proj(DivMod) node
443 static int verify_node_Proj_DivMod(ir_node *n, ir_node *p) {
444 ir_mode *mode = get_irn_mode(p);
445 long proj = get_Proj_proj(p);
449 (proj == pn_DivMod_M && mode == mode_M) ||
450 (proj == pn_DivMod_X_regular && mode == mode_X) ||
451 (proj == pn_DivMod_X_except && mode == mode_X) ||
452 (proj == pn_DivMod_res_div && mode_is_int(mode) && mode == get_DivMod_resmode(n)) ||
453 (proj == pn_DivMod_res_mod && mode_is_int(mode) && mode == get_DivMod_resmode(n))
455 "wrong Proj from DivMod", 0,
456 show_proj_failure(p);
458 if (proj == pn_DivMod_X_regular)
460 get_irn_pinned(n) == op_pin_state_pinned,
461 "Regular Proj from unpinned DivMod", 0);
462 else if (proj == pn_DivMod_X_except)
464 get_irn_pinned(n) == op_pin_state_pinned,
465 "Exception Proj from unpinned DivMod", 0);
466 else if (proj == pn_DivMod_M)
468 get_irn_pinned(n) == op_pin_state_pinned,
469 "Memory Proj from unpinned DivMod", 0);
474 * verify a Proj(Div) node
476 static int verify_node_Proj_Div(ir_node *n, ir_node *p) {
477 ir_mode *mode = get_irn_mode(p);
478 long proj = get_Proj_proj(p);
482 (proj == pn_Div_M && mode == mode_M) ||
483 (proj == pn_Div_X_regular && mode == mode_X) ||
484 (proj == pn_Div_X_except && mode == mode_X) ||
485 (proj == pn_Div_res && mode_is_int(mode) && mode == get_Div_resmode(n))
487 "wrong Proj from Div", 0,
488 show_proj_failure(p);
490 if (proj == pn_Div_X_regular)
492 get_irn_pinned(n) == op_pin_state_pinned,
493 "Regular Proj from unpinned Div", 0);
494 else if (proj == pn_Div_X_except)
496 get_irn_pinned(n) == op_pin_state_pinned,
497 "Exception Proj from unpinned Div", 0);
498 else if (proj == pn_Div_M)
500 get_irn_pinned(n) == op_pin_state_pinned,
501 "Memory Proj from unpinned Div", 0);
506 * verify a Proj(Mod) node
508 static int verify_node_Proj_Mod(ir_node *n, ir_node *p) {
509 ir_mode *mode = get_irn_mode(p);
510 long proj = get_Proj_proj(p);
514 (proj == pn_Mod_M && mode == mode_M) ||
515 (proj == pn_Mod_X_regular && mode == mode_X) ||
516 (proj == pn_Mod_X_except && mode == mode_X) ||
517 (proj == pn_Mod_res && mode_is_int(mode) && mode == get_Mod_resmode(n))
519 "wrong Proj from Mod", 0,
520 show_proj_failure(p);
522 if (proj == pn_Mod_X_regular)
524 get_irn_pinned(n) == op_pin_state_pinned,
525 "Regular Proj from unpinned Mod", 0);
526 else if (proj == pn_Mod_X_except)
528 get_irn_pinned(n) == op_pin_state_pinned,
529 "Exception Proj from unpinned Mod", 0);
530 else if (proj == pn_Mod_M)
532 get_irn_pinned(n) == op_pin_state_pinned,
533 "Memory Proj from unpinned Div", 0);
538 * verify a Proj(Cmp) node
540 static int verify_node_Proj_Cmp(ir_node *n, ir_node *p) {
541 ir_mode *mode = get_irn_mode(p);
542 long proj = get_Proj_proj(p);
546 (proj >= 0 && proj <= 15 && mode == mode_b),
547 "wrong Proj from Cmp", 0,
548 show_proj_failure(p);
551 (mode_is_float(get_irn_mode(get_Cmp_left(n))) || !(proj & pn_Cmp_Uo)),
552 "unordered Proj for non-float Cmp", 0,
553 show_proj_failure(p);
559 * verify a Proj(Load) node
561 static int verify_node_Proj_Load(ir_node *n, ir_node *p) {
562 ir_mode *mode = get_irn_mode(p);
563 long proj = get_Proj_proj(p);
565 if (proj == pn_Load_res) {
566 ir_node *ptr = get_Load_ptr(n);
567 ir_entity *ent = get_ptr_entity(ptr);
569 if (vrfy_entities && ent && get_irg_phase_state(current_ir_graph) == phase_high) {
570 /* do NOT check this for lowered phases, see comment on Store */
572 (mode == get_type_mode(get_entity_type(ent))),
573 "wrong data Proj from Load, entity type_mode failed", 0,
574 show_proj_failure_ent(p, ent);
579 mode_is_data(mode) && mode == get_Load_mode(n),
580 "wrong data Proj from Load", 0,
581 show_proj_failure(p);
588 (proj == pn_Load_M && mode == mode_M) ||
589 (proj == pn_Load_X_regular && mode == mode_X) ||
590 (proj == pn_Load_X_except && mode == mode_X)
592 "wrong Proj from Load", 0,
593 show_proj_failure(p);
596 if (proj == pn_Load_X_regular) {
598 get_irn_pinned(n) == op_pin_state_pinned,
599 "Regular Proj from unpinned Load", 0);
600 } else if (proj == pn_Load_X_except) {
602 get_irn_pinned(n) == op_pin_state_pinned,
603 "Exception Proj from unpinned Load", 0);
609 * verify a Proj(Store) node
611 static int verify_node_Proj_Store(ir_node *n, ir_node *p) {
612 ir_mode *mode = get_irn_mode(p);
613 long proj = get_Proj_proj(p);
617 (proj == pn_Store_M && mode == mode_M) ||
618 (proj == pn_Store_X_regular && mode == mode_X) ||
619 (proj == pn_Store_X_except && mode == mode_X)
621 "wrong Proj from Store", 0,
622 show_proj_failure(p);
624 if (proj == pn_Store_X_regular) {
626 get_irn_pinned(n) == op_pin_state_pinned,
627 "Regular Proj from unpinned Store", 0);
628 } else if (proj == pn_Store_X_except) {
630 get_irn_pinned(n) == op_pin_state_pinned,
631 "Exception Proj from unpinned Store", 0);
637 * verify a Proj(Alloc) node
639 static int verify_node_Proj_Alloc(ir_node *n, ir_node *p) {
640 ir_mode *mode = get_irn_mode(p);
641 long proj = get_Proj_proj(p);
646 (proj == pn_Alloc_M && mode == mode_M) ||
647 (proj == pn_Alloc_X_regular && mode == mode_X) ||
648 (proj == pn_Alloc_X_except && mode == mode_X) ||
649 (proj == pn_Alloc_res && mode_is_reference(mode))
651 "wrong Proj from Alloc", 0,
652 show_proj_failure(p);
658 * verify a Proj(Proj) node
660 static int verify_node_Proj_Proj(ir_node *pred, ir_node *p) {
661 ir_mode *mode = get_irn_mode(p);
662 long proj = get_Proj_proj(p);
663 long nr = get_Proj_proj(pred);
664 ir_type *mt; /* A method type */
666 pred = skip_Id(get_Proj_pred(pred));
667 ASSERT_AND_RET((get_irn_mode(pred) == mode_T), "Proj from something not a tuple", 0);
669 switch (get_irn_opcode(pred)) {
671 mt = get_entity_type(get_irg_entity(get_irn_irg(pred)));
673 if (nr == pn_Start_T_args) {
675 (proj >= 0 && mode_is_datab(mode)),
676 "wrong Proj from Proj from Start", 0);
678 (proj < get_method_n_params(mt)),
679 "More Projs for args than args in type", 0
681 if ((mode_is_reference(mode)) && is_compound_type(get_method_param_type(mt, proj)))
682 /* value argument */ break;
684 if (get_irg_phase_state(get_irn_irg(pred)) != phase_backend) {
686 (mode == get_type_mode(get_method_param_type(mt, proj))),
687 "Mode of Proj from Start doesn't match mode of param type.", 0,
688 show_proj_mode_failure(p, get_method_param_type(mt, proj));
697 (proj >= 0 && mode_is_datab(mode)),
698 "wrong Proj from Proj from Call", 0);
699 mt = get_Call_type(pred);
701 (proj < get_method_n_ress(mt)),
702 "More Projs for results than results in type.", 0);
703 if ((mode_is_reference(mode)) && is_compound_type(get_method_res_type(mt, proj)))
704 /* value result */ break;
707 (mode == get_type_mode(get_method_res_type(mt, proj))),
708 "Mode of Proj from Call doesn't match mode of result type.", 0);
717 /* hmm, optimization did not remove it */
721 /* ASSERT_AND_RET(0, "Unknown opcode", 0); */
728 * verify a Proj(Tuple) node
730 static int verify_node_Proj_Tuple(ir_node *n, ir_node *p) {
738 * verify a Proj(CallBegin) node
740 static int verify_node_Proj_CallBegin(ir_node *n, ir_node *p) {
747 * verify a Proj(EndReg) node
749 static int verify_node_Proj_EndReg(ir_node *n, ir_node *p) {
752 #ifdef INTERPROCEDURAL_VIEW
754 (get_irp_ip_view_state() != ip_view_no),
755 "EndReg may only appear if ip view is constructed.", 0);
761 * verify a Proj(EndExcept) node
763 static int verify_node_Proj_EndExcept(ir_node *n, ir_node *p) {
766 #ifdef INTERPROCEDURAL_VIEW
768 (get_irp_ip_view_state() != ip_view_no),
769 "EndExcept may only appear if ip view is constructed.", 0);
775 * verify a Proj(CopyB) node
777 static int verify_node_Proj_CopyB(ir_node *n, ir_node *p) {
778 ir_mode *mode = get_irn_mode(p);
779 long proj = get_Proj_proj(p);
783 (proj == pn_CopyB_M_regular && mode == mode_M) ||
784 (proj == pn_CopyB_X_regular && mode == mode_X) ||
785 (proj == pn_CopyB_X_except && mode == mode_X) ||
786 (proj == pn_CopyB_M_except && mode == mode_M)
788 "wrong Proj from CopyB", 0,
789 show_proj_failure(p);
791 if (proj == pn_CopyB_X_regular)
793 get_irn_pinned(n) == op_pin_state_pinned,
794 "Regular Proj from unpinned CopyB", 0);
795 else if (proj == pn_CopyB_X_except)
797 get_irn_pinned(n) == op_pin_state_pinned,
798 "Exception Proj from unpinned CopyB", 0);
803 * verify a Proj(Bound) node
805 static int verify_node_Proj_Bound(ir_node *n, ir_node *p) {
806 ir_mode *mode = get_irn_mode(p);
807 long proj = get_Proj_proj(p);
809 /* ignore Bound checks of Bad */
810 if (is_Bad(get_Bound_index(n)))
814 (proj == pn_Bound_M && mode == mode_M) ||
815 (proj == pn_Bound_X_regular && mode == mode_X) ||
816 (proj == pn_Bound_X_except && mode == mode_X) ||
817 (proj == pn_Bound_res && mode == get_irn_mode(get_Bound_index(n)))
819 "wrong Proj from Bound", 0,
820 show_proj_failure(p);
829 verify_node_Proj(ir_node *p, ir_graph *irg) {
833 pred = skip_Id(get_Proj_pred(p));
834 ASSERT_AND_RET(get_irn_mode(pred) == mode_T, "mode of a 'projed' node is not Tuple", 0);
835 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);
837 op = get_irn_op(pred);
839 if (op->ops.verify_proj_node)
840 return op->ops.verify_proj_node(pred, p);
847 * verify a Block node
849 static int verify_node_Block(ir_node *n, ir_graph *irg) {
851 ir_node *mb = get_Block_MacroBlock(n);
853 ASSERT_AND_RET(is_Block(mb) || is_Bad(mb), "Block node with wrong MacroBlock", 0);
855 if (is_Block(mb) && mb != n) {
858 /* Blocks with more than one predecessor must be header blocks */
859 ASSERT_AND_RET(get_Block_n_cfgpreds(n) == 1, "partBlock with more than one predecessor", 0);
860 if (get_irg_phase_state(irg) != phase_backend) {
861 pred = get_Block_cfgpred(n, 0);
863 /* the predecessor MUST be a regular Proj */
864 ir_node *frag_op = get_Proj_pred(pred);
866 is_fragile_op(frag_op) && get_Proj_proj(pred) == pn_Generic_X_regular,
867 "partBlock with non-regular predecessor", 0);
869 /* We allow Jmps to be predecessors of partBlocks. This can happen due to optimization
870 of fragile nodes during construction. It does not violate our assumption of dominance
872 ASSERT_AND_RET(is_Jmp(pred) || is_Bad(pred),
873 "partBlock with non-regular predecessor", 0);
876 /* relax in backend: Bound nodes are probably lowered into conditional jumps */
880 for (i = get_Block_n_cfgpreds(n) - 1; i >= 0; --i) {
881 ir_node *pred = get_Block_cfgpred(n, i);
883 is_Bad(pred) || (get_irn_mode(pred) == mode_X),
884 "Block node must have a mode_X predecessor", 0);
887 if (n == get_irg_end_block(irg) && get_irg_phase_state(irg) != phase_backend)
888 /* End block may only have Return, Raise or fragile ops as preds. */
889 for (i = get_Block_n_cfgpreds(n) - 1; i >= 0; --i) {
890 ir_node *pred = skip_Proj(get_Block_cfgpred(n, i));
891 if (is_Proj(pred) || is_Tuple(pred))
892 break; /* We can not test properly. How many tuples are there? */
900 "End Block node", 0);
902 /* irg attr must == graph we are in. */
903 if (! get_interprocedural_view()) {
904 ASSERT_AND_RET(((get_irn_irg(n) && get_irn_irg(n) == irg)), "Block node has wrong irg attribute", 0);
910 * verify a Start node
912 static int verify_node_Start(ir_node *n, ir_graph *irg) {
913 ir_mode *mymode = get_irn_mode(n);
917 /* Start: BB --> X x M x ref x data1 x ... x datan x ref */
918 mymode == mode_T, "Start node", 0
926 static int verify_node_Jmp(ir_node *n, ir_graph *irg) {
927 ir_mode *mymode = get_irn_mode(n);
932 mymode == mode_X, "Jmp node", 0
938 * verify an IJmp node
940 static int verify_node_IJmp(ir_node *n, ir_graph *irg) {
941 ir_mode *mymode = get_irn_mode(n);
942 ir_mode *op1mode = get_irn_mode(get_IJmp_target(n));
946 /* IJmp: BB x ref --> X */
947 mymode == mode_X && mode_is_reference(op1mode), "IJmp node", 0
953 * verify a Break node
955 static int verify_node_Break(ir_node *n, ir_graph *irg) {
956 ir_mode *mymode = get_irn_mode(n);
959 #ifdef INTERPROCEDURAL_VIEW
960 ASSERT_AND_RET((get_irp_ip_view_state() != ip_view_no),
961 "Break may only appear if ip view is constructed.", 0);
965 mymode == mode_X, "Break node", 0
973 static int verify_node_Cond(ir_node *n, ir_graph *irg) {
974 ir_mode *mymode = get_irn_mode(n);
975 ir_mode *op1mode = get_irn_mode(get_Cond_selector(n));
979 /* Cond: BB x b --> X x X */
980 (op1mode == mode_b ||
981 /* Cond: BB x int --> X^n */
982 mode_is_int(op1mode) ), "Cond node", 0
984 ASSERT_AND_RET(mymode == mode_T, "Cond mode is not a tuple", 0);
990 * verify a Return node
992 static int verify_node_Return(ir_node *n, ir_graph *irg) {
994 ir_mode *mymode = get_irn_mode(n);
995 ir_mode *mem_mode = get_irn_mode(get_Return_mem(n));
998 /* Return: BB x M x data1 x ... x datan --> X */
1000 ASSERT_AND_RET( mem_mode == mode_M, "Return node", 0 ); /* operand M */
1002 for (i = get_Return_n_ress(n) - 1; i >= 0; --i) {
1003 ASSERT_AND_RET( mode_is_datab(get_irn_mode(get_Return_res(n, i))), "Return node", 0 ); /* operand datai */
1005 ASSERT_AND_RET( mymode == mode_X, "Result X", 0 ); /* result X */
1006 /* Compare returned results with result types of method type */
1007 mt = get_entity_type(get_irg_entity(irg));
1008 ASSERT_AND_RET_DBG( get_Return_n_ress(n) == get_method_n_ress(mt),
1009 "Number of results for Return doesn't match number of results in type.", 0,
1010 show_return_nres(irg, n, mt););
1011 for (i = get_Return_n_ress(n) - 1; i >= 0; --i) {
1012 ir_type *res_type = get_method_res_type(mt, i);
1014 if (get_irg_phase_state(irg) != phase_backend) {
1015 if (is_atomic_type(res_type)) {
1017 get_irn_mode(get_Return_res(n, i)) == get_type_mode(res_type),
1018 "Mode of result for Return doesn't match mode of result type.", 0,
1019 show_return_modes(irg, n, mt, i);
1023 mode_is_reference(get_irn_mode(get_Return_res(n, i))),
1024 "Mode of result for Return doesn't match mode of result type.", 0,
1025 show_return_modes(irg, n, mt, i);
1034 * verify a Raise node
1036 static int verify_node_Raise(ir_node *n, ir_graph *irg) {
1037 ir_mode *mymode = get_irn_mode(n);
1038 ir_mode *op1mode = get_irn_mode(get_Raise_mem(n));
1039 ir_mode *op2mode = get_irn_mode(get_Raise_exo_ptr(n));
1043 /* Sel: BB x M x ref --> X x M */
1044 op1mode == mode_M && mode_is_reference(op2mode) &&
1045 mymode == mode_T, "Raise node", 0
1051 * verify a Const node
1053 static int verify_node_Const(ir_node *n, ir_graph *irg) {
1054 ir_mode *mymode = get_irn_mode(n);
1058 /* Const: BB --> data */
1059 (mode_is_data(mymode) ||
1060 mymode == mode_b) /* we want boolean constants for static evaluation */
1061 ,"Const node", 0 /* of Cmp. */
1064 /* the modes of the constant and teh tarval must match */
1065 mymode == get_tarval_mode(get_Const_tarval(n)),
1066 "Const node, tarval and node mode mismatch", 0
1072 * verify a SymConst node
1074 static int verify_node_SymConst(ir_node *n, ir_graph *irg) {
1075 ir_mode *mymode = get_irn_mode(n);
1078 if (get_SymConst_kind(n) == symconst_addr_ent) {
1079 ir_entity *ent = get_SymConst_entity(n);
1080 if (is_Method_type(get_entity_type(ent)) &&
1081 get_irn_irg(n) != get_const_code_irg()) {
1083 ASSERT_AND_RET((get_entity_peculiarity(ent) != peculiarity_description),
1084 "A constant must address an existing method.", 0);
1089 /* SymConst: BB --> int*/
1090 (mode_is_int(mymode) ||
1091 /* SymConst: BB --> ref */
1092 mode_is_reference(mymode))
1093 ,"SymConst node", 0);
1100 static int verify_node_Sel(ir_node *n, ir_graph *irg) {
1102 ir_mode *mymode = get_irn_mode(n);
1103 ir_mode *op1mode = get_irn_mode(get_Sel_mem(n));
1104 ir_mode *op2mode = get_irn_mode(get_Sel_ptr(n));
1109 /* Sel: BB x M x ref x int^n --> ref */
1110 (op1mode == mode_M && op2mode == mymode && mode_is_reference(mymode)),
1111 "Sel node", 0, show_node_failure(n)
1114 for (i = get_Sel_n_indexs(n) - 1; i >= 0; --i) {
1115 ASSERT_AND_RET_DBG(mode_is_int(get_irn_mode(get_Sel_index(n, i))), "Sel node", 0, show_node_failure(n));
1117 ent = get_Sel_entity(n);
1118 ASSERT_AND_RET_DBG(ent, "Sel node with empty entity", 0, show_node_failure(n));
1123 * verify an InstOf node
1125 static int verify_node_InstOf(ir_node *n, ir_graph *irg) {
1126 ir_mode *mymode = get_irn_mode(n);
1127 ir_mode *op1mode = get_irn_mode(get_InstOf_obj(n));
1130 ASSERT_AND_RET(mode_T == mymode, "mode of Instof is not a tuple", 0);
1131 ASSERT_AND_RET(mode_is_data(op1mode), "Instof not on data", 0);
1136 * Check if the pinned state is right.
1138 static int verify_right_pinned(ir_node *n) {
1141 if (get_irn_pinned(n) == op_pin_state_pinned)
1143 mem = get_Call_mem(n);
1145 /* if it's not pinned, its memory predecessor must be NoMem or Pin */
1146 if (is_NoMem(mem) || is_Pin(mem))
1152 * verify a Call node
1154 static int verify_node_Call(ir_node *n, ir_graph *irg) {
1155 ir_mode *mymode = get_irn_mode(n);
1156 ir_mode *op1mode = get_irn_mode(get_Call_mem(n));
1157 ir_mode *op2mode = get_irn_mode(get_Call_ptr(n));
1162 /* Call: BB x M x ref x data1 x ... x datan
1163 --> M x datan+1 x ... x data n+m */
1164 ASSERT_AND_RET( op1mode == mode_M && mode_is_reference(op2mode), "Call node", 0 ); /* operand M x ref */
1166 /* NoMem nodes are only allowed as memory input if the Call is NOT pinned */
1167 ASSERT_AND_RET(verify_right_pinned(n),"Call node with wrong memory input", 0 );
1169 mt = get_Call_type(n);
1170 if(get_unknown_type() == mt) {
1174 for (i = get_Call_n_params(n) - 1; i >= 0; --i) {
1175 ASSERT_AND_RET( mode_is_datab(get_irn_mode(get_Call_param(n, i))), "Call node", 0 ); /* operand datai */
1178 ASSERT_AND_RET( mymode == mode_T, "Call result not a tuple", 0 ); /* result T */
1179 /* Compare arguments of node with those of type */
1181 if (get_method_variadicity(mt) == variadicity_variadic) {
1183 get_Call_n_params(n) >= get_method_n_params(mt),
1184 "Number of args for Call doesn't match number of args in variadic type.",
1186 ir_fprintf(stderr, "Call %+F has %d params, method %s type %d\n",
1187 n, get_Call_n_params(n), get_type_name(mt), get_method_n_params(mt));
1191 get_Call_n_params(n) == get_method_n_params(mt),
1192 "Number of args for Call doesn't match number of args in non variadic type.",
1194 ir_fprintf(stderr, "Call %+F has %d params, method %s type %d\n",
1195 n, get_Call_n_params(n), get_type_name(mt), get_method_n_params(mt));
1199 for (i = 0; i < get_method_n_params(mt); i++) {
1200 ir_type *t = get_method_param_type(mt, i);
1202 if (get_irg_phase_state(irg) != phase_backend) {
1203 if (is_atomic_type(t)) {
1205 get_irn_mode(get_Call_param(n, i)) == get_type_mode(t),
1206 "Mode of arg for Call doesn't match mode of arg type.", 0,
1207 show_call_param(n, mt);
1210 /* call with a compound type, mode must be reference */
1212 mode_is_reference(get_irn_mode(get_Call_param(n, i))),
1213 "Mode of arg for Call doesn't match mode of arg type.", 0,
1214 show_call_param(n, mt);
1221 if (Call_has_callees(n)) {
1222 for (i = 0; i < get_Call_n_callees(n); i++) {
1223 ASSERT_AND_RET(is_entity(get_Call_callee(n, i)), "callee array must contain entities.", 0);
1231 * verify an Add node
1233 static int verify_node_Add(ir_node *n, ir_graph *irg) {
1234 ir_mode *mymode = get_irn_mode(n);
1235 ir_mode *op1mode = get_irn_mode(get_Add_left(n));
1236 ir_mode *op2mode = get_irn_mode(get_Add_right(n));
1241 /* common Add: BB x numP x numP --> numP */
1242 (op1mode == mymode && op2mode == op1mode && mode_is_data(mymode)) ||
1243 /* Pointer Add: BB x ref x int --> ref */
1244 (mode_is_reference(op1mode) && mode_is_int(op2mode) && op1mode == mymode) ||
1245 /* Pointer Add: BB x int x ref --> ref */
1246 (mode_is_int(op1mode) && op2mode == mymode && mode_is_reference(mymode))
1249 show_binop_failure(n, "/* common Add: BB x numP x numP --> numP */ |\n"
1250 "/* Pointer Add: BB x ref x int --> ref */ |\n"
1251 "/* Pointer Add: BB x int x ref --> ref */");
1259 static int verify_node_Sub(ir_node *n, ir_graph *irg) {
1260 ir_mode *mymode = get_irn_mode(n);
1261 ir_mode *op1mode = get_irn_mode(get_Sub_left(n));
1262 ir_mode *op2mode = get_irn_mode(get_Sub_right(n));
1267 /* common Sub: BB x numP x numP --> numP */
1268 (mymode ==op1mode && mymode == op2mode && mode_is_data(op1mode)) ||
1269 /* Pointer Sub: BB x ref x int --> ref */
1270 (op1mode == mymode && mode_is_int(op2mode) && mode_is_reference(mymode)) ||
1271 /* Pointer Sub: BB x ref x ref --> int */
1272 (op1mode == op2mode && mode_is_reference(op2mode) && mode_is_int(mymode))
1275 show_binop_failure(n, "/* common Sub: BB x numP x numP --> numP */ |\n"
1276 "/* Pointer Sub: BB x ref x int --> ref */ |\n"
1277 "/* Pointer Sub: BB x ref x ref --> int */" );
1283 * verify a Minus node
1285 static int verify_node_Minus(ir_node *n, ir_graph *irg) {
1286 ir_mode *mymode = get_irn_mode(n);
1287 ir_mode *op1mode = get_irn_mode(get_Minus_op(n));
1291 /* Minus: BB x num --> num */
1292 op1mode == mymode && mode_is_num(op1mode), "Minus node", 0,
1293 show_unop_failure(n , "/* Minus: BB x num --> num */");
1301 static int verify_node_Mul(ir_node *n, ir_graph *irg) {
1302 ir_mode *mymode = get_irn_mode(n);
1303 ir_mode *op1mode = get_irn_mode(get_Mul_left(n));
1304 ir_mode *op2mode = get_irn_mode(get_Mul_right(n));
1309 /* Mul: BB x int_n x int_n --> int_n|int_2n */
1310 (mode_is_int(op1mode) && op2mode == op1mode && mode_is_int(mymode) &&
1311 (op1mode == mymode || get_mode_size_bits(op1mode) * 2 == get_mode_size_bits(mymode))) ||
1312 /* Mul: BB x float x float --> float */
1313 (mode_is_float(op1mode) && op2mode == op1mode && mymode == op1mode)
1316 show_binop_failure(n, "/* Mul: BB x int_n x int_n --> int_n|int_2n */ |\n"
1317 "/* Mul: BB x float x float --> float */");
1323 * verify a Mulh node
1325 static int verify_node_Mulh(ir_node *n, ir_graph *irg) {
1326 ir_mode *mymode = get_irn_mode(n);
1327 ir_mode *op1mode = get_irn_mode(get_Mulh_left(n));
1328 ir_mode *op2mode = get_irn_mode(get_Mulh_right(n));
1333 /* Mulh: BB x int x int --> int */
1334 (mode_is_int(op1mode) && op2mode == op1mode && op1mode == mymode)
1337 show_binop_failure(n, "/* Mulh: BB x int x int --> int */");
1343 * verify a Quot node
1345 static int verify_node_Quot(ir_node *n, ir_graph *irg) {
1346 ir_mode *mymode = get_irn_mode(n);
1347 ir_mode *op1mode = get_irn_mode(get_Quot_mem(n));
1348 ir_mode *op2mode = get_irn_mode(get_Quot_left(n));
1349 ir_mode *op3mode = get_irn_mode(get_Quot_right(n));
1353 /* Quot: BB x M x float x float --> M x X x float */
1354 op1mode == mode_M && op2mode == op3mode &&
1355 get_mode_sort(op2mode) == irms_float_number &&
1358 show_binop_failure(n, "/* Quot: BB x M x float x float --> M x X x float */");
1364 * verify a DivMod node
1366 static int verify_node_DivMod(ir_node *n, ir_graph *irg) {
1367 ir_mode *mymode = get_irn_mode(n);
1368 ir_mode *op1mode = get_irn_mode(get_DivMod_mem(n));
1369 ir_mode *op2mode = get_irn_mode(get_DivMod_left(n));
1370 ir_mode *op3mode = get_irn_mode(get_DivMod_right(n));
1374 /* DivMod: BB x M x int x int --> M x X x int x int */
1375 op1mode == mode_M &&
1376 mode_is_int(op2mode) &&
1377 op3mode == op2mode &&
1387 static int verify_node_Div(ir_node *n, ir_graph *irg) {
1388 ir_mode *mymode = get_irn_mode(n);
1389 ir_mode *op1mode = get_irn_mode(get_Div_mem(n));
1390 ir_mode *op2mode = get_irn_mode(get_Div_left(n));
1391 ir_mode *op3mode = get_irn_mode(get_Div_right(n));
1395 /* Div: BB x M x int x int --> M x X x int */
1396 op1mode == mode_M &&
1397 op2mode == op3mode &&
1398 mode_is_int(op2mode) &&
1408 static int verify_node_Mod(ir_node *n, ir_graph *irg) {
1409 ir_mode *mymode = get_irn_mode(n);
1410 ir_mode *op1mode = get_irn_mode(get_Mod_mem(n));
1411 ir_mode *op2mode = get_irn_mode(get_Mod_left(n));
1412 ir_mode *op3mode = get_irn_mode(get_Mod_right(n));
1416 /* Mod: BB x M x int x int --> M x X x int */
1417 op1mode == mode_M &&
1418 op2mode == op3mode &&
1419 mode_is_int(op2mode) &&
1427 * verify an Abs node
1429 static int verify_node_Abs(ir_node *n, ir_graph *irg) {
1430 ir_mode *mymode = get_irn_mode(n);
1431 ir_mode *op1mode = get_irn_mode(get_Abs_op(n));
1435 /* Abs: BB x num --> num */
1436 op1mode == mymode &&
1437 mode_is_num (op1mode),
1439 show_unop_failure(n, "/* Abs: BB x num --> num */");
1445 * verify a logical And, Or, Eor node
1447 static int verify_node_Logic(ir_node *n, ir_graph *irg) {
1448 ir_mode *mymode = get_irn_mode(n);
1449 ir_mode *op1mode = get_irn_mode(get_binop_left(n));
1450 ir_mode *op2mode = get_irn_mode(get_binop_right(n));
1454 /* And or Or or Eor: BB x int x int --> int */
1455 (mode_is_int(mymode) || mymode == mode_b) &&
1456 op2mode == op1mode &&
1458 "And, Or or Eor node", 0,
1459 show_binop_failure(n, "/* And or Or or Eor: BB x int x int --> int */");
1464 #define verify_node_And verify_node_Logic
1465 #define verify_node_Or verify_node_Logic
1466 #define verify_node_Eor verify_node_Logic
1471 static int verify_node_Not(ir_node *n, ir_graph *irg) {
1472 ir_mode *mymode = get_irn_mode(n);
1473 ir_mode *op1mode = get_irn_mode(get_Not_op(n));
1477 /* Not: BB x int --> int */
1478 (mode_is_int(mymode) || mymode == mode_b) &&
1481 show_unop_failure(n, "/* Not: BB x int --> int */");
1489 static int verify_node_Cmp(ir_node *n, ir_graph *irg) {
1490 ir_mode *mymode = get_irn_mode(n);
1491 ir_mode *op1mode = get_irn_mode(get_Cmp_left(n));
1492 ir_mode *op2mode = get_irn_mode(get_Cmp_right(n));
1496 /* Cmp: BB x datab x datab --> b16 */
1497 mode_is_datab(op1mode) &&
1498 op2mode == op1mode &&
1501 show_binop_failure(n, "/* Cmp: BB x datab x datab --> b16 */");
1507 * verify a Shift node
1509 static int verify_node_Shift(ir_node *n, ir_graph *irg) {
1510 ir_mode *mymode = get_irn_mode(n);
1511 ir_mode *op1mode = get_irn_mode(get_binop_left(n));
1512 ir_mode *op2mode = get_irn_mode(get_binop_right(n));
1516 /* Shl, Shr or Shrs: BB x int x int_u --> int */
1517 mode_is_int(op1mode) &&
1518 mode_is_int(op2mode) &&
1519 !mode_is_signed(op2mode) &&
1521 "Shl, Shr or Shrs node", 0,
1522 show_binop_failure(n, "/* Shl, Shr or Shrs: BB x int x int_u --> int */");
1527 #define verify_node_Shl verify_node_Shift
1528 #define verify_node_Shr verify_node_Shift
1529 #define verify_node_Shrs verify_node_Shift
1532 * verify a Rotl node
1534 static int verify_node_Rotl(ir_node *n, ir_graph *irg) {
1535 ir_mode *mymode = get_irn_mode(n);
1536 ir_mode *op1mode = get_irn_mode(get_Rotl_left(n));
1537 ir_mode *op2mode = get_irn_mode(get_Rotl_right(n));
1541 /* Rotl: BB x int x int --> int */
1542 mode_is_int(op1mode) &&
1543 mode_is_int(op2mode) &&
1546 show_binop_failure(n, "/* Rotl: BB x int x int --> int */");
1552 * verify a Conv node
1554 static int verify_node_Conv(ir_node *n, ir_graph *irg) {
1555 ir_mode *mymode = get_irn_mode(n);
1556 ir_mode *op1mode = get_irn_mode(get_Conv_op(n));
1560 get_irg_phase_state(irg) == phase_backend ||
1561 (mode_is_datab(op1mode) && mode_is_data(mymode)),
1563 show_unop_failure(n, "/* Conv: BB x datab --> data */");
1569 * verify a Cast node
1571 static int verify_node_Cast(ir_node *n, ir_graph *irg) {
1572 ir_mode *mymode = get_irn_mode(n);
1573 ir_mode *op1mode = get_irn_mode(get_Cast_op(n));
1577 /* Conv: BB x datab1 --> datab2 */
1578 mode_is_data(op1mode) && op1mode == mymode,
1580 show_unop_failure(n, "/* Conv: BB x datab1 --> datab2 */");
1588 static int verify_node_Phi(ir_node *n, ir_graph *irg) {
1589 ir_mode *mymode = get_irn_mode(n);
1590 ir_node *block = get_nodes_block(n);
1594 if (! is_Bad(block) && get_irg_phase_state(get_irn_irg(n)) != phase_building && get_irn_arity(n) > 0) {
1595 /* a Phi node MUST have the same number of inputs as its block */
1597 get_irn_arity(n) == get_irn_arity(block),
1598 "wrong number of inputs in Phi node", 0,
1599 show_phi_inputs(n, block);
1603 /* Phi: BB x dataM^n --> dataM */
1604 for (i = get_Phi_n_preds(n) - 1; i >= 0; --i) {
1605 ir_node *pred = get_Phi_pred(n, i);
1606 if (!is_Bad(pred)) {
1608 get_irn_mode(pred) == mymode,
1610 show_phi_failure(n, pred, i);
1614 ASSERT_AND_RET(mode_is_dataM(mymode) || mymode == mode_b, "Phi node", 0 );
1616 if (mymode == mode_M) {
1617 for (i = get_Phi_n_preds(n) - 1; i >= 0; --i) {
1619 ir_node *pred_i = get_Phi_pred(n, i);
1623 for (j = i - 1; j >= 0; --j) {
1624 ir_node *pred_j = get_Phi_pred(n, j);
1629 /* currently this checks fails for blocks with exception
1630 outputs (and these are NOT basic blocks). So it is disabled yet. */
1632 (pred_i == pred_j) || (get_irn_n(pred_i, -1) != get_irn_n(pred_j, -1)),
1633 "At least two different PhiM predecessors are in the same block",
1635 ir_printf("%+F and %+F of %+F are in %+F\n", pred_i, pred_j, n, get_irn_n(pred_i, -1))
1645 * verify a Filter node
1647 static int verify_node_Filter(ir_node *n, ir_graph *irg) {
1650 #ifdef INTERPROCEDURAL_VIEW
1651 ASSERT_AND_RET((get_irp_ip_view_state() != ip_view_no),
1652 "Filter may only appear if ip view is constructed.", 0);
1654 /* We should further do tests as for Proj and Phi. */
1659 * verify a Load node
1661 static int verify_node_Load(ir_node *n, ir_graph *irg) {
1662 ir_mode *mymode = get_irn_mode(n);
1663 ir_mode *op1mode = get_irn_mode(get_Load_mem(n));
1664 ir_mode *op2mode = get_irn_mode(get_Load_ptr(n));
1666 ASSERT_AND_RET(op1mode == mode_M, "Load node", 0);
1667 if (get_irg_phase_state(irg) != phase_backend) {
1668 ASSERT_AND_RET(mode_is_reference(op2mode), "Load node", 0 );
1670 ASSERT_AND_RET( mymode == mode_T, "Load node", 0 );
1673 * jack's gen_add_firm_code:simpleSel seems to build Load (Load
1674 * (Proj (Proj))) sometimes ...
1676 * interprete.c:ai_eval seems to assume that this happens, too
1678 * obset.c:get_abstval_any can't deal with this if the load has
1682 ir_entity *ent = hunt_for_entity (get_Load_ptr (n), n);
1683 assert ((NULL != ent) || (mymode != mode_T));
1691 * verify a Store node
1693 static int verify_node_Store(ir_node *n, ir_graph *irg) {
1696 ir_mode *mymode = get_irn_mode(n);
1697 ir_mode *op1mode = get_irn_mode(get_Store_mem(n));
1698 ir_mode *op2mode = get_irn_mode(get_Store_ptr(n));
1699 ir_mode *op3mode = get_irn_mode(get_Store_value(n));
1701 ASSERT_AND_RET(op1mode == mode_M && mode_is_datab(op3mode), "Store node", 0 );
1702 if (get_irg_phase_state(irg) != phase_backend) {
1703 ASSERT_AND_RET(mode_is_reference(op2mode), "Store node", 0 );
1705 ASSERT_AND_RET(mymode == mode_T, "Store node", 0);
1707 target = get_ptr_entity(get_Store_ptr(n));
1708 if (vrfy_entities && target && get_irg_phase_state(current_ir_graph) == phase_high) {
1710 * If lowered code, any Sels that add 0 may be removed, causing
1711 * an direct access to entities of array or compound type.
1712 * Prevent this by checking the phase.
1714 ASSERT_AND_RET( op3mode == get_type_mode(get_entity_type(target)),
1722 * verify an Alloc node
1724 static int verify_node_Alloc(ir_node *n, ir_graph *irg) {
1725 ir_mode *mymode = get_irn_mode(n);
1726 ir_mode *op1mode = get_irn_mode(get_Alloc_mem(n));
1727 ir_mode *op2mode = get_irn_mode(get_Alloc_size(n));
1731 /* Alloc: BB x M x int_u --> M x X x ref */
1732 op1mode == mode_M &&
1733 mode_is_int(op2mode) &&
1734 !mode_is_signed(op2mode) &&
1737 show_node_failure(n);
1743 * verify a Free node
1745 static int verify_node_Free(ir_node *n, ir_graph *irg) {
1746 ir_mode *mymode = get_irn_mode(n);
1747 ir_mode *op1mode = get_irn_mode(get_Free_mem(n));
1748 ir_mode *op2mode = get_irn_mode(get_Free_ptr(n));
1749 ir_mode *op3mode = get_irn_mode(get_Free_size(n));
1753 /* Free: BB x M x ref x int_u --> M */
1754 op1mode == mode_M && mode_is_reference(op2mode) &&
1755 mode_is_int(op3mode) &&
1756 !mode_is_signed(op3mode) &&
1759 show_triop_failure(n, "/* Free: BB x M x ref x int_u --> M */");
1765 * verify a Sync node
1767 static int verify_node_Sync(ir_node *n, ir_graph *irg) {
1769 ir_mode *mymode = get_irn_mode(n);
1772 /* Sync: BB x M^n --> M */
1773 for (i = get_Sync_n_preds(n) - 1; i >= 0; --i) {
1774 ASSERT_AND_RET( get_irn_mode(get_Sync_pred(n, i)) == mode_M, "Sync node", 0 );
1776 ASSERT_AND_RET( mymode == mode_M, "Sync node", 0 );
1781 * verify a Confirm node
1783 static int verify_node_Confirm(ir_node *n, ir_graph *irg) {
1784 ir_mode *mymode = get_irn_mode(n);
1785 ir_mode *op1mode = get_irn_mode(get_Confirm_value(n));
1786 ir_mode *op2mode = get_irn_mode(get_Confirm_bound(n));
1790 /* Confirm: BB x T x T --> T */
1791 op1mode == mymode &&
1794 show_binop_failure(n, "/* Confirm: BB x T x T --> T */");
1802 static int verify_node_Mux(ir_node *n, ir_graph *irg) {
1803 ir_mode *mymode = get_irn_mode(n);
1804 ir_mode *op1mode = get_irn_mode(get_Mux_sel(n));
1805 ir_mode *op2mode = get_irn_mode(get_Mux_true(n));
1806 ir_mode *op3mode = get_irn_mode(get_Mux_false(n));
1810 /* Mux: BB x b x datab x datab --> datab */
1811 op1mode == mode_b &&
1812 op2mode == mymode &&
1813 op3mode == mymode &&
1814 mode_is_datab(mymode),
1821 * verify a CopyB node
1823 static int verify_node_CopyB(ir_node *n, ir_graph *irg) {
1824 ir_mode *mymode = get_irn_mode(n);
1825 ir_mode *op1mode = get_irn_mode(get_CopyB_mem(n));
1826 ir_mode *op2mode = get_irn_mode(get_CopyB_dst(n));
1827 ir_mode *op3mode = get_irn_mode(get_CopyB_src(n));
1828 ir_type *t = get_CopyB_type(n);
1830 /* CopyB: BB x M x ref x ref --> M x X */
1831 ASSERT_AND_RET(mymode == mode_T && op1mode == mode_M, "CopyB node", 0);
1832 if (get_irg_phase_state(irg) != phase_backend) {
1833 ASSERT_AND_RET(mode_is_reference(op2mode) && mode_is_reference(op3mode),
1838 is_compound_type(t),
1839 "CopyB node should copy compound types only", 0 );
1841 /* NoMem nodes are only allowed as memory input if the CopyB is NOT pinned.
1842 This should happen RARELY, as CopyB COPIES MEMORY */
1843 ASSERT_AND_RET(verify_right_pinned(n), "CopyB node with wrong memory input", 0 );
1848 * verify a Bound node
1850 static int verify_node_Bound(ir_node *n, ir_graph *irg) {
1851 ir_mode *mymode = get_irn_mode(n);
1852 ir_mode *op1mode = get_irn_mode(get_Bound_mem(n));
1853 ir_mode *op2mode = get_irn_mode(get_Bound_index(n));
1854 ir_mode *op3mode = get_irn_mode(get_Bound_lower(n));
1855 ir_mode *op4mode = get_irn_mode(get_Bound_upper(n));
1858 /* Bound: BB x M x int x int x int --> M x X */
1861 op1mode == mode_M &&
1862 op2mode == op3mode &&
1863 op3mode == op4mode &&
1864 mode_is_int(op3mode),
1871 * For each usage of a node, it is checked, if the block of the
1872 * node dominates the block of the usage (for phis: the predecessor
1873 * block of the phi for the corresponding edge).
1875 * @return non-zero on success, 0 on dominance error
1877 static int check_dominance_for_node(ir_node *use) {
1878 if (is_Block(use)) {
1879 ir_node *mbh = get_Block_MacroBlock(use);
1882 /* must be a partBlock */
1883 if (is_Block(mbh)) {
1884 ASSERT_AND_RET(block_dominates(mbh, use), "MacroBlock header must dominate a partBlock", 0);
1888 /* This won't work for blocks and the end node */
1889 else if (use != get_irg_end(current_ir_graph) && use != current_ir_graph->anchor) {
1891 ir_node *bl = get_nodes_block(use);
1893 for (i = get_irn_arity(use) - 1; i >= 0; --i) {
1894 ir_node *def = get_irn_n(use, i);
1895 ir_node *def_bl = get_nodes_block(def);
1896 ir_node *use_bl = bl;
1898 /* ignore dead definition blocks, will be removed */
1899 if (is_Block_dead(def_bl) || get_Block_dom_depth(def_bl) == -1)
1903 use_bl = get_Block_cfgpred_block(bl, i);
1905 /* ignore dead use blocks, will be removed */
1906 if (is_Block_dead(use_bl) || get_Block_dom_depth(use_bl) == -1)
1910 block_dominates(def_bl, use_bl),
1911 "the definition of a value used violates the dominance property", 0,
1913 "graph %+F: %+F of %+F must dominate %+F of user %+F input %d\n",
1914 current_ir_graph, def_bl, def, use_bl, use, i
1922 /* Tests the modes of n and its predecessors. */
1923 int irn_vrfy_irg(ir_node *n, ir_graph *irg) {
1927 if (!get_node_verification_mode())
1930 if (!get_interprocedural_view()) {
1932 * do NOT check placement in interprocedural view, as we don't always know
1933 * the "right" graph ...
1937 /* this seems to be an expensive check in VS compile (9% over all runtime),
1938 so do NOT run it in release mode */
1940 node_is_in_irgs_storage(irg, n),
1941 "Node is not stored on proper IR graph!", 0,
1942 show_node_on_graph(irg, n);
1945 assert(get_irn_irg(n) == irg);
1947 unsigned idx = get_irn_idx(n);
1948 ir_node *node_from_map = get_idx_irn(irg, idx);
1949 ASSERT_AND_RET_DBG(node_from_map == n, "Node index and index map entry differ", 0,
1950 ir_printf("node %+F node in map %+F(%p)\n", n, node_from_map, node_from_map));
1956 /* We don't want to test nodes whose predecessors are Bad,
1957 as we would have to special case that for each operation. */
1958 if (op != op_Phi && op != op_Block) {
1959 for (i = get_irn_arity(n) - 1; i >= 0; --i) {
1960 if (is_Bad(get_irn_n(n, i)))
1965 if (_get_op_pinned(op) >= op_pin_state_exc_pinned) {
1966 op_pin_state state = get_irn_pinned(n);
1968 state == op_pin_state_floats ||
1969 state == op_pin_state_pinned,
1970 "invalid pin state", 0,
1971 ir_printf("node %+F", n));
1974 if (op->ops.verify_node)
1975 return op->ops.verify_node(n, irg);
1981 int irn_vrfy(ir_node *n) {
1982 #ifdef DEBUG_libfirm
1983 return irn_vrfy_irg(n, current_ir_graph);
1990 /*-----------------------------------------------------------------*/
1991 /* Verify the whole graph. */
1992 /*-----------------------------------------------------------------*/
1994 #ifdef DEBUG_libfirm
1996 * Walker to check every node
1998 static void vrfy_wrap(ir_node *node, void *env) {
2000 *res = irn_vrfy(node);
2004 * Walker to check every node including SSA property.
2005 * Only called if dominance info is available.
2007 static void vrfy_wrap_ssa(ir_node *node, void *env) {
2010 *res = irn_vrfy(node);
2012 *res = check_dominance_for_node(node);
2016 #endif /* DEBUG_libfirm */
2019 * Calls irn_vrfy for each node in irg.
2020 * Graph must be in state "op_pin_state_pinned".
2021 * If dominance info is available, check the SSA property.
2023 int irg_verify(ir_graph *irg, unsigned flags) {
2025 #ifdef DEBUG_libfirm
2028 rem = current_ir_graph;
2029 current_ir_graph = irg;
2032 last_irg_error = NULL;
2035 assert(get_irg_pinned(irg) == op_pin_state_pinned && "Verification need pinned graph");
2037 if (flags & VRFY_ENFORCE_SSA)
2042 get_irg_dom_state(irg) == dom_consistent &&
2043 get_irg_pinned(irg) == op_pin_state_pinned ? vrfy_wrap_ssa : vrfy_wrap,
2047 current_ir_graph = rem;
2049 if (get_node_verification_mode() == FIRM_VERIFICATION_REPORT && ! res) {
2050 ir_entity *ent = get_irg_entity(current_ir_graph);
2053 fprintf(stderr, "irg_verify: Verifying graph %s failed\n", get_entity_name(ent));
2055 fprintf(stderr, "irg_verify: Verifying graph %p failed\n", (void *)current_ir_graph);
2060 #endif /* DEBUG_libfirm */
2065 int irn_vrfy_irg_dump(ir_node *n, ir_graph *irg, const char **bad_string) {
2067 firm_verification_t old = get_node_verification_mode();
2069 firm_vrfy_failure_msg = NULL;
2070 do_node_verification(FIRM_VERIFICATION_ERROR_ONLY);
2071 res = irn_vrfy_irg(n, irg);
2072 if (res && get_irg_dom_state(irg) == dom_consistent &&
2073 get_irg_pinned(irg) == op_pin_state_pinned)
2074 res = check_dominance_for_node(n);
2075 do_node_verification(old);
2076 *bad_string = firm_vrfy_failure_msg;
2082 typedef struct _vrfy_bad_env_t {
2088 * Pre-Walker: check Bad predecessors of node.
2090 static void check_bads(ir_node *node, void *env) {
2091 vrfy_bad_env_t *venv = env;
2092 int i, arity = get_irn_arity(node);
2094 if (is_Block(node)) {
2095 if ((venv->flags & BAD_CF) == 0) {
2097 /* check for Bad Block predecessor */
2098 for (i = 0; i < arity; ++i) {
2099 ir_node *pred = get_irn_n(node, i);
2102 venv->res |= BAD_CF;
2104 if (get_node_verification_mode() == FIRM_VERIFICATION_REPORT) {
2105 fprintf(stderr, "irg_vrfy_bads: Block %ld has Bad predecessor\n", get_irn_node_nr(node));
2107 if (get_node_verification_mode() == FIRM_VERIFICATION_ON) {
2108 dump_ir_block_graph_sched(current_ir_graph, "-assert");
2109 assert(0 && "Bad CF detected");
2115 if ((venv->flags & BAD_BLOCK) == 0) {
2117 /* check for Bad Block */
2118 if (is_Bad(get_nodes_block(node))) {
2119 venv->res |= BAD_BLOCK;
2121 if (get_node_verification_mode() == FIRM_VERIFICATION_REPORT) {
2122 fprintf(stderr, "irg_vrfy_bads: node %ld has Bad Block\n", get_irn_node_nr(node));
2124 if (get_node_verification_mode() == FIRM_VERIFICATION_ON) {
2125 dump_ir_block_graph_sched(current_ir_graph, "-assert");
2126 assert(0 && "Bad CF detected");
2131 if ((venv->flags & TUPLE) == 0) {
2132 if (is_Tuple(node)) {
2135 if (get_node_verification_mode() == FIRM_VERIFICATION_REPORT) {
2136 fprintf(stderr, "irg_vrfy_bads: node %ld is a Tuple\n", get_irn_node_nr(node));
2138 if (get_node_verification_mode() == FIRM_VERIFICATION_ON) {
2139 dump_ir_block_graph_sched(current_ir_graph, "-assert");
2140 assert(0 && "Tuple detected");
2145 for (i = 0; i < arity; ++i) {
2146 ir_node *pred = get_irn_n(node, i);
2149 /* check for Phi with Bad inputs */
2150 if (is_Phi(node) && !is_Bad(get_nodes_block(node)) && is_Bad(get_irn_n(get_nodes_block(node), i))) {
2151 if (venv->flags & BAD_CF)
2154 venv->res |= BAD_CF;
2156 if (get_node_verification_mode() == FIRM_VERIFICATION_REPORT) {
2157 fprintf(stderr, "irg_vrfy_bads: Phi %ld has Bad Input\n", get_irn_node_nr(node));
2159 if (get_node_verification_mode() == FIRM_VERIFICATION_ON) {
2160 dump_ir_block_graph_sched(current_ir_graph, "-assert");
2161 assert(0 && "Bad CF detected");
2166 /* Bad node input */
2167 if ((venv->flags & BAD_DF) == 0) {
2168 venv->res |= BAD_DF;
2170 if (get_node_verification_mode() == FIRM_VERIFICATION_REPORT) {
2171 fprintf(stderr, "irg_vrfy_bads: node %ld has Bad Input\n", get_irn_node_nr(node));
2173 if (get_node_verification_mode() == FIRM_VERIFICATION_ON) {
2174 dump_ir_block_graph_sched(current_ir_graph, "-assert");
2175 assert(0 && "Bad NON-CF detected");
2184 * verify occurrence of bad nodes
2186 int irg_vrfy_bads(ir_graph *irg, int flags) {
2192 irg_walk_graph(irg, check_bads, NULL, &env);
2198 * set the default verify operation
2200 void firm_set_default_verifyer(ir_opcode code, ir_op_ops *ops) {
2203 ops->verify_node = verify_node_##a; \
2260 ops->verify_proj_node = verify_node_Proj_##a; \