Add a hint about the infamous pn_Cmp_Lg/Ne mixup in the assertion message of verify_n...
[libfirm] / ir / ir / irverify.c
1 /*
2  * Copyright (C) 1995-2010 University of Karlsruhe.  All right reserved.
3  *
4  * This file is part of libFirm.
5  *
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.
10  *
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.
14  *
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
17  * PURPOSE.
18  */
19
20 /**
21  * @file
22  * @brief    Check irnodes for correctness.
23  * @author   Christian Schaefer, Goetz Lindenmaier, Till Riedel, Michael Beck
24  * @version  $Id$
25  */
26 #include "config.h"
27
28 #include "irprog.h"
29 #include "irop_t.h"
30 #include "irgraph_t.h"
31 #include "irverify_t.h"
32 #include "irgwalk.h"
33 #include "irdump.h"
34 #include "irdom_t.h"
35 #include "irprintf.h"
36 #include "irouts.h"
37 #include "irflag_t.h"
38 #include "irpass_t.h"
39
40 /** if this flag is set, verify entity types in Load & Store nodes */
41 static int verify_entities = 0;
42
43 const char *firm_verify_failure_msg;
44
45 /* enable verification of Load/Store entities */
46 void verify_enable_entity_tests(int enable)
47 {
48         verify_entities = enable;
49 }
50
51 #ifndef NDEBUG
52
53 /**
54  * little helper for NULL modes
55  */
56 static const char *get_mode_name_ex(ir_mode *mode)
57 {
58         if (! mode)
59                 return "<no mode>";
60         return get_mode_name(mode);
61 }
62
63 /** the last IRG, on which a verification error was found */
64 static ir_graph *last_irg_error = NULL;
65
66 /**
67  * print the name of the entity of an verification failure
68  *
69  * @param node  the node caused the failure
70  */
71 static void show_entity_failure(ir_node *node)
72 {
73         ir_graph *irg = get_irn_irg(node);
74
75         if (last_irg_error == irg)
76                 return;
77
78         last_irg_error = irg;
79
80         if (irg == get_const_code_irg()) {
81                 fprintf(stderr, "\nFIRM: irn_verify_irg() <of CONST_CODE_IRG> failed\n");
82         } else {
83                 ir_entity *ent = get_irg_entity(irg);
84
85                 if (ent) {
86                         ir_type *ent_type = get_entity_owner(ent);
87
88                         if (ent_type) {
89                                 ir_fprintf(stderr, "\nFIRM: irn_verify_irg() %+F::%s failed\n",
90                                            ent_type, get_entity_name(ent));
91                         } else {
92                                 fprintf(stderr, "\nFIRM: irn_verify_irg() <NULL>::%s failed\n", get_entity_name(ent));
93                         }
94                 } else {
95                         fprintf(stderr, "\nFIRM: irn_verify_irg() <IRG %p> failed\n", (void *)irg);
96                 }
97         }
98 }
99
100 static const char *get_irn_modename(const ir_node *node)
101 {
102         ir_mode *mode = get_irn_mode(node);
103         return get_mode_name(mode);
104 }
105
106 /**
107  * Prints a failure for a Node
108  */
109 static void show_node_failure(ir_node *n)
110 {
111         show_entity_failure(n);
112         fprintf(stderr, "  node %ld %s%s\n" ,
113                 get_irn_node_nr(n),
114                 get_irn_opname(n), get_irn_modename(n)
115         );
116 }
117
118 /**
119  * Prints a failure message for a binop
120  */
121 static void show_binop_failure(ir_node *n, const char *text)
122 {
123         ir_node *left  = get_binop_left(n);
124         ir_node *right = get_binop_right(n);
125
126         show_entity_failure(n);
127         fprintf(stderr, "  node %ld %s%s(%s%s, %s%s) did not match (%s)\n",
128                 get_irn_node_nr(n),
129                 get_irn_opname(n), get_irn_modename(n),
130                 get_irn_opname(left), get_irn_modename(left),
131                 get_irn_opname(right), get_irn_modename(right),
132                 text);
133 }
134
135 /**
136  * Prints a failure message for an unop
137  */
138 static void show_unop_failure(ir_node *n, const char *text)
139 {
140         ir_node *op  = get_unop_op(n);
141
142         show_entity_failure(n);
143         fprintf(stderr, "  node %ld %s%s(%s%s) did not match (%s)\n",
144                 get_irn_node_nr(n),
145                 get_irn_opname(n), get_irn_modename(n),
146                 get_irn_opname(op), get_irn_modename(op),
147                 text);
148 }
149
150 /**
151  * Prints a failure message for an op with 3 operands
152  */
153 static void show_triop_failure(ir_node *n, const char *text)
154 {
155         ir_node *op0  = get_irn_n(n, 0);
156         ir_node *op1  = get_irn_n(n, 1);
157         ir_node *op2  = get_irn_n(n, 2);
158
159         show_entity_failure(n);
160         fprintf(stderr, "  of node %ld %s%s(%s%s, %s%s, %s%s) did not match (%s)\n",
161                 get_irn_node_nr(n),
162                 get_irn_opname(n), get_irn_modename(n),
163                 get_irn_opname(op0), get_irn_modename(op0),
164                 get_irn_opname(op1), get_irn_modename(op1),
165                 get_irn_opname(op2), get_irn_modename(op2),
166                 text);
167 }
168
169 /**
170  * Prints a failure message for a proj
171  */
172 static void show_proj_failure(ir_node *n)
173 {
174         ir_node *op  = get_Proj_pred(n);
175         int proj     = get_Proj_proj(n);
176
177         show_entity_failure(n);
178         fprintf(stderr, "  node %ld %s%s %d(%s%s) failed\n" ,
179                 get_irn_node_nr(n),
180                 get_irn_opname(n), get_irn_modename(n), proj,
181                 get_irn_opname(op), get_irn_modename(op));
182 }
183
184 /**
185  * Prints a failure message for a proj from Start
186  */
187 static void show_proj_mode_failure(ir_node *n, ir_type *ty)
188 {
189         long proj  = get_Proj_proj(n);
190         ir_mode *m = get_type_mode(ty);
191         char type_name[256];
192         ir_print_type(type_name, sizeof(type_name), ty);
193
194         show_entity_failure(n);
195         fprintf(stderr, "  Proj %ld mode %s proj %ld (type %s mode %s) failed\n" ,
196                 get_irn_node_nr(n),
197                 get_irn_modename(n),
198                 proj,
199                 type_name,
200                 get_mode_name_ex(m));
201 }
202
203 /**
204  * Prints a failure message for a proj
205  */
206 static void show_proj_failure_ent(ir_node *n, ir_entity *ent)
207 {
208         ir_node *op  = get_Proj_pred(n);
209         int proj     = get_Proj_proj(n);
210         ir_mode *m   = get_type_mode(get_entity_type(ent));
211         char type_name[256];
212         ir_print_type(type_name, sizeof(type_name), get_entity_type(ent));
213
214         show_entity_failure(n);
215         fprintf(stderr, "  node %ld %s%s %d(%s%s) entity %s(type %s mode %s)failed\n" ,
216                 get_irn_node_nr(n),
217                 get_irn_opname(n), get_irn_modename(n), proj,
218                 get_irn_opname(op), get_irn_modename(op),
219                 get_entity_name(ent), type_name,
220                 get_mode_name_ex(m));
221 }
222
223 /**
224  * Show a node and a graph
225  */
226 static void show_node_on_graph(ir_graph *irg, ir_node *n)
227 {
228         ir_fprintf(stderr, "\nFIRM: irn_verify_irg() of %+F, node %+F\n", irg, n);
229 }
230
231 /**
232  * Show call parameters
233  */
234 static void show_call_param(ir_node *n, ir_type *mt)
235 {
236         int i;
237         char type_name[256];
238         ir_print_type(type_name, sizeof(type_name), mt);
239
240         show_entity_failure(n);
241         fprintf(stderr, "  Call type-check failed: %s(", type_name);
242         for (i = 0; i < get_method_n_params(mt); ++i) {
243                 fprintf(stderr, "%s ", get_mode_name_ex(get_type_mode(get_method_param_type(mt, i))));
244         }
245         fprintf(stderr, ") != CALL(");
246
247         for (i = 0; i < get_Call_n_params(n); ++i) {
248                 fprintf(stderr, "%s ", get_mode_name_ex(get_irn_mode(get_Call_param(n, i))));
249         }
250         fprintf(stderr, ")\n");
251 }
252
253 /**
254  * Show return modes
255  */
256 static void show_return_modes(ir_graph *irg, ir_node *n, ir_type *mt, int i)
257 {
258         ir_entity *ent = get_irg_entity(irg);
259
260         show_entity_failure(n);
261         fprintf(stderr, "  Return node %ld in entity \"%s\" mode %s different from type mode %s\n",
262                 get_irn_node_nr(n), get_entity_name(ent),
263                 get_mode_name_ex(get_irn_mode(get_Return_res(n, i))),
264                 get_mode_name_ex(get_type_mode(get_method_res_type(mt, i)))
265         );
266 }
267
268 /**
269  * Show return number of results
270  */
271 static void show_return_nres(ir_graph *irg, ir_node *n, ir_type *mt)
272 {
273         ir_entity *ent = get_irg_entity(irg);
274
275         show_entity_failure(n);
276         fprintf(stderr, "  Return node %ld in entity \"%s\" has %d results different from type %d\n",
277                 get_irn_node_nr(n), get_entity_name(ent),
278                 get_Return_n_ress(n), get_method_n_ress(mt));
279 }
280
281 /**
282  * Show Phi input
283  */
284 static void show_phi_failure(ir_node *phi, ir_node *pred, int pos)
285 {
286         (void) pos;
287         show_entity_failure(phi);
288         fprintf(stderr, "  Phi node %ld has mode %s different from predeccessor node %ld mode %s\n",
289                 get_irn_node_nr(phi), get_mode_name_ex(get_irn_mode(phi)),
290                 get_irn_node_nr(pred), get_mode_name_ex(get_irn_mode(pred)));
291 }
292
293 /**
294  * Show Phi inputs
295  */
296 static void show_phi_inputs(ir_node *phi, ir_node *block)
297 {
298         show_entity_failure(phi);
299         fprintf(stderr, "  Phi node %ld has %d inputs, its Block %ld has %d\n",
300                 get_irn_node_nr(phi),   get_irn_arity(phi),
301                 get_irn_node_nr(block), get_irn_arity(block));
302 }
303
304 #endif /* #ifndef NDEBUG */
305
306 /**
307  * If the address is Sel or SymConst, return the entity.
308  *
309  * @param ptr  the node representing the address
310  */
311 static ir_entity *get_ptr_entity(ir_node *ptr)
312 {
313         if (is_Sel(ptr)) {
314                 return get_Sel_entity(ptr);
315         } else if (is_SymConst_addr_ent(ptr)) {
316                 return get_SymConst_entity(ptr);
317         }
318         return NULL;
319 }
320
321 /**
322  * verify a Proj(Start) node
323  */
324 static int verify_node_Proj_Start(ir_node *n, ir_node *p)
325 {
326         ir_mode *mode = get_irn_mode(p);
327         long proj     = get_Proj_proj(p);
328         (void) n;
329
330         ASSERT_AND_RET_DBG(
331                 (
332                         (proj == pn_Start_X_initial_exec && mode == mode_X) ||
333                         (proj == pn_Start_M              && mode == mode_M) ||
334                         (proj == pn_Start_P_frame_base   && mode_is_reference(mode)) ||
335                         (proj == pn_Start_P_tls          && mode_is_reference(mode)) ||
336                         (proj == pn_Start_T_args         && mode == mode_T)
337                 ),
338                 "wrong Proj from Start", 0,
339                 show_proj_failure(p);
340         );
341         return 1;
342 }
343
344 /**
345  * verify a Proj(Cond) node
346  */
347 static int verify_node_Proj_Cond(ir_node *pred, ir_node *p)
348 {
349         ir_mode *mode = get_irn_mode(p);
350         long proj     = get_Proj_proj(p);
351
352         ASSERT_AND_RET_DBG(
353                 (
354                         (proj >= 0 && mode == mode_X && get_irn_mode(get_Cond_selector(pred)) == mode_b) ||   /* compare */
355                         (mode == mode_X && mode_is_int(get_irn_mode(get_Cond_selector(pred)))) ||             /* switch */
356                         is_Bad(get_Cond_selector(pred))                                                       /* rare */
357                 ),
358                 "wrong Proj from Cond", 0,
359                 show_proj_failure(p);
360         );
361         return 1;
362 }
363
364 /**
365  * verify a Proj(Raise) node
366  */
367 static int verify_node_Proj_Raise(ir_node *n, ir_node *p)
368 {
369         ir_mode *mode = get_irn_mode(p);
370         long proj     = get_Proj_proj(p);
371         (void) n;
372
373         ASSERT_AND_RET_DBG(
374                 ((proj == pn_Raise_X && mode == mode_X) || (proj == pn_Raise_M && mode == mode_M)),
375                 "wrong Proj from Raise", 0,
376                 show_proj_failure(p);
377         );
378         return 1;
379 }
380
381 /**
382  * verify a Proj(InstOf) node
383  */
384 static int verify_node_Proj_InstOf(ir_node *n, ir_node *p)
385 {
386         ir_mode *mode = get_irn_mode(p);
387         long proj     = get_Proj_proj(p);
388         (void) n;
389
390         ASSERT_AND_RET_DBG(
391                 (
392                         (proj == pn_InstOf_M         && mode == mode_M) ||
393                         (proj == pn_InstOf_X_regular && mode == mode_X) ||
394                         (proj == pn_InstOf_X_except  && mode == mode_X) ||
395                         (proj == pn_InstOf_res       && mode_is_reference(mode))
396                 ),
397                 "wrong Proj from InstOf", 0,
398                 show_proj_failure(p);
399         );
400         return 1;
401 }
402
403 /**
404  * verify a Proj(Call) node
405  */
406 static int verify_node_Proj_Call(ir_node *n, ir_node *p)
407 {
408         ir_mode *mode = get_irn_mode(p);
409         long proj     = get_Proj_proj(p);
410
411         ASSERT_AND_RET_DBG(
412                 (
413                         (proj == pn_Call_M                && mode == mode_M) ||
414                         (proj == pn_Call_X_regular        && mode == mode_X) ||
415                         (proj == pn_Call_X_except         && mode == mode_X) ||
416                         (proj == pn_Call_T_result         && mode == mode_T) ||
417                         (proj == pn_Call_P_value_res_base && mode_is_reference(mode))
418                 ),
419                 "wrong Proj from Call", 0,
420                 show_proj_failure(p);
421         );
422         /* if we have exception flow, we must have a real Memory input */
423         if (proj == pn_Call_X_regular)
424                 ASSERT_AND_RET(
425                         !is_NoMem(get_Call_mem(n)),
426                         "Regular Proj from FunctionCall", 0);
427         else if (proj == pn_Call_X_except)
428                 ASSERT_AND_RET(
429                         !is_NoMem(get_Call_mem(n)),
430                         "Exception Proj from FunctionCall", 0);
431         return 1;
432 }
433
434 /**
435  * verify a Proj(Quot) node
436  */
437 static int verify_node_Proj_Quot(ir_node *n, ir_node *p)
438 {
439         ir_mode *mode = get_irn_mode(p);
440         long proj     = get_Proj_proj(p);
441
442         ASSERT_AND_RET_DBG(
443                 (
444                         (proj == pn_Quot_M         && mode == mode_M) ||
445                         (proj == pn_Quot_X_regular && mode == mode_X) ||
446                         (proj == pn_Quot_X_except  && mode == mode_X) ||
447                         (proj == pn_Quot_res       && mode_is_float(mode) && mode == get_Quot_resmode(n))
448                 ),
449                 "wrong Proj from Quot", 0,
450                 show_proj_failure(p);
451         );
452         if (proj == pn_Quot_X_regular)
453                 ASSERT_AND_RET(
454                         get_irn_pinned(n) == op_pin_state_pinned,
455                         "Regular Proj from unpinned Quot", 0);
456         else if (proj == pn_Quot_X_except)
457                 ASSERT_AND_RET(
458                         get_irn_pinned(n) == op_pin_state_pinned,
459                         "Exception Proj from unpinned Quot", 0);
460         else if (proj == pn_Quot_M)
461                 ASSERT_AND_RET(
462                         get_irn_pinned(n) == op_pin_state_pinned,
463                         "Memory Proj from unpinned Quot", 0);
464         return 1;
465 }
466
467 /**
468  * verify a Proj(DivMod) node
469  */
470 static int verify_node_Proj_DivMod(ir_node *n, ir_node *p)
471 {
472         ir_mode *mode = get_irn_mode(p);
473         long proj     = get_Proj_proj(p);
474
475         ASSERT_AND_RET_DBG(
476                 (
477                         (proj == pn_DivMod_M         && mode == mode_M) ||
478                         (proj == pn_DivMod_X_regular && mode == mode_X) ||
479                         (proj == pn_DivMod_X_except  && mode == mode_X) ||
480                         (proj == pn_DivMod_res_div   && mode_is_int(mode) && mode == get_DivMod_resmode(n)) ||
481                         (proj == pn_DivMod_res_mod   && mode_is_int(mode) && mode == get_DivMod_resmode(n))
482                 ),
483                 "wrong Proj from DivMod", 0,
484                 show_proj_failure(p);
485         );
486         if (proj == pn_DivMod_X_regular)
487                 ASSERT_AND_RET(
488                         get_irn_pinned(n) == op_pin_state_pinned,
489                         "Regular Proj from unpinned DivMod", 0);
490         else if (proj == pn_DivMod_X_except)
491                 ASSERT_AND_RET(
492                         get_irn_pinned(n) == op_pin_state_pinned,
493                         "Exception Proj from unpinned DivMod", 0);
494         else if (proj == pn_DivMod_M)
495                 ASSERT_AND_RET(
496                         get_irn_pinned(n) == op_pin_state_pinned,
497                         "Memory Proj from unpinned DivMod", 0);
498         return 1;
499 }
500
501 /**
502  * verify a Proj(Div) node
503  */
504 static int verify_node_Proj_Div(ir_node *n, ir_node *p)
505 {
506         ir_mode *mode = get_irn_mode(p);
507         long proj     = get_Proj_proj(p);
508
509         ASSERT_AND_RET_DBG(
510                 (
511                         (proj == pn_Div_M         && mode == mode_M) ||
512                         (proj == pn_Div_X_regular && mode == mode_X) ||
513                         (proj == pn_Div_X_except  && mode == mode_X) ||
514                         (proj == pn_Div_res       && mode_is_int(mode) && mode == get_Div_resmode(n))
515                 ),
516                 "wrong Proj from Div", 0,
517                 show_proj_failure(p);
518         );
519         if (proj == pn_Div_X_regular)
520                 ASSERT_AND_RET(
521                         get_irn_pinned(n) == op_pin_state_pinned,
522                         "Regular Proj from unpinned Div", 0);
523         else if (proj == pn_Div_X_except)
524                 ASSERT_AND_RET(
525                         get_irn_pinned(n) == op_pin_state_pinned,
526                         "Exception Proj from unpinned Div", 0);
527         else if (proj == pn_Div_M)
528                 ASSERT_AND_RET(
529                         get_irn_pinned(n) == op_pin_state_pinned,
530                         "Memory Proj from unpinned Div", 0);
531         return 1;
532 }
533
534 /**
535  * verify a Proj(Mod) node
536  */
537 static int verify_node_Proj_Mod(ir_node *n, ir_node *p)
538 {
539         ir_mode *mode = get_irn_mode(p);
540         long proj     = get_Proj_proj(p);
541
542         ASSERT_AND_RET_DBG(
543                 (
544                         (proj == pn_Mod_M         && mode == mode_M) ||
545                         (proj == pn_Mod_X_regular && mode == mode_X) ||
546                         (proj == pn_Mod_X_except  && mode == mode_X) ||
547                         (proj == pn_Mod_res       && mode_is_int(mode) && mode == get_Mod_resmode(n))
548                 ),
549                 "wrong Proj from Mod", 0,
550                 show_proj_failure(p);
551         );
552         if (proj == pn_Mod_X_regular)
553                 ASSERT_AND_RET(
554                         get_irn_pinned(n) == op_pin_state_pinned,
555                         "Regular Proj from unpinned Mod", 0);
556         else if (proj == pn_Mod_X_except)
557                 ASSERT_AND_RET(
558                         get_irn_pinned(n) == op_pin_state_pinned,
559                         "Exception Proj from unpinned Mod", 0);
560         else if (proj == pn_Mod_M)
561                 ASSERT_AND_RET(
562                         get_irn_pinned(n) == op_pin_state_pinned,
563                         "Memory Proj from unpinned Div", 0);
564         return 1;
565 }
566
567 /**
568  * verify a Proj(Cmp) node
569  */
570 static int verify_node_Proj_Cmp(ir_node *n, ir_node *p)
571 {
572         ir_mode *mode = get_irn_mode(p);
573         long proj     = get_Proj_proj(p);
574         (void) n;
575
576         ASSERT_AND_RET_DBG(
577                 (proj >= 0 && proj <= 15 && mode == mode_b),
578                 "wrong Proj from Cmp", 0,
579                 show_proj_failure(p);
580         );
581         ASSERT_AND_RET_DBG(
582                 (mode_is_float(get_irn_mode(get_Cmp_left(n))) || !(proj & pn_Cmp_Uo)),
583                 "unordered Proj for non-float Cmp (Did you use Ne instead of Lg?)", 0,
584                 show_proj_failure(p);
585         );
586         return 1;
587 }
588
589 /**
590  * verify a Proj(Load) node
591  */
592 static int verify_node_Proj_Load(ir_node *n, ir_node *p)
593 {
594         ir_mode *mode = get_irn_mode(p);
595         long proj     = get_Proj_proj(p);
596
597         if (proj == pn_Load_res) {
598                 ir_node   *ptr = get_Load_ptr(n);
599                 ir_entity *ent = get_ptr_entity(ptr);
600                 ir_graph  *irg = get_irn_irg(n);
601
602                 if (verify_entities && ent && get_irg_phase_state(irg) == phase_high) {
603                         /* do NOT check this for lowered phases, see comment on Store */
604                         ASSERT_AND_RET_DBG(
605                                 (mode == get_type_mode(get_entity_type(ent))),
606                                 "wrong data Proj from Load, entity type_mode failed", 0,
607                                 show_proj_failure_ent(p, ent);
608                         );
609                 }
610                 else {
611                         ASSERT_AND_RET_DBG(
612                                 mode_is_data(mode) && mode == get_Load_mode(n),
613                                 "wrong data Proj from Load", 0,
614                                 show_proj_failure(p);
615                         );
616                 }
617         }
618         else {
619                 ASSERT_AND_RET_DBG(
620                         (
621                                 (proj == pn_Load_M         && mode == mode_M) ||
622                                 (proj == pn_Load_X_regular && mode == mode_X) ||
623                                 (proj == pn_Load_X_except  && mode == mode_X)
624                         ),
625                         "wrong Proj from Load", 0,
626                         show_proj_failure(p);
627                 );
628         }
629         if (proj == pn_Load_X_regular) {
630                 ASSERT_AND_RET(
631                         get_irn_pinned(n) == op_pin_state_pinned,
632                         "Regular Proj from unpinned Load", 0);
633         } else if (proj == pn_Load_X_except) {
634                 ASSERT_AND_RET(
635                         get_irn_pinned(n) == op_pin_state_pinned,
636                         "Exception Proj from unpinned Load", 0);
637         }
638         return 1;
639 }
640
641 /**
642  * verify a Proj(Store) node
643  */
644 static int verify_node_Proj_Store(ir_node *n, ir_node *p)
645 {
646         ir_mode *mode = get_irn_mode(p);
647         long proj     = get_Proj_proj(p);
648
649         ASSERT_AND_RET_DBG(
650                 (
651                         (proj == pn_Store_M         && mode == mode_M) ||
652                         (proj == pn_Store_X_regular && mode == mode_X) ||
653                         (proj == pn_Store_X_except  && mode == mode_X)
654                 ),
655                 "wrong Proj from Store", 0,
656                 show_proj_failure(p);
657         );
658         if (proj == pn_Store_X_regular) {
659                 ASSERT_AND_RET(
660                         get_irn_pinned(n) == op_pin_state_pinned,
661                         "Regular Proj from unpinned Store", 0);
662         } else if (proj == pn_Store_X_except) {
663                 ASSERT_AND_RET(
664                         get_irn_pinned(n) == op_pin_state_pinned,
665                         "Exception Proj from unpinned Store", 0);
666         }
667         return 1;
668 }
669
670 /**
671  * verify a Proj(Alloc) node
672  */
673 static int verify_node_Proj_Alloc(ir_node *n, ir_node *p)
674 {
675         ir_mode *mode = get_irn_mode(p);
676         long proj     = get_Proj_proj(p);
677         (void) n;
678
679         ASSERT_AND_RET_DBG(
680                 (
681                         (proj == pn_Alloc_M         && mode == mode_M) ||
682                         (proj == pn_Alloc_X_regular && mode == mode_X) ||
683                         (proj == pn_Alloc_X_except  && mode == mode_X) ||
684                         (proj == pn_Alloc_res       && mode_is_reference(mode))
685                 ),
686                 "wrong Proj from Alloc", 0,
687                 show_proj_failure(p);
688         );
689         return 1;
690 }
691
692 /**
693  * verify a Proj(Proj) node
694  */
695 static int verify_node_Proj_Proj(ir_node *pred, ir_node *p)
696 {
697         ir_mode *mode = get_irn_mode(p);
698         long proj     = get_Proj_proj(p);
699         long nr       = get_Proj_proj(pred);
700         ir_type *mt; /* A method type */
701
702         pred = skip_Id(get_Proj_pred(pred));
703         ASSERT_AND_RET((get_irn_mode(pred) == mode_T), "Proj from something not a tuple", 0);
704
705         switch (get_irn_opcode(pred)) {
706         case iro_Start:
707                 mt = get_entity_type(get_irg_entity(get_irn_irg(pred)));
708
709                 if (nr == pn_Start_T_args) {
710                         ASSERT_AND_RET(
711                                 (proj >= 0 && mode_is_datab(mode)),
712                                 "wrong Proj from Proj from Start", 0);
713                         ASSERT_AND_RET(
714                                 (proj < get_method_n_params(mt)),
715                                 "More Projs for args than args in type", 0
716                                 );
717                         if ((mode_is_reference(mode)) && is_compound_type(get_method_param_type(mt, proj)))
718                                 /* value argument */ break;
719
720                         if (get_irg_phase_state(get_irn_irg(pred)) != phase_backend) {
721                                 ASSERT_AND_RET_DBG(
722                                                 (mode == get_type_mode(get_method_param_type(mt, proj))),
723                                                 "Mode of Proj from Start doesn't match mode of param type.", 0,
724                                                 show_proj_mode_failure(p, get_method_param_type(mt, proj));
725                                                 );
726                         }
727                 }
728                 break;
729
730         case iro_Call:
731                 {
732                         ASSERT_AND_RET(
733                                 (proj >= 0 && mode_is_datab(mode)),
734                                 "wrong Proj from Proj from Call", 0);
735                         mt = get_Call_type(pred);
736                         ASSERT_AND_RET(mt == get_unknown_type() || is_Method_type(mt),
737                                         "wrong call type on call", 0);
738                         ASSERT_AND_RET(
739                                 (proj < get_method_n_ress(mt)),
740                                 "More Projs for results than results in type.", 0);
741                         if ((mode_is_reference(mode)) && is_compound_type(get_method_res_type(mt, proj)))
742                                 /* value result */ break;
743
744                                 ASSERT_AND_RET(
745                                 (mode == get_type_mode(get_method_res_type(mt, proj))),
746                                 "Mode of Proj from Call doesn't match mode of result type.", 0);
747                 }
748                 break;
749
750         case iro_Tuple:
751                 /* We don't test */
752                 break;
753
754         case iro_Bad:
755                 /* hmm, optimization did not remove it */
756                 break;
757
758         default:
759                 /* ASSERT_AND_RET(0, "Unknown opcode", 0); */
760                 break;
761         }
762         return 1;
763 }
764
765 /**
766  * verify a Proj(Tuple) node
767  */
768 static int verify_node_Proj_Tuple(ir_node *n, ir_node *p)
769 {
770         (void) n;
771         (void) p;
772         /* We don't test */
773         return 1;
774 }
775
776 /**
777  * verify a Proj(CopyB) node
778  */
779 static int verify_node_Proj_CopyB(ir_node *n, ir_node *p)
780 {
781         ir_mode *mode = get_irn_mode(p);
782         long proj     = get_Proj_proj(p);
783
784         ASSERT_AND_RET_DBG(
785                 (
786                         (proj == pn_CopyB_M         && mode == mode_M) ||
787                         (proj == pn_CopyB_X_regular && mode == mode_X) ||
788                         (proj == pn_CopyB_X_except  && mode == mode_X)
789                 ),
790                 "wrong Proj from CopyB", 0,
791                 show_proj_failure(p);
792         );
793         if (proj == pn_CopyB_X_regular)
794                 ASSERT_AND_RET(
795                         get_irn_pinned(n) == op_pin_state_pinned,
796                         "Regular Proj from unpinned CopyB", 0);
797         else if (proj == pn_CopyB_X_except)
798                 ASSERT_AND_RET(
799                         get_irn_pinned(n) == op_pin_state_pinned,
800                         "Exception Proj from unpinned CopyB", 0);
801         return 1;
802 }
803
804 /**
805  * verify a Proj(Bound) node
806  */
807 static int verify_node_Proj_Bound(ir_node *n, ir_node *p)
808 {
809         ir_mode *mode = get_irn_mode(p);
810         long proj     = get_Proj_proj(p);
811
812         /* ignore Bound checks of Bad */
813         if (is_Bad(get_Bound_index(n)))
814                 return 1;
815         ASSERT_AND_RET_DBG(
816                 (
817                         (proj == pn_Bound_M         && mode == mode_M) ||
818                         (proj == pn_Bound_X_regular && mode == mode_X) ||
819                         (proj == pn_Bound_X_except  && mode == mode_X) ||
820                         (proj == pn_Bound_res       && mode == get_irn_mode(get_Bound_index(n)))
821                 ),
822                 "wrong Proj from Bound", 0,
823                 show_proj_failure(p);
824         );
825         return 1;
826 }
827
828 /**
829  * verify a Proj node
830  */
831 static int verify_node_Proj(ir_node *p, ir_graph *irg)
832 {
833         ir_node *pred;
834         ir_op *op;
835
836         pred = skip_Id(get_Proj_pred(p));
837         ASSERT_AND_RET(get_irn_mode(pred) == mode_T, "mode of a 'projed' node is not Tuple", 0);
838         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);
839
840         op = get_irn_op(pred);
841
842         if (op->ops.verify_proj_node)
843                 return op->ops.verify_proj_node(pred, p);
844
845         /* all went ok */
846         return 1;
847 }
848
849 /**
850  * verify a Block node
851  */
852 static int verify_node_Block(ir_node *n, ir_graph *irg)
853 {
854         int i;
855
856         for (i = get_Block_n_cfgpreds(n) - 1; i >= 0; --i) {
857                 ir_node *pred = get_Block_cfgpred(n, i);
858                 ASSERT_AND_RET(
859                         is_Bad(pred) || (get_irn_mode(pred) == mode_X),
860                         "Block node must have a mode_X predecessor", 0);
861         }
862
863         if (n == get_irg_start_block(irg)) {
864                 ASSERT_AND_RET(get_Block_n_cfgpreds(n) == 0, "Start Block node", 0);
865         }
866
867         if (n == get_irg_end_block(irg) && get_irg_phase_state(irg) != phase_backend)
868                 /* End block may only have Return, Raise or fragile ops as preds. */
869                 for (i = get_Block_n_cfgpreds(n) - 1; i >= 0; --i) {
870                         ir_node *pred =  skip_Proj(get_Block_cfgpred(n, i));
871                         if (is_Proj(pred) || is_Tuple(pred))
872                                 break;   /*  We can not test properly.  How many tuples are there? */
873                         ASSERT_AND_RET(
874                                 (
875                                         is_Return(pred) ||
876                                         is_Bad(pred)    ||
877                                         is_Raise(pred)  ||
878                                         is_fragile_op(pred)
879                                 ),
880                                 "End Block node", 0);
881                 }
882                 /*  irg attr must == graph we are in. */
883                 ASSERT_AND_RET(((get_irn_irg(n) && get_irn_irg(n) == irg)), "Block node has wrong irg attribute", 0);
884                 return 1;
885 }
886
887 /**
888  * verify a Start node
889  */
890 static int verify_node_Start(ir_node *n, ir_graph *irg)
891 {
892         ir_mode *mymode = get_irn_mode(n);
893         (void) irg;
894
895         ASSERT_AND_RET(
896                 /* Start: BB --> X x M x ref x data1 x ... x datan x ref */
897                 mymode == mode_T, "Start node", 0
898                 );
899         return 1;
900 }
901
902 /**
903  * verify a Jmp node
904  */
905 static int verify_node_Jmp(ir_node *n, ir_graph *irg)
906 {
907         ir_mode *mymode = get_irn_mode(n);
908         (void) irg;
909
910         ASSERT_AND_RET(
911                 /* Jmp: BB --> X */
912                 mymode == mode_X, "Jmp node", 0
913         );
914         return 1;
915 }
916
917 /**
918  * verify an IJmp node
919  */
920 static int verify_node_IJmp(ir_node *n, ir_graph *irg)
921 {
922         ir_mode *mymode  = get_irn_mode(n);
923         ir_mode *op1mode = get_irn_mode(get_IJmp_target(n));
924         (void) irg;
925
926         ASSERT_AND_RET(
927                 /* IJmp: BB x ref --> X */
928                 mymode == mode_X && mode_is_reference(op1mode), "IJmp node", 0
929         );
930         return 1;
931 }
932
933 /**
934  * verify a Cond node
935  */
936 static int verify_node_Cond(ir_node *n, ir_graph *irg)
937 {
938         ir_mode *mymode  = get_irn_mode(n);
939         ir_mode *op1mode = get_irn_mode(get_Cond_selector(n));
940         (void) irg;
941
942         ASSERT_AND_RET(
943                 /* Cond: BB x b --> X x X */
944                 (op1mode == mode_b ||
945                 /* Cond: BB x int --> X^n */
946                 mode_is_int(op1mode) ),  "Cond node", 0
947                 );
948         ASSERT_AND_RET(mymode == mode_T, "Cond mode is not a tuple", 0);
949
950         return 1;
951 }
952
953 /**
954  * verify a Return node
955  */
956 static int verify_node_Return(ir_node *n, ir_graph *irg)
957 {
958         int i;
959         ir_mode *mymode   = get_irn_mode(n);
960         ir_mode *mem_mode = get_irn_mode(get_Return_mem(n));
961         ir_type *mt;
962
963         /* Return: BB x M x data1 x ... x datan --> X */
964
965         ASSERT_AND_RET( mem_mode == mode_M, "Return node", 0 );  /* operand M */
966
967         for (i = get_Return_n_ress(n) - 1; i >= 0; --i) {
968                 ASSERT_AND_RET( mode_is_datab(get_irn_mode(get_Return_res(n, i))), "Return node", 0 );  /* operand datai */
969         }
970         ASSERT_AND_RET( mymode == mode_X, "Result X", 0 );   /* result X */
971         /* Compare returned results with result types of method type */
972         mt = get_entity_type(get_irg_entity(irg));
973         ASSERT_AND_RET_DBG( get_Return_n_ress(n) == get_method_n_ress(mt),
974                 "Number of results for Return doesn't match number of results in type.", 0,
975                 show_return_nres(irg, n, mt););
976         for (i = get_Return_n_ress(n) - 1; i >= 0; --i) {
977                 ir_type *res_type = get_method_res_type(mt, i);
978
979                 if (get_irg_phase_state(irg) != phase_backend) {
980                         if (is_atomic_type(res_type)) {
981                                 ASSERT_AND_RET_DBG(
982                                         get_irn_mode(get_Return_res(n, i)) == get_type_mode(res_type),
983                                         "Mode of result for Return doesn't match mode of result type.", 0,
984                                         show_return_modes(irg, n, mt, i);
985                                 );
986                         } else {
987                                 ASSERT_AND_RET_DBG(
988                                         mode_is_reference(get_irn_mode(get_Return_res(n, i))),
989                                         "Mode of result for Return doesn't match mode of result type.", 0,
990                                         show_return_modes(irg, n, mt, i);
991                                 );
992                         }
993                 }
994         }
995         return 1;
996 }
997
998 /**
999  * verify a Raise node
1000  */
1001 static int verify_node_Raise(ir_node *n, ir_graph *irg)
1002 {
1003         ir_mode *mymode  = get_irn_mode(n);
1004         ir_mode *op1mode = get_irn_mode(get_Raise_mem(n));
1005         ir_mode *op2mode = get_irn_mode(get_Raise_exo_ptr(n));
1006         (void) irg;
1007
1008         ASSERT_AND_RET(
1009                 /* Sel: BB x M x ref --> X x M */
1010                 op1mode == mode_M && mode_is_reference(op2mode) &&
1011                 mymode == mode_T, "Raise node", 0
1012         );
1013         return 1;
1014 }
1015
1016 /**
1017  * verify a Const node
1018  */
1019 static int verify_node_Const(ir_node *n, ir_graph *irg)
1020 {
1021         ir_mode *mymode = get_irn_mode(n);
1022         (void) irg;
1023
1024         ASSERT_AND_RET(
1025                 /* Const: BB --> data */
1026                 (mode_is_data(mymode) ||
1027                 mymode == mode_b)      /* we want boolean constants for static evaluation */
1028                 ,"Const node", 0       /* of Cmp. */
1029         );
1030         ASSERT_AND_RET(
1031                 /* the modes of the constant and teh tarval must match */
1032                 mymode == get_tarval_mode(get_Const_tarval(n)),
1033                 "Const node, tarval and node mode mismatch", 0
1034         );
1035         return 1;
1036 }
1037
1038 /**
1039  * verify a SymConst node
1040  */
1041 static int verify_node_SymConst(ir_node *n, ir_graph *irg)
1042 {
1043         ir_mode *mymode = get_irn_mode(n);
1044         (void) irg;
1045
1046         ASSERT_AND_RET(
1047                 /* SymConst: BB --> int*/
1048                 (mode_is_int(mymode) ||
1049                 /* SymConst: BB --> ref */
1050                 mode_is_reference(mymode))
1051                 ,"SymConst node", 0);
1052         return 1;
1053 }
1054
1055 /**
1056  * verify a Sel node
1057  */
1058 static int verify_node_Sel(ir_node *n, ir_graph *irg)
1059 {
1060         int i;
1061         ir_mode *mymode  = get_irn_mode(n);
1062         ir_mode *op1mode = get_irn_mode(get_Sel_mem(n));
1063         ir_mode *op2mode = get_irn_mode(get_Sel_ptr(n));
1064         ir_entity *ent;
1065         (void) irg;
1066
1067         ASSERT_AND_RET_DBG(
1068                 /* Sel: BB x M x ref x int^n --> ref */
1069                 (op1mode == mode_M && op2mode == mymode && mode_is_reference(mymode)),
1070                 "Sel node", 0, show_node_failure(n)
1071         );
1072
1073         for (i = get_Sel_n_indexs(n) - 1; i >= 0; --i) {
1074                 ASSERT_AND_RET_DBG(mode_is_int(get_irn_mode(get_Sel_index(n, i))), "Sel node", 0, show_node_failure(n));
1075         }
1076         ent = get_Sel_entity(n);
1077         ASSERT_AND_RET_DBG(ent, "Sel node with empty entity", 0, show_node_failure(n));
1078         return 1;
1079 }
1080
1081 /**
1082  * verify an InstOf node
1083  */
1084 static int verify_node_InstOf(ir_node *n, ir_graph *irg)
1085 {
1086         ir_mode *mymode  = get_irn_mode(n);
1087         ir_mode *op1mode = get_irn_mode(get_InstOf_obj(n));
1088         (void) irg;
1089
1090         ASSERT_AND_RET(mode_T == mymode, "mode of Instof is not a tuple", 0);
1091         ASSERT_AND_RET(mode_is_data(op1mode), "Instof not on data", 0);
1092         return 1;
1093 }
1094
1095 /**
1096  * Check if the pinned state is right.
1097  */
1098 static int verify_right_pinned(ir_node *n)
1099 {
1100         ir_node *mem;
1101
1102         if (get_irn_pinned(n) == op_pin_state_pinned)
1103                 return 1;
1104         mem = get_Call_mem(n);
1105
1106         /* if it's not pinned, its memory predecessor must be NoMem or Pin */
1107         if (is_NoMem(mem) || is_Pin(mem))
1108                 return 1;
1109         return 0;
1110 }
1111
1112 /**
1113  * verify a Call node
1114  */
1115 static int verify_node_Call(ir_node *n, ir_graph *irg)
1116 {
1117         ir_mode *mymode  = get_irn_mode(n);
1118         ir_mode *op1mode = get_irn_mode(get_Call_mem(n));
1119         ir_mode *op2mode = get_irn_mode(get_Call_ptr(n));
1120         ir_type *mt;
1121         int i;
1122         (void) irg;
1123
1124         /* Call: BB x M x ref x data1 x ... x datan
1125         --> M x datan+1 x ... x data n+m */
1126         ASSERT_AND_RET( op1mode == mode_M && mode_is_reference(op2mode), "Call node", 0 );  /* operand M x ref */
1127
1128         /* NoMem nodes are only allowed as memory input if the Call is NOT pinned */
1129         ASSERT_AND_RET(verify_right_pinned(n),"Call node with wrong memory input", 0 );
1130
1131         mt = get_Call_type(n);
1132         if (get_unknown_type() == mt) {
1133                 return 1;
1134         }
1135
1136         for (i = get_Call_n_params(n) - 1; i >= 0; --i) {
1137                 ASSERT_AND_RET( mode_is_datab(get_irn_mode(get_Call_param(n, i))), "Call node", 0 );  /* operand datai */
1138         }
1139
1140         ASSERT_AND_RET( mymode == mode_T, "Call result not a tuple", 0 );   /* result T */
1141         /* Compare arguments of node with those of type */
1142
1143         if (get_method_variadicity(mt) == variadicity_variadic) {
1144                 ASSERT_AND_RET_DBG(
1145                         get_Call_n_params(n) >= get_method_n_params(mt),
1146                         "Number of args for Call doesn't match number of args in variadic type.",
1147                         0,
1148                         ir_fprintf(stderr, "Call %+F has %d params, type %d\n",
1149                         n, get_Call_n_params(n), get_method_n_params(mt));
1150                 );
1151         } else {
1152                 ASSERT_AND_RET_DBG(
1153                         get_Call_n_params(n) == get_method_n_params(mt),
1154                         "Number of args for Call doesn't match number of args in non variadic type.",
1155                         0,
1156                         ir_fprintf(stderr, "Call %+F has %d params, type %d\n",
1157                         n, get_Call_n_params(n), get_method_n_params(mt));
1158                 );
1159         }
1160
1161         for (i = 0; i < get_method_n_params(mt); i++) {
1162                 ir_type *t = get_method_param_type(mt, i);
1163
1164                 if (get_irg_phase_state(irg) != phase_backend) {
1165                         if (is_atomic_type(t)) {
1166                                 ASSERT_AND_RET_DBG(
1167                                         get_irn_mode(get_Call_param(n, i)) == get_type_mode(t),
1168                                         "Mode of arg for Call doesn't match mode of arg type.", 0,
1169                                         show_call_param(n, mt);
1170                                 );
1171                         } else {
1172                                 /* call with a compound type, mode must be reference */
1173                                 ASSERT_AND_RET_DBG(
1174                                         mode_is_reference(get_irn_mode(get_Call_param(n, i))),
1175                                         "Mode of arg for Call doesn't match mode of arg type.", 0,
1176                                         show_call_param(n, mt);
1177                                 );
1178                         }
1179                 }
1180         }
1181
1182 #if 0
1183         if (Call_has_callees(n)) {
1184                 for (i = 0; i < get_Call_n_callees(n); i++) {
1185                         ASSERT_AND_RET(is_entity(get_Call_callee(n, i)), "callee array must contain entities.", 0);
1186                 }
1187         }
1188 #endif
1189         return 1;
1190 }
1191
1192 /**
1193  * verify an Add node
1194  */
1195 static int verify_node_Add(ir_node *n, ir_graph *irg)
1196 {
1197         ir_mode *mymode  = get_irn_mode(n);
1198         ir_mode *op1mode = get_irn_mode(get_Add_left(n));
1199         ir_mode *op2mode = get_irn_mode(get_Add_right(n));
1200         (void) irg;
1201
1202         ASSERT_AND_RET_DBG(
1203                 (
1204                         /* common Add: BB x numP x numP --> numP */
1205                         (op1mode == mymode && op2mode == op1mode && mode_is_data(mymode)) ||
1206                         /* Pointer Add: BB x ref x int --> ref */
1207                         (mode_is_reference(op1mode) && mode_is_int(op2mode) && op1mode == mymode) ||
1208                         /* Pointer Add: BB x int x ref --> ref */
1209                         (mode_is_int(op1mode) && op2mode == mymode && mode_is_reference(mymode))
1210                 ),
1211                 "Add node", 0,
1212                 show_binop_failure(n, "/* common Add: BB x numP x numP --> numP */ |\n"
1213                         "/* Pointer Add: BB x ref x int --> ref */   |\n"
1214                         "/* Pointer Add: BB x int x ref --> ref */");
1215         );
1216         return 1;
1217 }
1218
1219 /**
1220  * verify a Sub node
1221  */
1222 static int verify_node_Sub(ir_node *n, ir_graph *irg)
1223 {
1224         ir_mode *mymode  = get_irn_mode(n);
1225         ir_mode *op1mode = get_irn_mode(get_Sub_left(n));
1226         ir_mode *op2mode = get_irn_mode(get_Sub_right(n));
1227         (void) irg;
1228
1229         ASSERT_AND_RET_DBG(
1230                 (
1231                         /* common Sub: BB x numP x numP --> numP */
1232                         (mymode ==op1mode && mymode == op2mode && mode_is_data(op1mode)) ||
1233                         /* Pointer Sub: BB x ref x int --> ref */
1234                         (op1mode == mymode && mode_is_int(op2mode) && mode_is_reference(mymode)) ||
1235                         /* Pointer Sub: BB x ref x ref --> int */
1236                         (op1mode == op2mode && mode_is_reference(op2mode) && mode_is_int(mymode))
1237                 ),
1238                 "Sub node", 0,
1239                 show_binop_failure(n, "/* common Sub: BB x numP x numP --> numP */ |\n"
1240                         "/* Pointer Sub: BB x ref x int --> ref */   |\n"
1241                         "/* Pointer Sub: BB x ref x ref --> int */" );
1242                 );
1243         return 1;
1244 }
1245
1246 /**
1247  * verify a Minus node
1248  */
1249 static int verify_node_Minus(ir_node *n, ir_graph *irg)
1250 {
1251         ir_mode *mymode  = get_irn_mode(n);
1252         ir_mode *op1mode = get_irn_mode(get_Minus_op(n));
1253         (void) irg;
1254
1255         ASSERT_AND_RET_DBG(
1256                 /* Minus: BB x num --> num */
1257                 op1mode == mymode && mode_is_num(op1mode), "Minus node", 0,
1258                 show_unop_failure(n , "/* Minus: BB x num --> num */");
1259         );
1260         return 1;
1261 }
1262
1263 /**
1264  * verify a Mul node
1265  */
1266 static int verify_node_Mul(ir_node *n, ir_graph *irg)
1267 {
1268         ir_mode *mymode  = get_irn_mode(n);
1269         ir_mode *op1mode = get_irn_mode(get_Mul_left(n));
1270         ir_mode *op2mode = get_irn_mode(get_Mul_right(n));
1271         (void) irg;
1272
1273         ASSERT_AND_RET_DBG(
1274                 (
1275                         /* Mul: BB x int_n x int_n --> int_n|int_2n */
1276                         (mode_is_int(op1mode)   && op2mode == op1mode && mode_is_int(mymode) &&
1277                          (op1mode == mymode || get_mode_size_bits(op1mode) * 2 == get_mode_size_bits(mymode))) ||
1278                         /* Mul: BB x float x float --> float */
1279                         (mode_is_float(op1mode) && op2mode == op1mode && mymode == op1mode)
1280                 ),
1281                 "Mul node",0,
1282                 show_binop_failure(n, "/* Mul: BB x int_n x int_n --> int_n|int_2n */ |\n"
1283                 "/* Mul: BB x float x float --> float */");
1284         );
1285         return 1;
1286 }
1287
1288 /**
1289  * verify a Mulh node
1290  */
1291 static int verify_node_Mulh(ir_node *n, ir_graph *irg)
1292 {
1293         ir_mode *mymode  = get_irn_mode(n);
1294         ir_mode *op1mode = get_irn_mode(get_Mulh_left(n));
1295         ir_mode *op2mode = get_irn_mode(get_Mulh_right(n));
1296         (void) irg;
1297
1298         ASSERT_AND_RET_DBG(
1299                 (
1300                         /* Mulh: BB x int x int --> int */
1301                         (mode_is_int(op1mode) && op2mode == op1mode && op1mode == mymode)
1302                 ),
1303                 "Mulh node",0,
1304                 show_binop_failure(n, "/* Mulh: BB x int x int --> int */");
1305         );
1306         return 1;
1307 }
1308
1309 /**
1310  * verify a Quot node
1311  */
1312 static int verify_node_Quot(ir_node *n, ir_graph *irg)
1313 {
1314         ir_mode *mymode  = get_irn_mode(n);
1315         ir_mode *op1mode = get_irn_mode(get_Quot_mem(n));
1316         ir_mode *op2mode = get_irn_mode(get_Quot_left(n));
1317         ir_mode *op3mode = get_irn_mode(get_Quot_right(n));
1318         (void) irg;
1319
1320         ASSERT_AND_RET_DBG(
1321                 /* Quot: BB x M x float x float --> M x X x float */
1322                 op1mode == mode_M && op2mode == op3mode &&
1323                 get_mode_sort(op2mode) == irms_float_number &&
1324                 mymode == mode_T,
1325                 "Quot node",0,
1326                 show_binop_failure(n, "/* Quot: BB x M x float x float --> M x X x float */");
1327         );
1328         return 1;
1329 }
1330
1331 /**
1332  * verify a DivMod node
1333  */
1334 static int verify_node_DivMod(ir_node *n, ir_graph *irg)
1335 {
1336         ir_mode *mymode  = get_irn_mode(n);
1337         ir_mode *op1mode = get_irn_mode(get_DivMod_mem(n));
1338         ir_mode *op2mode = get_irn_mode(get_DivMod_left(n));
1339         ir_mode *op3mode = get_irn_mode(get_DivMod_right(n));
1340         (void) irg;
1341
1342         ASSERT_AND_RET(
1343                 /* DivMod: BB x M x int x int --> M x X x int x int */
1344                 op1mode == mode_M &&
1345                 mode_is_int(op2mode) &&
1346                 op3mode == op2mode &&
1347                 mymode == mode_T,
1348                 "DivMod node", 0
1349                 );
1350         return 1;
1351 }
1352
1353 /**
1354  * verify a Div node
1355  */
1356 static int verify_node_Div(ir_node *n, ir_graph *irg)
1357 {
1358         ir_mode *mymode  = get_irn_mode(n);
1359         ir_mode *op1mode = get_irn_mode(get_Div_mem(n));
1360         ir_mode *op2mode = get_irn_mode(get_Div_left(n));
1361         ir_mode *op3mode = get_irn_mode(get_Div_right(n));
1362         (void) irg;
1363
1364         ASSERT_AND_RET(
1365                 /* Div: BB x M x int x int --> M x X x int */
1366                 op1mode == mode_M &&
1367                 op2mode == op3mode &&
1368                 mode_is_int(op2mode) &&
1369                 mymode == mode_T,
1370                 "Div node", 0
1371                 );
1372         return 1;
1373 }
1374
1375 /**
1376  * verify a Mod node
1377  */
1378 static int verify_node_Mod(ir_node *n, ir_graph *irg)
1379 {
1380         ir_mode *mymode  = get_irn_mode(n);
1381         ir_mode *op1mode = get_irn_mode(get_Mod_mem(n));
1382         ir_mode *op2mode = get_irn_mode(get_Mod_left(n));
1383         ir_mode *op3mode = get_irn_mode(get_Mod_right(n));
1384         (void) irg;
1385
1386         ASSERT_AND_RET(
1387                 /* Mod: BB x M x int x int --> M x X x int */
1388                 op1mode == mode_M &&
1389                 op2mode == op3mode &&
1390                 mode_is_int(op2mode) &&
1391                 mymode == mode_T,
1392                 "Mod node", 0
1393                 );
1394         return 1;
1395 }
1396
1397 /**
1398  * verify a logical And, Or, Eor node
1399  */
1400 static int verify_node_Logic(ir_node *n, ir_graph *irg)
1401 {
1402         ir_mode *mymode  = get_irn_mode(n);
1403         ir_mode *op1mode = get_irn_mode(get_binop_left(n));
1404         ir_mode *op2mode = get_irn_mode(get_binop_right(n));
1405         (void) irg;
1406
1407         ASSERT_AND_RET_DBG(
1408                 /* And or Or or Eor: BB x int x int --> int */
1409                 (mode_is_int(mymode) || mymode == mode_b) &&
1410                 op2mode == op1mode &&
1411                 mymode == op2mode,
1412                 "And, Or or Eor node", 0,
1413                 show_binop_failure(n, "/* And or Or or Eor: BB x int x int --> int */");
1414         );
1415         return 1;
1416 }
1417
1418 #define verify_node_And   verify_node_Logic
1419 #define verify_node_Or    verify_node_Logic
1420 #define verify_node_Eor   verify_node_Logic
1421
1422 /**
1423  * verify a Not node
1424  */
1425 static int verify_node_Not(ir_node *n, ir_graph *irg)
1426 {
1427         ir_mode *mymode  = get_irn_mode(n);
1428         ir_mode *op1mode = get_irn_mode(get_Not_op(n));
1429         (void) irg;
1430
1431         ASSERT_AND_RET_DBG(
1432                 /* Not: BB x int --> int */
1433                 (mode_is_int(mymode) || mymode == mode_b) &&
1434                 mymode == op1mode,
1435                 "Not node", 0,
1436                 show_unop_failure(n, "/* Not: BB x int --> int */");
1437         );
1438         return 1;
1439 }
1440
1441 /**
1442  * verify a Cmp node
1443  */
1444 static int verify_node_Cmp(ir_node *n, ir_graph *irg)
1445 {
1446         ir_mode *mymode  = get_irn_mode(n);
1447         ir_mode *op1mode = get_irn_mode(get_Cmp_left(n));
1448         ir_mode *op2mode = get_irn_mode(get_Cmp_right(n));
1449         (void) irg;
1450
1451         ASSERT_AND_RET_DBG(
1452                 /* Cmp: BB x datab x datab --> b16 */
1453                 mode_is_datab(op1mode) &&
1454                 op2mode == op1mode &&
1455                 mymode == mode_T,
1456                 "Cmp node", 0,
1457                 show_binop_failure(n, "/* Cmp: BB x datab x datab --> b16 */");
1458         );
1459         return 1;
1460 }
1461
1462 /**
1463  * verify a Shift node
1464  */
1465 static int verify_node_Shift(ir_node *n, ir_graph *irg)
1466 {
1467         ir_mode *mymode  = get_irn_mode(n);
1468         ir_mode *op1mode = get_irn_mode(get_binop_left(n));
1469         ir_mode *op2mode = get_irn_mode(get_binop_right(n));
1470         (void) irg;
1471
1472         ASSERT_AND_RET_DBG(
1473                 /* Shl, Shr or Shrs: BB x int x int_u --> int */
1474                 mode_is_int(op1mode) &&
1475                 mode_is_int(op2mode) &&
1476                 !mode_is_signed(op2mode) &&
1477                 mymode == op1mode,
1478                 "Shl, Shr or Shrs node", 0,
1479                 show_binop_failure(n, "/* Shl, Shr or Shrs: BB x int x int_u --> int */");
1480         );
1481         return 1;
1482 }
1483
1484 #define verify_node_Shl   verify_node_Shift
1485 #define verify_node_Shr   verify_node_Shift
1486 #define verify_node_Shrs  verify_node_Shift
1487
1488 /**
1489  * verify a Rotl node
1490  */
1491 static int verify_node_Rotl(ir_node *n, ir_graph *irg)
1492 {
1493         ir_mode *mymode  = get_irn_mode(n);
1494         ir_mode *op1mode = get_irn_mode(get_Rotl_left(n));
1495         ir_mode *op2mode = get_irn_mode(get_Rotl_right(n));
1496         (void) irg;
1497
1498         ASSERT_AND_RET_DBG(
1499                 /* Rotl: BB x int x int --> int */
1500                 mode_is_int(op1mode) &&
1501                 mode_is_int(op2mode) &&
1502                 mymode == op1mode,
1503                 "Rotl node", 0,
1504                 show_binop_failure(n, "/* Rotl: BB x int x int --> int */");
1505         );
1506         return 1;
1507 }
1508
1509 /**
1510  * verify a Conv node
1511  */
1512 static int verify_node_Conv(ir_node *n, ir_graph *irg)
1513 {
1514         ir_mode *mymode  = get_irn_mode(n);
1515         ir_mode *op1mode = get_irn_mode(get_Conv_op(n));
1516         (void) irg;
1517
1518         ASSERT_AND_RET_DBG(
1519                 is_irg_state(irg, IR_GRAPH_STATE_BCONV_ALLOWED) ||
1520                 (mode_is_datab(op1mode) && mode_is_data(mymode)),
1521                 "Conv node", 0,
1522                 show_unop_failure(n, "/* Conv: BB x datab --> data */");
1523         );
1524         return 1;
1525 }
1526
1527 /**
1528  * verify a Cast node
1529  */
1530 static int verify_node_Cast(ir_node *n, ir_graph *irg)
1531 {
1532         ir_mode *mymode  = get_irn_mode(n);
1533         ir_mode *op1mode = get_irn_mode(get_Cast_op(n));
1534         (void) irg;
1535
1536         ASSERT_AND_RET_DBG(
1537                 /* Conv: BB x datab1 --> datab2 */
1538                 mode_is_data(op1mode) && op1mode == mymode,
1539                 "Cast node", 0,
1540                 show_unop_failure(n, "/* Conv: BB x datab1 --> datab2 */");
1541         );
1542         return 1;
1543 }
1544
1545 /**
1546  * verify a Phi node
1547  */
1548 static int verify_node_Phi(ir_node *n, ir_graph *irg)
1549 {
1550         ir_mode *mymode = get_irn_mode(n);
1551         ir_node *block  = get_nodes_block(n);
1552         int i;
1553         (void) irg;
1554
1555         /* a Phi node MUST have the same number of inputs as its block
1556          * Exception is a phi with 0 inputs which is used when (re)constructing the
1557          * SSA form */
1558         if (! is_Bad(block) && get_irg_phase_state(get_irn_irg(n)) != phase_building && get_irn_arity(n) > 0) {
1559                 ASSERT_AND_RET_DBG(
1560                         get_irn_arity(n) == get_irn_arity(block),
1561                         "wrong number of inputs in Phi node", 0,
1562                         show_phi_inputs(n, block);
1563                 );
1564         }
1565
1566         /* Phi: BB x dataM^n --> dataM */
1567         for (i = get_Phi_n_preds(n) - 1; i >= 0; --i) {
1568                 ir_node *pred = get_Phi_pred(n, i);
1569                 if (!is_Bad(pred)) {
1570                         ASSERT_AND_RET_DBG(
1571                                 get_irn_mode(pred) == mymode,
1572                                 "Phi node", 0,
1573                                 show_phi_failure(n, pred, i);
1574                         );
1575                 }
1576         }
1577         ASSERT_AND_RET(mode_is_dataM(mymode) || mymode == mode_b, "Phi node", 0 );
1578
1579         if (mymode == mode_M) {
1580                 for (i = get_Phi_n_preds(n) - 1; i >= 0; --i) {
1581                         int j;
1582                         ir_node *pred_i = get_Phi_pred(n, i);
1583
1584                         if (is_Bad(pred_i))
1585                                 continue;
1586                         for (j = i - 1; j >= 0; --j) {
1587                                 ir_node *pred_j = get_Phi_pred(n, j);
1588
1589                                 if (is_Bad(pred_j))
1590                                         continue;
1591 #if 0
1592                                 /* currently this checks fails for blocks with exception
1593                                    outputs (and these are NOT basic blocks).  So it is disabled yet. */
1594                                 ASSERT_AND_RET_DBG(
1595                                         (pred_i == pred_j) || (get_irn_n(pred_i, -1) != get_irn_n(pred_j, -1)),
1596                                         "At least two different PhiM predecessors are in the same block",
1597                                         0,
1598                                         ir_printf("%+F and %+F of %+F are in %+F\n", pred_i, pred_j, n, get_irn_n(pred_i, -1))
1599                                 );
1600 #endif
1601                         }
1602                 }
1603         }
1604         return 1;
1605 }
1606
1607 /**
1608  * verify a Load node
1609  */
1610 static int verify_node_Load(ir_node *n, ir_graph *irg)
1611 {
1612         ir_mode *mymode  = get_irn_mode(n);
1613         ir_mode *op1mode = get_irn_mode(get_Load_mem(n));
1614         ir_mode *op2mode = get_irn_mode(get_Load_ptr(n));
1615
1616         ASSERT_AND_RET(op1mode == mode_M, "Load node", 0);
1617         if (get_irg_phase_state(irg) != phase_backend) {
1618                 ASSERT_AND_RET(mode_is_reference(op2mode), "Load node", 0 );
1619         }
1620         ASSERT_AND_RET( mymode == mode_T, "Load node", 0 );
1621
1622         /*
1623          * jack's gen_add_firm_code:simpleSel seems to build Load (Load
1624          * (Proj (Proj))) sometimes ...
1625
1626          * interprete.c:ai_eval seems to assume that this happens, too
1627
1628          * obset.c:get_abstval_any can't deal with this if the load has
1629          * mode_T
1630          *
1631           {
1632           ir_entity *ent = hunt_for_entity (get_Load_ptr (n), n);
1633           assert ((NULL != ent) || (mymode != mode_T));
1634           }
1635          */
1636
1637         return 1;
1638 }
1639
1640 /**
1641  * verify a Store node
1642  */
1643 static int verify_node_Store(ir_node *n, ir_graph *irg)
1644 {
1645         ir_entity *target;
1646
1647         ir_mode *mymode  = get_irn_mode(n);
1648         ir_mode *op1mode = get_irn_mode(get_Store_mem(n));
1649         ir_mode *op2mode = get_irn_mode(get_Store_ptr(n));
1650         ir_mode *op3mode = get_irn_mode(get_Store_value(n));
1651
1652         ASSERT_AND_RET(op1mode == mode_M && mode_is_datab(op3mode), "Store node", 0 );
1653         if (get_irg_phase_state(irg) != phase_backend) {
1654                 ASSERT_AND_RET(mode_is_reference(op2mode), "Store node", 0 );
1655         }
1656         ASSERT_AND_RET(mymode == mode_T, "Store node", 0);
1657
1658         target = get_ptr_entity(get_Store_ptr(n));
1659         if (verify_entities && target && get_irg_phase_state(irg) == phase_high) {
1660                 /*
1661                  * If lowered code, any Sels that add 0 may be removed, causing
1662                  * an direct access to entities of array or compound type.
1663                  * Prevent this by checking the phase.
1664                  */
1665                 ASSERT_AND_RET( op3mode == get_type_mode(get_entity_type(target)),
1666                         "Store node", 0);
1667         }
1668
1669         return 1;
1670 }
1671
1672 /**
1673  * verify an Alloc node
1674  */
1675 static int verify_node_Alloc(ir_node *n, ir_graph *irg)
1676 {
1677         ir_mode *mymode  = get_irn_mode(n);
1678         ir_mode *op1mode = get_irn_mode(get_Alloc_mem(n));
1679         ir_mode *op2mode = get_irn_mode(get_Alloc_count(n));
1680         (void) irg;
1681
1682         ASSERT_AND_RET_DBG(
1683                 /* Alloc: BB x M x int_u --> M x X x ref */
1684                 op1mode == mode_M &&
1685                 mode_is_int(op2mode) &&
1686                 !mode_is_signed(op2mode) &&
1687                 mymode == mode_T,
1688                 "Alloc node", 0,
1689                 show_node_failure(n);
1690         );
1691         return 1;
1692 }
1693
1694 /**
1695  * verify a Free node
1696  */
1697 static int verify_node_Free(ir_node *n, ir_graph *irg)
1698 {
1699         ir_mode *mymode  = get_irn_mode(n);
1700         ir_mode *op1mode = get_irn_mode(get_Free_mem(n));
1701         ir_mode *op2mode = get_irn_mode(get_Free_ptr(n));
1702         ir_mode *op3mode = get_irn_mode(get_Free_size(n));
1703         (void) irg;
1704
1705         ASSERT_AND_RET_DBG(
1706                 /* Free: BB x M x ref x int_u --> M */
1707                 op1mode == mode_M && mode_is_reference(op2mode) &&
1708                 mode_is_int(op3mode) &&
1709                 !mode_is_signed(op3mode) &&
1710                 mymode == mode_M,
1711                 "Free node", 0,
1712                 show_triop_failure(n, "/* Free: BB x M x ref x int_u --> M */");
1713         );
1714         return 1;
1715 }
1716
1717 /**
1718  * verify a Sync node
1719  */
1720 static int verify_node_Sync(ir_node *n, ir_graph *irg)
1721 {
1722         int i;
1723         ir_mode *mymode  = get_irn_mode(n);
1724         (void) irg;
1725
1726         /* Sync: BB x M^n --> M */
1727         for (i = get_Sync_n_preds(n) - 1; i >= 0; --i) {
1728                 ASSERT_AND_RET( get_irn_mode(get_Sync_pred(n, i)) == mode_M, "Sync node", 0 );
1729         };
1730         ASSERT_AND_RET( mymode == mode_M, "Sync node", 0 );
1731         return 1;
1732 }
1733
1734 /**
1735  * verify a Confirm node
1736  */
1737 static int verify_node_Confirm(ir_node *n, ir_graph *irg)
1738 {
1739         ir_mode *mymode  = get_irn_mode(n);
1740         ir_mode *op1mode = get_irn_mode(get_Confirm_value(n));
1741         ir_mode *op2mode = get_irn_mode(get_Confirm_bound(n));
1742         (void) irg;
1743
1744         ASSERT_AND_RET_DBG(
1745                 /* Confirm: BB x T x T --> T */
1746                 op1mode == mymode &&
1747                 op2mode == mymode,
1748                 "Confirm node", 0,
1749                 show_binop_failure(n, "/* Confirm: BB x T x T --> T */");
1750         );
1751         return 1;
1752 }
1753
1754 /**
1755  * verify a Mux node
1756  */
1757 static int verify_node_Mux(ir_node *n, ir_graph *irg)
1758 {
1759         ir_mode *mymode  = get_irn_mode(n);
1760         ir_mode *op1mode = get_irn_mode(get_Mux_sel(n));
1761         ir_mode *op2mode = get_irn_mode(get_Mux_true(n));
1762         ir_mode *op3mode = get_irn_mode(get_Mux_false(n));
1763         (void) irg;
1764
1765         ASSERT_AND_RET(
1766                 /* Mux: BB x b x datab x datab --> datab */
1767                 op1mode == mode_b &&
1768                 op2mode == mymode &&
1769                 op3mode == mymode &&
1770                 mode_is_datab(mymode),
1771                 "Mux node", 0
1772                 );
1773         return 1;
1774 }
1775
1776 /**
1777  * verify a CopyB node
1778  */
1779 static int verify_node_CopyB(ir_node *n, ir_graph *irg)
1780 {
1781         ir_mode *mymode  = get_irn_mode(n);
1782         ir_mode *op1mode = get_irn_mode(get_CopyB_mem(n));
1783         ir_mode *op2mode = get_irn_mode(get_CopyB_dst(n));
1784         ir_mode *op3mode = get_irn_mode(get_CopyB_src(n));
1785         ir_type *t = get_CopyB_type(n);
1786
1787         /* CopyB: BB x M x ref x ref --> M x X */
1788         ASSERT_AND_RET(mymode == mode_T && op1mode == mode_M, "CopyB node", 0);
1789         if (get_irg_phase_state(irg) != phase_backend) {
1790                 ASSERT_AND_RET(mode_is_reference(op2mode) && mode_is_reference(op3mode),
1791                         "CopyB node", 0 );
1792         }
1793
1794         ASSERT_AND_RET(
1795                 is_compound_type(t) || is_Array_type(t),
1796                 "CopyB node should copy compound types only", 0 );
1797
1798         /* NoMem nodes are only allowed as memory input if the CopyB is NOT pinned.
1799            This should happen RARELY, as CopyB COPIES MEMORY */
1800         ASSERT_AND_RET(verify_right_pinned(n), "CopyB node with wrong memory input", 0 );
1801         return 1;
1802 }
1803
1804 /**
1805  * verify a Bound node
1806  */
1807 static int verify_node_Bound(ir_node *n, ir_graph *irg)
1808 {
1809         ir_mode *mymode  = get_irn_mode(n);
1810         ir_mode *op1mode = get_irn_mode(get_Bound_mem(n));
1811         ir_mode *op2mode = get_irn_mode(get_Bound_index(n));
1812         ir_mode *op3mode = get_irn_mode(get_Bound_lower(n));
1813         ir_mode *op4mode = get_irn_mode(get_Bound_upper(n));
1814         (void) irg;
1815
1816         /* Bound: BB x M x int x int x int --> M x X */
1817         ASSERT_AND_RET(
1818                 mymode == mode_T &&
1819                 op1mode == mode_M &&
1820                 op2mode == op3mode &&
1821                 op3mode == op4mode &&
1822                 mode_is_int(op3mode),
1823                 "Bound node", 0 );
1824         return 1;
1825 }
1826
1827 /**
1828  * Check dominance.
1829  * For each usage of a node, it is checked, if the block of the
1830  * node dominates the block of the usage (for phis: the predecessor
1831  * block of the phi for the corresponding edge).
1832  *
1833  * @return non-zero on success, 0 on dominance error
1834  */
1835 static int check_dominance_for_node(ir_node *use)
1836 {
1837         /* This won't work for blocks and the end node */
1838         if (!is_Block(use) && !is_End(use) && !is_Anchor(use)) {
1839                 int i;
1840                 ir_node *bl = get_nodes_block(use);
1841
1842                 for (i = get_irn_arity(use) - 1; i >= 0; --i) {
1843                         ir_node *def    = get_irn_n(use, i);
1844                         ir_node *def_bl = get_nodes_block(def);
1845                         ir_node *use_bl = bl;
1846                         ir_graph *irg;
1847
1848                         /* ignore dead definition blocks, will be removed */
1849                         if (is_Block_dead(def_bl) || get_Block_dom_depth(def_bl) == -1)
1850                                 continue;
1851
1852                         if (is_Phi(use))
1853                                 use_bl = get_Block_cfgpred_block(bl, i);
1854
1855                         /* ignore dead use blocks, will be removed */
1856                         if (is_Block_dead(use_bl) || get_Block_dom_depth(use_bl) == -1)
1857                                 continue;
1858
1859                         irg = get_irn_irg(use);
1860                         ASSERT_AND_RET_DBG(
1861                                 block_dominates(def_bl, use_bl),
1862                                 "the definition of a value used violates the dominance property", 0,
1863                                 ir_fprintf(stderr,
1864                                 "graph %+F: %+F of %+F must dominate %+F of user %+F input %d\n",
1865                                 irg, def_bl, def, use_bl, use, i
1866                                 );
1867                         );
1868                 }
1869         }
1870         return 1;
1871 }
1872
1873 /* Tests the modes of n and its predecessors. */
1874 int irn_verify_irg(ir_node *n, ir_graph *irg)
1875 {
1876         int i;
1877         ir_op *op;
1878
1879         if (!get_node_verification_mode())
1880                 return 1;
1881
1882         /*
1883          * do NOT check placement in interprocedural view, as we don't always
1884          * know the "right" graph ...
1885          */
1886
1887 #ifndef NDEBUG
1888         /* this is an expensive check for large graphs (it has a quadratic
1889          * runtime but with a small constant); so do NOT run it in release mode
1890          */
1891         ASSERT_AND_RET_DBG(
1892                 node_is_in_irgs_storage(irg, n),
1893                 "Node is not stored on proper IR graph!", 0,
1894                 show_node_on_graph(irg, n);
1895         );
1896 #endif
1897         assert(get_irn_irg(n) == irg);
1898         {
1899                 unsigned idx           = get_irn_idx(n);
1900                 ir_node *node_from_map = get_idx_irn(irg, idx);
1901                 ASSERT_AND_RET_DBG(node_from_map == n, "Node index and index map entry differ", 0,
1902                         ir_printf("node %+F node in map %+F(%p)\n", n, node_from_map, node_from_map));
1903         }
1904
1905         op = get_irn_op(n);
1906
1907         /* We don't want to test nodes whose predecessors are Bad,
1908            as we would have to special case that for each operation. */
1909         if (op != op_Phi && op != op_Block) {
1910                 for (i = get_irn_arity(n) - 1; i >= 0; --i) {
1911                         if (is_Bad(get_irn_n(n, i)))
1912                                 return 1;
1913                 }
1914         }
1915
1916         if (_get_op_pinned(op) >= op_pin_state_exc_pinned) {
1917                 op_pin_state state = get_irn_pinned(n);
1918                 ASSERT_AND_RET_DBG(
1919                         state == op_pin_state_floats ||
1920                         state == op_pin_state_pinned,
1921                         "invalid pin state", 0,
1922                         ir_printf("node %+F", n));
1923         }
1924
1925         if (op->ops.verify_node)
1926                 return op->ops.verify_node(n, irg);
1927
1928         /* All went ok */
1929         return 1;
1930 }
1931
1932 int irn_verify(ir_node *n)
1933 {
1934 #ifdef DEBUG_libfirm
1935         return irn_verify_irg(n, get_irn_irg(n));
1936 #else
1937         (void)n;
1938         return 1;
1939 #endif
1940 }
1941
1942 /*-----------------------------------------------------------------*/
1943 /* Verify the whole graph.                                         */
1944 /*-----------------------------------------------------------------*/
1945
1946 #ifdef DEBUG_libfirm
1947 /**
1948  * Walker to check every node
1949  */
1950 static void verify_wrap(ir_node *node, void *env)
1951 {
1952         int *res = (int*)env;
1953         *res = irn_verify_irg(node, get_irn_irg(node));
1954 }
1955
1956 /**
1957  * Walker to check every node including SSA property.
1958  * Only called if dominance info is available.
1959  */
1960 static void verify_wrap_ssa(ir_node *node, void *env)
1961 {
1962         int *res = (int*)env;
1963
1964         *res = irn_verify_irg(node, get_irn_irg(node));
1965         if (*res) {
1966                 *res = check_dominance_for_node(node);
1967         }
1968 }
1969
1970 #endif /* DEBUG_libfirm */
1971
1972 /*
1973  * Calls irn_verify for each node in irg.
1974  * Graph must be in state "op_pin_state_pinned".
1975  * If dominance info is available, check the SSA property.
1976  */
1977 int irg_verify(ir_graph *irg, unsigned flags)
1978 {
1979         int res = 1;
1980 #ifdef DEBUG_libfirm
1981
1982 #ifndef NDEBUG
1983     last_irg_error = NULL;
1984 #endif /* NDEBUG */
1985
1986         assert(get_irg_pinned(irg) == op_pin_state_pinned && "Verification need pinned graph");
1987
1988         if (flags & VERIFY_ENFORCE_SSA)
1989                 compute_doms(irg);
1990
1991         irg_walk_anchors(
1992                 irg,
1993                 get_irg_dom_state(irg) == dom_consistent &&
1994                 get_irg_pinned(irg) == op_pin_state_pinned ? verify_wrap_ssa : verify_wrap,
1995                 NULL, &res
1996         );
1997
1998         if (get_node_verification_mode() == FIRM_VERIFICATION_REPORT && ! res) {
1999                 ir_entity *ent = get_irg_entity(irg);
2000
2001                 if (ent)
2002                         fprintf(stderr, "irg_verify: Verifying graph %s failed\n", get_entity_name(ent));
2003                 else
2004                         fprintf(stderr, "irg_verify: Verifying graph %p failed\n", (void *)irg);
2005         }
2006
2007 #else
2008         (void)irg;
2009         (void)flags;
2010 #endif /* DEBUG_libfirm */
2011
2012         return res;
2013 }
2014
2015 typedef struct pass_t {
2016         ir_graph_pass_t pass;
2017         unsigned        flags;
2018 } pass_t;
2019
2020 /**
2021  * Wrapper to irg_verify to be run as an ir_graph pass.
2022  */
2023 static int irg_verify_wrapper(ir_graph *irg, void *context)
2024 {
2025         pass_t *pass = (pass_t*)context;
2026         irg_verify(irg, pass->flags);
2027         /* do NOT rerun the pass if verify is ok :-) */
2028         return 0;
2029 }
2030
2031 /* Creates an ir_graph pass for irg_verify(). */
2032 ir_graph_pass_t *irg_verify_pass(const char *name, unsigned flags)
2033 {
2034         pass_t *pass = XMALLOCZ(pass_t);
2035
2036         def_graph_pass_constructor(
2037                 &pass->pass, name ? name : "irg_verify", irg_verify_wrapper);
2038
2039         /* neither dump for verify */
2040         pass->pass.dump_irg   = (DUMP_ON_IRG_FUNC)ir_prog_no_dump;
2041         pass->pass.verify_irg = (RUN_ON_IRG_FUNC)ir_prog_no_verify;
2042
2043         pass->flags = flags;
2044         return &pass->pass;
2045 }
2046
2047 /* create a verify pass */
2048 int irn_verify_irg_dump(ir_node *n, ir_graph *irg, const char **bad_string)
2049 {
2050         int res;
2051         firm_verification_t old = get_node_verification_mode();
2052
2053         firm_verify_failure_msg = NULL;
2054         do_node_verification(FIRM_VERIFICATION_ERROR_ONLY);
2055         res = irn_verify_irg(n, irg);
2056         if (res && get_irg_dom_state(irg) == dom_consistent &&
2057             get_irg_pinned(irg) == op_pin_state_pinned)
2058                 res = check_dominance_for_node(n);
2059         do_node_verification(old);
2060         *bad_string = firm_verify_failure_msg;
2061
2062         return res;
2063 }
2064
2065 typedef struct verify_bad_env_t {
2066         int flags;
2067         int res;
2068 } verify_bad_env_t;
2069
2070 /**
2071  * Pre-Walker: check Bad predecessors of node.
2072  */
2073 static void check_bads(ir_node *node, void *env)
2074 {
2075         verify_bad_env_t *venv = (verify_bad_env_t*)env;
2076         int i, arity = get_irn_arity(node);
2077         ir_graph *irg = get_irn_irg(node);
2078
2079         if (is_Block(node)) {
2080                 if ((venv->flags & BAD_CF) == 0) {
2081
2082                         /* check for Bad Block predecessor */
2083                         for (i = 0; i < arity; ++i) {
2084                                 ir_node *pred = get_irn_n(node, i);
2085
2086                                 if (is_Bad(pred)) {
2087                                         venv->res |= BAD_CF;
2088
2089                                         if (get_node_verification_mode() == FIRM_VERIFICATION_REPORT) {
2090                                                 fprintf(stderr, "irg_verify_bads: Block %ld has Bad predecessor\n", get_irn_node_nr(node));
2091                                         }
2092                                         if (get_node_verification_mode() == FIRM_VERIFICATION_ON) {
2093                                                 dump_ir_graph(irg, "-assert");
2094                                                 assert(0 && "Bad CF detected");
2095                                         }
2096                                 }
2097                         }
2098                 }
2099         } else {
2100                 if ((venv->flags & BAD_BLOCK) == 0) {
2101
2102                         /* check for Bad Block */
2103                         if (is_Bad(get_nodes_block(node))) {
2104                                 venv->res |= BAD_BLOCK;
2105
2106                                 if (get_node_verification_mode() == FIRM_VERIFICATION_REPORT) {
2107                                         fprintf(stderr, "irg_verify_bads: node %ld has Bad Block\n", get_irn_node_nr(node));
2108                                 }
2109                                 if (get_node_verification_mode() == FIRM_VERIFICATION_ON) {
2110                                         dump_ir_graph(irg, "-assert");
2111                                         assert(0 && "Bad CF detected");
2112                                 }
2113                         }
2114                 }
2115
2116                 if ((venv->flags & TUPLE) == 0) {
2117                         if (is_Tuple(node)) {
2118                                 venv->res |= TUPLE;
2119
2120                                 if (get_node_verification_mode() == FIRM_VERIFICATION_REPORT) {
2121                                         fprintf(stderr, "irg_verify_bads: node %ld is a Tuple\n", get_irn_node_nr(node));
2122                                 }
2123                                 if (get_node_verification_mode() == FIRM_VERIFICATION_ON) {
2124                                         dump_ir_graph(irg, "-assert");
2125                                         assert(0 && "Tuple detected");
2126                                 }
2127                         }
2128                 }
2129
2130                 for (i = 0; i < arity; ++i) {
2131                         ir_node *pred = get_irn_n(node, i);
2132
2133                         if (is_Bad(pred)) {
2134                                 /* check for Phi with Bad inputs */
2135                                 if (is_Phi(node) && !is_Bad(get_nodes_block(node)) && is_Bad(get_irn_n(get_nodes_block(node), i))) {
2136                                         if (venv->flags & BAD_CF)
2137                                                 continue;
2138                                         else {
2139                                                 venv->res |= BAD_CF;
2140
2141                                                 if (get_node_verification_mode() == FIRM_VERIFICATION_REPORT) {
2142                                                         fprintf(stderr, "irg_verify_bads: Phi %ld has Bad Input\n", get_irn_node_nr(node));
2143                                                 }
2144                                                 if (get_node_verification_mode() == FIRM_VERIFICATION_ON) {
2145                                                         dump_ir_graph(irg, "-assert");
2146                                                         assert(0 && "Bad CF detected");
2147                                                 }
2148                                         }
2149                                 }
2150
2151                                 /* Bad node input */
2152                                 if ((venv->flags & BAD_DF) == 0) {
2153                                         venv->res |= BAD_DF;
2154
2155                                         if (get_node_verification_mode() == FIRM_VERIFICATION_REPORT) {
2156                                                 fprintf(stderr, "irg_verify_bads: node %ld has Bad Input\n", get_irn_node_nr(node));
2157                                         }
2158                                         if (get_node_verification_mode() == FIRM_VERIFICATION_ON) {
2159                                                 dump_ir_graph(irg, "-assert");
2160                                                 assert(0 && "Bad NON-CF detected");
2161                                         }
2162                                 }
2163                         }
2164                 }
2165         }
2166 }
2167
2168 /*
2169  * verify occurrence of bad nodes
2170  */
2171 int irg_verify_bads(ir_graph *irg, int flags)
2172 {
2173         verify_bad_env_t env;
2174
2175         env.flags = flags;
2176         env.res   = 0;
2177
2178         irg_walk_graph(irg, check_bads, NULL, &env);
2179
2180         return env.res;
2181 }
2182
2183 /*
2184  * set the default verify operation
2185  */
2186 void firm_set_default_verifyer(ir_opcode code, ir_op_ops *ops)
2187 {
2188 #define CASE(a)                           \
2189    case iro_##a:                          \
2190      ops->verify_node  = verify_node_##a; \
2191      break
2192
2193         switch (code) {
2194         CASE(Proj);
2195         CASE(Block);
2196         CASE(Start);
2197         CASE(Jmp);
2198         CASE(IJmp);
2199         CASE(Cond);
2200         CASE(Return);
2201         CASE(Raise);
2202         CASE(Const);
2203         CASE(SymConst);
2204         CASE(Sel);
2205         CASE(InstOf);
2206         CASE(Call);
2207         CASE(Add);
2208         CASE(Sub);
2209         CASE(Minus);
2210         CASE(Mul);
2211         CASE(Mulh);
2212         CASE(Quot);
2213         CASE(DivMod);
2214         CASE(Div);
2215         CASE(Mod);
2216         CASE(And);
2217         CASE(Or);
2218         CASE(Eor);
2219         CASE(Not);
2220         CASE(Cmp);
2221         CASE(Shl);
2222         CASE(Shr);
2223         CASE(Shrs);
2224         CASE(Rotl);
2225         CASE(Conv);
2226         CASE(Cast);
2227         CASE(Phi);
2228         CASE(Load);
2229         CASE(Store);
2230         CASE(Alloc);
2231         CASE(Free);
2232         CASE(Sync);
2233         CASE(Confirm);
2234         CASE(Mux);
2235         CASE(CopyB);
2236         CASE(Bound);
2237         default:
2238                 /* leave NULL */;
2239         }
2240 #undef CASE
2241
2242 #define CASE(a)                          \
2243    case iro_##a:                         \
2244      ops->verify_proj_node  = verify_node_Proj_##a; \
2245      break
2246
2247         switch (code) {
2248         CASE(Start);
2249         CASE(Cond);
2250         CASE(Raise);
2251         CASE(InstOf);
2252         CASE(Call);
2253         CASE(Quot);
2254         CASE(DivMod);
2255         CASE(Div);
2256         CASE(Mod);
2257         CASE(Cmp);
2258         CASE(Load);
2259         CASE(Store);
2260         CASE(Alloc);
2261         CASE(Proj);
2262         CASE(Tuple);
2263         CASE(CopyB);
2264         CASE(Bound);
2265         default:
2266                 /* leave NULL */;
2267         }
2268 #undef CASE
2269 }