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